Refactor BranchConfiguration for improved encapsulation and re-usability

arturcic · arturcic · commit 5205799b5cb9 · 2023-10-07T20:05:36.000+02:00
This commit modifies EffectiveBranchConfiguration and NextVersion to encapsulate branch and configuration data. The changes focus on transforming some classes to records, thus creating better data structures. The countless changes in method calls from various strategies and calculators accommodate the revised data encapsulation. The intention behind this refactor is to enhance readability, reduce redundancy, and provide better design of the data structure. It is important to note that these modifications are not expected to change the existing behavior.
diff --git a/src/GitVersion.Core.Tests/Helpers/TestEffectiveConfiguration.cs b/src/GitVersion.Core.Tests/Helpers/TestEffectiveConfiguration.cs
@@ -4,7 +4,7 @@
 
 namespace GitVersion.Core.Tests.Helpers;
 
-public class TestEffectiveConfiguration : EffectiveConfiguration
+public record TestEffectiveConfiguration : EffectiveConfiguration
 {
     public TestEffectiveConfiguration(
         AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch,
diff --git a/src/GitVersion.Core.Tests/VersionCalculation/Strategies/ConfigNextVersionBaseVersionStrategyTests.cs b/src/GitVersion.Core.Tests/VersionCalculation/Strategies/ConfigNextVersionBaseVersionStrategyTests.cs
@@ -57,10 +57,8 @@ public void ConfigNextVersionTestShouldFail(string nextVersion, SemanticVersionF
         var strategy = contextBuilder.ServicesProvider.GetServiceForType<IVersionStrategy, ConfigNextVersionVersionStrategy>();
         var context = contextBuilder.ServicesProvider.GetRequiredService<Lazy<GitVersionContext>>().Value;
         var branchMock = GitToolsTestingExtensions.CreateMockBranch("main", GitToolsTestingExtensions.CreateMockCommit());
-        var branchConfiguration = context.Configuration.GetBranchConfiguration(branchMock);
-        var effectiveConfiguration = new EffectiveConfiguration(context.Configuration, branchConfiguration);
 
         strategy.ShouldNotBeNull();
-        return strategy.GetBaseVersions(new(branchMock, effectiveConfiguration)).SingleOrDefault();
+        return strategy.GetBaseVersions(context.Configuration.GetEffectiveBranchConfiguration(branchMock)).SingleOrDefault();
     }
 }
diff --git a/src/GitVersion.Core.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs b/src/GitVersion.Core.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs
@@ -35,11 +35,9 @@ public void ShouldNotAllowIncrementOfVersion()
         contextBuilder.ServicesProvider.ShouldNotBeNull();
         var strategy = contextBuilder.ServicesProvider.GetServiceForType<IVersionStrategy, MergeMessageVersionStrategy>();
         var context = contextBuilder.ServicesProvider.GetRequiredService<Lazy<GitVersionContext>>().Value;
-        var branchConfiguration = context.Configuration.GetBranchConfiguration(mockBranch);
-        var effectiveConfiguration = new EffectiveConfiguration(context.Configuration, branchConfiguration);
 
         strategy.ShouldNotBeNull();
-        var baseVersion = strategy.GetBaseVersions(new(mockBranch, effectiveConfiguration)).Single();
+        var baseVersion = strategy.GetBaseVersions(context.Configuration.GetEffectiveBranchConfiguration(mockBranch)).Single();
 
         baseVersion.ShouldIncrement.ShouldBe(false);
     }
@@ -168,11 +166,9 @@ private static void AssertMergeMessage(string message, string? expectedVersion,
         contextBuilder.ServicesProvider.ShouldNotBeNull();
         var strategy = contextBuilder.ServicesProvider.GetServiceForType<IVersionStrategy, MergeMessageVersionStrategy>();
         var context = contextBuilder.ServicesProvider.GetRequiredService<Lazy<GitVersionContext>>().Value;
-        var branchConfiguration = context.Configuration.GetBranchConfiguration(mockBranch);
-        var effectiveConfiguration = new EffectiveConfiguration(context.Configuration, branchConfiguration);
 
         strategy.ShouldNotBeNull();
-        var baseVersion = strategy.GetBaseVersions(new(mockBranch, effectiveConfiguration)).SingleOrDefault();
+        var baseVersion = strategy.GetBaseVersions(context.Configuration.GetEffectiveBranchConfiguration(mockBranch)).SingleOrDefault();
 
         if (expectedVersion == null)
         {
diff --git a/src/GitVersion.Core.Tests/VersionCalculation/Strategies/VersionInBranchNameBaseVersionStrategyTests.cs b/src/GitVersion.Core.Tests/VersionCalculation/Strategies/VersionInBranchNameBaseVersionStrategyTests.cs
@@ -23,9 +23,7 @@ public void CanTakeVersionFromNameOfReleaseBranch(string branchName, string expe
         var branch = repository.FindBranch(branchName);
 
         var configuration = GitFlowConfigurationBuilder.New.Build();
-        var branchConfiguration = configuration.GetBranchConfiguration(branch);
-        var effectiveConfiguration = new EffectiveConfiguration(configuration, branchConfiguration);
-        var effectiveBranchConfiguration = new EffectiveBranchConfiguration(branch, effectiveConfiguration);
+        var effectiveBranchConfiguration = configuration.GetEffectiveBranchConfiguration(branch);
 
         strategy.ShouldNotBeNull();
         var baseVersion = strategy.GetBaseVersions(effectiveBranchConfiguration).Single();
@@ -54,9 +52,7 @@ public void ShouldNotTakeVersionFromNameOfNonReleaseBranch(string branchName)
         var branch = repository.FindBranch(branchName);
 
         var configuration = GitFlowConfigurationBuilder.New.Build();
-        var branchConfiguration = configuration.GetBranchConfiguration(branch);
-        var effectiveConfiguration = new EffectiveConfiguration(configuration, branchConfiguration);
-        var effectiveBranchConfiguration = new EffectiveBranchConfiguration(branch, effectiveConfiguration);
+        var effectiveBranchConfiguration = configuration.GetEffectiveBranchConfiguration(branch);
 
         strategy.ShouldNotBeNull();
         var baseVersions = strategy.GetBaseVersions(effectiveBranchConfiguration);
@@ -89,9 +85,7 @@ public void CanTakeVersionFromNameOfConfiguredReleaseBranch(string branchName, s
         var strategy = GetVersionStrategy(repository, null, configurationHelper.Dictionary);
         var branch = repository.FindBranch(branchName);
 
-        var branchConfiguration = configuration.GetBranchConfiguration(branch);
-        var effectiveConfiguration = new EffectiveConfiguration(configuration, branchConfiguration);
-        var effectiveBranchConfiguration = new EffectiveBranchConfiguration(branch, effectiveConfiguration);
+        var effectiveBranchConfiguration = configuration.GetEffectiveBranchConfiguration(branch);
 
         strategy.ShouldNotBeNull();
         var baseVersion = strategy.GetBaseVersions(effectiveBranchConfiguration).Single();
@@ -115,9 +109,7 @@ public void CanTakeVersionFromNameOfRemoteReleaseBranch(string origin, string br
         var branch = localRepository.FindBranch(branchName);
 
         var configuration = GitFlowConfigurationBuilder.New.Build();
-        var branchConfiguration = configuration.GetBranchConfiguration(branch);
-        var effectiveConfiguration = new EffectiveConfiguration(configuration, branchConfiguration);
-        var effectiveBranchConfiguration = new EffectiveBranchConfiguration(branch, effectiveConfiguration);
+        var effectiveBranchConfiguration = configuration.GetEffectiveBranchConfiguration(branch);
 
         strategy.ShouldNotBeNull();
         var baseVersion = strategy.GetBaseVersions(effectiveBranchConfiguration).Single();
diff --git a/src/GitVersion.Core/Configuration/ConfigurationExtensions.cs b/src/GitVersion.Core/Configuration/ConfigurationExtensions.cs
@@ -5,18 +5,18 @@ namespace GitVersion.Configuration;
 
 public static class ConfigurationExtensions
 {
-    public static EffectiveConfiguration GetEffectiveConfiguration(this IGitVersionConfiguration configuration, IBranch branch)
-        => GetEffectiveConfiguration(configuration, branch.NotNull().Name);
+    public static EffectiveBranchConfiguration GetEffectiveBranchConfiguration(this IGitVersionConfiguration configuration, IBranch branch)
+    {
+        var effectiveConfiguration = GetEffectiveConfiguration(configuration, branch.Name);
+        return new(effectiveConfiguration, branch);
+    }
 
     public static EffectiveConfiguration GetEffectiveConfiguration(this IGitVersionConfiguration configuration, ReferenceName branchName)
     {
-        IBranchConfiguration branchConfiguration = configuration.GetBranchConfiguration(branchName);
-        return new EffectiveConfiguration(configuration, branchConfiguration);
+        var branchConfiguration = configuration.GetBranchConfiguration(branchName);
+        return new(configuration, branchConfiguration);
     }
 
-    public static IBranchConfiguration GetBranchConfiguration(this IGitVersionConfiguration configuration, IBranch branch)
-        => GetBranchConfiguration(configuration, branch.NotNull().Name);
-
     public static IBranchConfiguration GetBranchConfiguration(this IGitVersionConfiguration configuration, ReferenceName branchName)
     {
         var branchConfiguration = GetBranchConfigurations(configuration, branchName.WithoutOrigin).FirstOrDefault();
diff --git a/src/GitVersion.Core/Configuration/EffectiveBranchConfiguration.cs b/src/GitVersion.Core/Configuration/EffectiveBranchConfiguration.cs
@@ -3,23 +3,17 @@
 
 namespace GitVersion.Configuration;
 
-public class EffectiveBranchConfiguration
+public record EffectiveBranchConfiguration(EffectiveConfiguration Value, IBranch Branch)
 {
-    public IBranch Branch { get; }
+    public IBranch Branch { get; } = Branch.NotNull();
 
-    public EffectiveConfiguration Value { get; }
-
-    public EffectiveBranchConfiguration(IBranch branch, EffectiveConfiguration value)
-    {
-        Branch = branch.NotNull();
-        Value = value.NotNull();
-    }
+    public EffectiveConfiguration Value { get; } = Value.NotNull();
 
     public NextVersion CreateNextVersion(BaseVersion baseVersion, SemanticVersion incrementedVersion)
     {
         incrementedVersion.NotNull();
         baseVersion.NotNull();
 
-        return new NextVersion(incrementedVersion, baseVersion, new EffectiveBranchConfiguration(Branch, Value));
+        return new(incrementedVersion, baseVersion, this);
     }
 }
diff --git a/src/GitVersion.Core/Configuration/EffectiveConfiguration.cs b/src/GitVersion.Core/Configuration/EffectiveConfiguration.cs
@@ -8,7 +8,7 @@ namespace GitVersion.Configuration;
 ///     Configuration can be applied to different things, effective configuration is the result after applying the
 ///     appropriate configuration
 /// </summary>
-public class EffectiveConfiguration
+public record EffectiveConfiguration
 {
     public EffectiveConfiguration(IGitVersionConfiguration configuration, IBranchConfiguration branchConfiguration)
     {
diff --git a/src/GitVersion.Core/Core/RepositoryStore.cs b/src/GitVersion.Core/Core/RepositoryStore.cs
@@ -126,7 +126,7 @@ public IEnumerable<IBranch> FindMainlineBranches(IGitVersionConfiguration config
 
         foreach (var branch in this.repository.Branches)
         {
-            var branchConfiguration = configuration.GetBranchConfiguration(branch);
+            var branchConfiguration = configuration.GetBranchConfiguration(branch.Name);
             if (branchConfiguration.IsMainline == true)
             {
                 yield return branch;
diff --git a/src/GitVersion.Core/PublicAPI.Unshipped.txt b/src/GitVersion.Core/PublicAPI.Unshipped.txt
@@ -100,7 +100,7 @@ GitVersion.Configuration.ConfigurationModule.RegisterTypes(Microsoft.Extensions.
 GitVersion.Configuration.EffectiveBranchConfiguration
 GitVersion.Configuration.EffectiveBranchConfiguration.Branch.get -> GitVersion.IBranch!
 GitVersion.Configuration.EffectiveBranchConfiguration.CreateNextVersion(GitVersion.VersionCalculation.BaseVersion! baseVersion, GitVersion.SemanticVersion! incrementedVersion) -> GitVersion.VersionCalculation.NextVersion!
-GitVersion.Configuration.EffectiveBranchConfiguration.EffectiveBranchConfiguration(GitVersion.IBranch! branch, GitVersion.Configuration.EffectiveConfiguration! value) -> void
+GitVersion.Configuration.EffectiveBranchConfiguration.EffectiveBranchConfiguration(GitVersion.Configuration.EffectiveConfiguration! Value, GitVersion.IBranch! Branch) -> void
 GitVersion.Configuration.EffectiveBranchConfiguration.Value.get -> GitVersion.Configuration.EffectiveConfiguration!
 GitVersion.Configuration.EffectiveConfiguration
 GitVersion.Configuration.EffectiveConfiguration.AssemblyFileVersioningFormat.get -> string?
@@ -735,13 +735,12 @@ GitVersion.VersionCalculation.IVersionStrategy
 GitVersion.VersionCalculation.IVersionStrategy.GetBaseVersions(GitVersion.Configuration.EffectiveBranchConfiguration! configuration) -> System.Collections.Generic.IEnumerable<GitVersion.VersionCalculation.BaseVersion!>!
 GitVersion.VersionCalculation.NextVersion
 GitVersion.VersionCalculation.NextVersion.BaseVersion.get -> GitVersion.VersionCalculation.BaseVersion!
-GitVersion.VersionCalculation.NextVersion.Branch.get -> GitVersion.IBranch!
+GitVersion.VersionCalculation.NextVersion.BranchConfiguration.get -> GitVersion.Configuration.EffectiveBranchConfiguration!
 GitVersion.VersionCalculation.NextVersion.CompareTo(GitVersion.VersionCalculation.NextVersion? other) -> int
 GitVersion.VersionCalculation.NextVersion.Configuration.get -> GitVersion.Configuration.EffectiveConfiguration!
 GitVersion.VersionCalculation.NextVersion.Equals(GitVersion.VersionCalculation.NextVersion? other) -> bool
 GitVersion.VersionCalculation.NextVersion.IncrementedVersion.get -> GitVersion.SemanticVersion!
 GitVersion.VersionCalculation.NextVersion.NextVersion(GitVersion.SemanticVersion! incrementedVersion, GitVersion.VersionCalculation.BaseVersion! baseVersion, GitVersion.Configuration.EffectiveBranchConfiguration! configuration) -> void
-GitVersion.VersionCalculation.NextVersion.NextVersion(GitVersion.SemanticVersion! incrementedVersion, GitVersion.VersionCalculation.BaseVersion! baseVersion, GitVersion.IBranch! branch, GitVersion.Configuration.EffectiveConfiguration! configuration) -> void
 GitVersion.VersionCalculation.VersionCalculationModule
 GitVersion.VersionCalculation.VersionCalculationModule.RegisterTypes(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> void
 GitVersion.VersionCalculation.VersionCalculationModule.VersionCalculationModule() -> void
@@ -808,11 +807,10 @@ readonly GitVersion.Agents.BuildAgentBase.Log -> GitVersion.Logging.ILog!
 static GitVersion.BranchCommit.operator !=(GitVersion.BranchCommit left, GitVersion.BranchCommit right) -> bool
 static GitVersion.BranchCommit.operator ==(GitVersion.BranchCommit left, GitVersion.BranchCommit right) -> bool
 static GitVersion.Configuration.ConfigurationExtensions.FindGitDir(this string! path) -> (string! GitDirectory, string! WorkingTreeDirectory)?
-static GitVersion.Configuration.ConfigurationExtensions.GetBranchConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration, GitVersion.IBranch! branch) -> GitVersion.Configuration.IBranchConfiguration!
 static GitVersion.Configuration.ConfigurationExtensions.GetBranchConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration, GitVersion.ReferenceName! branchName) -> GitVersion.Configuration.IBranchConfiguration!
 static GitVersion.Configuration.ConfigurationExtensions.GetBranchSpecificLabel(this GitVersion.Configuration.EffectiveConfiguration! configuration, GitVersion.ReferenceName! branchName, string? branchNameOverride) -> string?
 static GitVersion.Configuration.ConfigurationExtensions.GetBranchSpecificLabel(this GitVersion.Configuration.EffectiveConfiguration! configuration, string? branchName, string? branchNameOverride) -> string?
-static GitVersion.Configuration.ConfigurationExtensions.GetEffectiveConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration, GitVersion.IBranch! branch) -> GitVersion.Configuration.EffectiveConfiguration!
+static GitVersion.Configuration.ConfigurationExtensions.GetEffectiveBranchConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration, GitVersion.IBranch! branch) -> GitVersion.Configuration.EffectiveBranchConfiguration!
 static GitVersion.Configuration.ConfigurationExtensions.GetEffectiveConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration, GitVersion.ReferenceName! branchName) -> GitVersion.Configuration.EffectiveConfiguration!
 static GitVersion.Configuration.ConfigurationExtensions.GetFallbackBranchConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration) -> GitVersion.Configuration.IBranchConfiguration!
 static GitVersion.Configuration.ConfigurationExtensions.GetReleaseBranchConfiguration(this GitVersion.Configuration.IGitVersionConfiguration! configuration) -> System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string!, GitVersion.Configuration.IBranchConfiguration!>>!
diff --git a/src/GitVersion.Core/VersionCalculation/EffectiveBranchConfigurationFinder.cs b/src/GitVersion.Core/VersionCalculation/EffectiveBranchConfigurationFinder.cs
@@ -29,7 +29,7 @@ private IEnumerable<EffectiveBranchConfiguration> GetEffectiveConfigurationsRecu
     {
         if (!traversedBranches.Add(branch)) yield break; // This should never happen!! But it is good to have a circuit breaker.
 
-        var branchConfiguration = configuration.GetBranchConfiguration(branch);
+        var branchConfiguration = configuration.GetBranchConfiguration(branch.Name);
         if (childBranchConfiguration != null)
         {
             branchConfiguration = childBranchConfiguration.Inherit(branchConfiguration);
@@ -66,7 +66,7 @@ in GetEffectiveConfigurationsRecursive(sourceBranch, configuration, branchConfig
         }
         else
         {
-            yield return new(branch, new EffectiveConfiguration(configuration, branchConfiguration));
+            yield return new(new(configuration, branchConfiguration), branch);
         }
     }
 }
diff --git a/src/GitVersion.Core/VersionCalculation/NextVersion.cs b/src/GitVersion.Core/VersionCalculation/NextVersion.cs
@@ -9,21 +9,15 @@ public class NextVersion : IComparable<NextVersion>, IEquatable<NextVersion>
 
     public SemanticVersion IncrementedVersion { get; }
 
-    public IBranch Branch { get; }
+    public EffectiveBranchConfiguration BranchConfiguration { get; }
 
-    public EffectiveConfiguration Configuration { get; }
+    public EffectiveConfiguration Configuration => BranchConfiguration.Value;
 
     public NextVersion(SemanticVersion incrementedVersion, BaseVersion baseVersion, EffectiveBranchConfiguration configuration)
-        : this(incrementedVersion, baseVersion, configuration.NotNull().Branch, configuration.NotNull().Value)
-    {
-    }
-
-    public NextVersion(SemanticVersion incrementedVersion, BaseVersion baseVersion, IBranch branch, EffectiveConfiguration configuration)
     {
         IncrementedVersion = incrementedVersion.NotNull();
         BaseVersion = baseVersion.NotNull();
-        Configuration = configuration.NotNull();
-        Branch = branch.NotNull();
+        BranchConfiguration = configuration;
     }
 
     public int CompareTo(NextVersion? other) => IncrementedVersion.CompareTo(other?.IncrementedVersion);
diff --git a/src/GitVersion.Core/VersionCalculation/VersionCalculators/MainlineVersionCalculator.cs b/src/GitVersion.Core/VersionCalculation/VersionCalculators/MainlineVersionCalculator.cs
@@ -345,7 +345,7 @@ private static VersionField FindDefaultIncrementForBranch(GitVersionContext cont
 
     private static VersionField FindDefaultIncrementForBranch(GitVersionContext context, IBranch branch)
     {
-        var increment = context.Configuration.GetEffectiveConfiguration(branch).Increment;
+        var increment = context.Configuration.GetEffectiveConfiguration(branch.Name).Increment;
         if (increment == IncrementStrategy.Inherit) increment = IncrementStrategy.Patch;
         return increment.ToVersionField();
     }
diff --git a/src/GitVersion.Core/VersionCalculation/VersionCalculators/NextVersionCalculator.cs b/src/GitVersion.Core/VersionCalculation/VersionCalculators/NextVersionCalculator.cs
@@ -42,7 +42,9 @@ public virtual NextVersion FindVersion()
 
         var nextVersion = CalculateNextVersion(Context.CurrentBranch, Context.Configuration);
         var incrementedVersion = CalculateIncrementedVersion(nextVersion.Configuration.VersioningMode, nextVersion);
-        return new(incrementedVersion, nextVersion.BaseVersion, new(nextVersion.Branch, nextVersion.Configuration));
+
+        var effectiveBranchConfiguration = nextVersion.BranchConfiguration;
+        return effectiveBranchConfiguration.CreateNextVersion(nextVersion.BaseVersion, incrementedVersion);
     }
 
     private SemanticVersion CalculateIncrementedVersion(VersioningMode versioningMode, NextVersion nextVersion)
@@ -112,7 +114,8 @@ private NextVersion CalculateNextVersion(IBranch branch, IGitVersionConfiguratio
 
         log.Info($"Base version used: {calculatedBase}");
         log.Separator();
-        return new NextVersion(maxVersion.IncrementedVersion, calculatedBase, maxVersion.Branch, maxVersion.Configuration);
+        var effectiveBranchConfiguration = maxVersion.BranchConfiguration;
+        return effectiveBranchConfiguration.CreateNextVersion(calculatedBase, maxVersion.IncrementedVersion);
     }
 
     private static NextVersion CompareVersions(NextVersion versions1, NextVersion version2)
diff --git a/src/GitVersion.Core/VersionCalculation/VersionCalculators/NonTrunkBasedVersionCalculatorBase.cs b/src/GitVersion.Core/VersionCalculation/VersionCalculators/NonTrunkBasedVersionCalculatorBase.cs
@@ -39,7 +39,7 @@ protected SemanticVersion CalculateIncrementedVersion(NextVersion nextVersion)
         ////
         // TODO: We need to consider somehow the IGitVersionConfiguration::Ignore property here!!
         var semanticVersionWithTag = this.repositoryStore.GetTaggedSemanticVersionsOnBranch(
-            nextVersion.Branch, Context.Configuration.TagPrefix, Context.Configuration.SemanticVersionFormat
+            nextVersion.BranchConfiguration.Branch, Context.Configuration.TagPrefix, Context.Configuration.SemanticVersionFormat
         ).FirstOrDefault(element => Context.CurrentCommit is null || element.Tag.Commit.When <= Context.CurrentCommit.When);
         //
 
diff --git a/src/GitVersion.Core/VersionCalculation/VersionSearchStrategies/TrackReleaseBranchesVersionStrategy.cs b/src/GitVersion.Core/VersionCalculation/VersionSearchStrategies/TrackReleaseBranchesVersionStrategy.cs
@@ -64,9 +64,9 @@ private IEnumerable<BaseVersion> GetReleaseVersion(IBranch releaseBranch)
     {
         // Find the commit where the child branch was created.
         var baseSource = this.repositoryStore.FindMergeBase(releaseBranch, Context.CurrentBranch);
-        var configuration = Context.Configuration.GetEffectiveConfiguration(releaseBranch);
+        var effectiveBranchConfiguration = Context.Configuration.GetEffectiveBranchConfiguration(releaseBranch);
         return this.releaseVersionStrategy
-            .GetBaseVersions(new(releaseBranch, configuration))
+            .GetBaseVersions(effectiveBranchConfiguration)
             .Select(b => new BaseVersion(b.Source, true, b.SemanticVersion, baseSource, b.BranchNameOverride));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace GitVersion.Core.Tests.Helpers;`
`6`	`6`
`7`		`-public class TestEffectiveConfiguration : EffectiveConfiguration`
	`7`	`+public record TestEffectiveConfiguration : EffectiveConfiguration`
`8`	`8`	`{`
`9`	`9`	`public TestEffectiveConfiguration(`
`10`	`10`	`AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch,`
Original file line number	Diff line number	Diff line change
`@@ -57,10 +57,8 @@ public void ConfigNextVersionTestShouldFail(string nextVersion, SemanticVersionF`
`57`	`57`	`var strategy = contextBuilder.ServicesProvider.GetServiceForType<IVersionStrategy, ConfigNextVersionVersionStrategy>();`
`58`	`58`	`var context = contextBuilder.ServicesProvider.GetRequiredService<Lazy<GitVersionContext>>().Value;`
`59`	`59`	`var branchMock = GitToolsTestingExtensions.CreateMockBranch("main", GitToolsTestingExtensions.CreateMockCommit());`
`60`		`- var branchConfiguration = context.Configuration.GetBranchConfiguration(branchMock);`
`61`		`- var effectiveConfiguration = new EffectiveConfiguration(context.Configuration, branchConfiguration);`
`62`	`60`
`63`	`61`	`strategy.ShouldNotBeNull();`
`64`		`- return strategy.GetBaseVersions(new(branchMock, effectiveConfiguration)).SingleOrDefault();`
	`62`	`+ return strategy.GetBaseVersions(context.Configuration.GetEffectiveBranchConfiguration(branchMock)).SingleOrDefault();`
`65`	`63`	`}`
`66`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,18 +5,18 @@ namespace GitVersion.Configuration;`
`5`	`5`
`6`	`6`	`public static class ConfigurationExtensions`
`7`	`7`	`{`
`8`		`- public static EffectiveConfiguration GetEffectiveConfiguration(this IGitVersionConfiguration configuration, IBranch branch)`
`9`		`- => GetEffectiveConfiguration(configuration, branch.NotNull().Name);`
	`8`	`+ public static EffectiveBranchConfiguration GetEffectiveBranchConfiguration(this IGitVersionConfiguration configuration, IBranch branch)`
	`9`	`+ {`
	`10`	`+ var effectiveConfiguration = GetEffectiveConfiguration(configuration, branch.Name);`
	`11`	`+ return new(effectiveConfiguration, branch);`
	`12`	`+ }`
`10`	`13`
`11`	`14`	`public static EffectiveConfiguration GetEffectiveConfiguration(this IGitVersionConfiguration configuration, ReferenceName branchName)`
`12`	`15`	`{`
`13`		`- IBranchConfiguration branchConfiguration = configuration.GetBranchConfiguration(branchName);`
`14`		`- return new EffectiveConfiguration(configuration, branchConfiguration);`
	`16`	`+ var branchConfiguration = configuration.GetBranchConfiguration(branchName);`
	`17`	`+ return new(configuration, branchConfiguration);`
`15`	`18`	`}`
`16`	`19`
`17`		`- public static IBranchConfiguration GetBranchConfiguration(this IGitVersionConfiguration configuration, IBranch branch)`
`18`		`- => GetBranchConfiguration(configuration, branch.NotNull().Name);`
`19`		`-`
`20`	`20`	`public static IBranchConfiguration GetBranchConfiguration(this IGitVersionConfiguration configuration, ReferenceName branchName)`
`21`	`21`	`{`
`22`	`22`	`var branchConfiguration = GetBranchConfigurations(configuration, branchName.WithoutOrigin).FirstOrDefault();`
Original file line number	Diff line number	Diff line change
`@@ -3,23 +3,17 @@`
`3`	`3`
`4`	`4`	`namespace GitVersion.Configuration;`
`5`	`5`
`6`		`-public class EffectiveBranchConfiguration`
	`6`	`+public record EffectiveBranchConfiguration(EffectiveConfiguration Value, IBranch Branch)`
`7`	`7`	`{`
`8`		`- public IBranch Branch { get; }`
	`8`	`+ public IBranch Branch { get; } = Branch.NotNull();`
`9`	`9`
`10`		`- public EffectiveConfiguration Value { get; }`
`11`		`-`
`12`		`- public EffectiveBranchConfiguration(IBranch branch, EffectiveConfiguration value)`
`13`		`- {`
`14`		`- Branch = branch.NotNull();`
`15`		`- Value = value.NotNull();`
`16`		`- }`
	`10`	`+ public EffectiveConfiguration Value { get; } = Value.NotNull();`
`17`	`11`
`18`	`12`	`public NextVersion CreateNextVersion(BaseVersion baseVersion, SemanticVersion incrementedVersion)`
`19`	`13`	`{`
`20`	`14`	`incrementedVersion.NotNull();`
`21`	`15`	`baseVersion.NotNull();`
`22`	`16`
`23`		`- return new NextVersion(incrementedVersion, baseVersion, new EffectiveBranchConfiguration(Branch, Value));`
	`17`	`+ return new(incrementedVersion, baseVersion, this);`
`24`	`18`	`}`
`25`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace GitVersion.Configuration;`
`8`	`8`	`/// Configuration can be applied to different things, effective configuration is the result after applying the`
`9`	`9`	`/// appropriate configuration`
`10`	`10`	`/// </summary>`
`11`		`-public class EffectiveConfiguration`
	`11`	`+public record EffectiveConfiguration`
`12`	`12`	`{`
`13`	`13`	`public EffectiveConfiguration(IGitVersionConfiguration configuration, IBranchConfiguration branchConfiguration)`
`14`	`14`	`{`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ public IEnumerable<IBranch> FindMainlineBranches(IGitVersionConfiguration config`
`126`	`126`
`127`	`127`	`foreach (var branch in this.repository.Branches)`
`128`	`128`	`{`
`129`		`- var branchConfiguration = configuration.GetBranchConfiguration(branch);`
	`129`	`+ var branchConfiguration = configuration.GetBranchConfiguration(branch.Name);`
`130`	`130`	`if (branchConfiguration.IsMainline == true)`
`131`	`131`	`{`
`132`	`132`	`yield return branch;`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ private IEnumerable<EffectiveBranchConfiguration> GetEffectiveConfigurationsRecu`
`29`	`29`	`{`
`30`	`30`	`if (!traversedBranches.Add(branch)) yield break; // This should never happen!! But it is good to have a circuit breaker.`
`31`	`31`
`32`		`- var branchConfiguration = configuration.GetBranchConfiguration(branch);`
	`32`	`+ var branchConfiguration = configuration.GetBranchConfiguration(branch.Name);`
`33`	`33`	`if (childBranchConfiguration != null)`
`34`	`34`	`{`
`35`	`35`	`branchConfiguration = childBranchConfiguration.Inherit(branchConfiguration);`
`@@ -66,7 +66,7 @@ in GetEffectiveConfigurationsRecursive(sourceBranch, configuration, branchConfig`
`66`	`66`	`}`
`67`	`67`	`else`
`68`	`68`	`{`
`69`		`- yield return new(branch, new EffectiveConfiguration(configuration, branchConfiguration));`
	`69`	`+ yield return new(new(configuration, branchConfiguration), branch);`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`}`