Ignore versions with PreRelease tags when getting base version in mainline mode.

Author: Andy Furniss

src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs

@@ -133,6 +133,45 @@ public void ShouldFilterVersion()
             baseVersion.SemanticVersion.ShouldBe(lowerVersion.SemanticVersion);
         }
 
+        [Test]
+        public void ShouldIgnorePreReleaseVersionInMainlineMode()
+        {
+            var fakeIgnoreConfig = new TestIgnoreConfig(new ExcludeSourcesContainingExclude());
+
+            var lowerVersion = new BaseVersion("dummy", false, new SemanticVersion(1), new MockCommit(), null);
+            var preReleaseVersion = new BaseVersion(
+                "prerelease",
+                false,
+                new SemanticVersion(1, 0, 1)
+                {
+                    PreReleaseTag = new SemanticVersionPreReleaseTag
+                    {
+                        Name = "alpha",
+                        Number = 1
+                    }
+                },
+                new MockCommit(),
+                null
+            );
+
+            var versionCalculator = GetBaseVersionCalculator(contextBuilder =>
+            {
+                contextBuilder
+                    .WithConfig(new Config { VersioningMode = VersioningMode.Mainline, Ignore = fakeIgnoreConfig })
+                    .OverrideServices(services =>
+                    {
+                        services.RemoveAll<IVersionStrategy>();
+                        services.AddSingleton<IVersionStrategy>(new TestVersionStrategy(preReleaseVersion, lowerVersion));
+                    });
+            });
+            var baseVersion = versionCalculator.GetBaseVersion();
+
+            baseVersion.Source.ShouldNotBe(preReleaseVersion.Source);
+            baseVersion.SemanticVersion.ShouldNotBe(preReleaseVersion.SemanticVersion);
+            baseVersion.Source.ShouldBe(lowerVersion.Source);
+            baseVersion.SemanticVersion.ShouldBe(lowerVersion.SemanticVersion);
+        }
+
         private static IBaseVersionCalculator GetBaseVersionCalculator(Action<GitVersionContextBuilder> contextBuilderAction)
         {
             var contextBuilder = new GitVersionContextBuilder();

src/GitVersionCore.Tests/VersionCalculation/NextVersionCalculatorTests.cs

@@ -154,6 +154,29 @@ public void MergeIntoMainline()
             fixture.AssertFullSemver("1.0.0", config);
         }
 
+        [Test]
+        public void MergeFeatureIntoMainline()
+        {
+            var config = new Config
+            {
+                VersioningMode = VersioningMode.Mainline
+            };
+
+            using var fixture = new EmptyRepositoryFixture();
+            fixture.MakeACommit();
+            fixture.ApplyTag("1.0.0");
+            fixture.AssertFullSemver("1.0.0", config);
+
+            fixture.BranchTo("feature/foo");
+            fixture.MakeACommit();
+            fixture.AssertFullSemver("1.0.1-foo.1", config);
+            fixture.ApplyTag("1.0.1-foo.1");
+
+            fixture.Checkout("master");
+            fixture.MergeNoFF("feature/foo");
+            fixture.AssertFullSemver("1.0.1", config);
+        }
+
         [Test]
         public void PreReleaseTagCanUseBranchNameVariable()
         {

src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs

@@ -60,7 +60,19 @@ public BaseVersion GetBaseVersion()
                     .ToList();
 
                 FixTheBaseVersionSourceOfMergeMessageStrategyIfReleaseBranchWasMergedAndDeleted(baseVersions);
-                var maxVersion = baseVersions.Aggregate((v1, v2) => v1.IncrementedVersion > v2.IncrementedVersion ? v1 : v2);
+
+                Versions maxVersion;
+                if (context.Configuration.VersioningMode == VersioningMode.Mainline)
+                {
+                    maxVersion = baseVersions
+                        .Where(b => !b.IncrementedVersion.PreReleaseTag.HasTag())
+                        .Aggregate((v1, v2) => v1.IncrementedVersion > v2.IncrementedVersion ? v1 : v2);
+                }
+                else
+                {
+                    maxVersion = baseVersions.Aggregate((v1, v2) => v1.IncrementedVersion > v2.IncrementedVersion ? v1 : v2);
+                }
+
                 var matchingVersionsOnceIncremented = baseVersions
                     .Where(b => b.Version.BaseVersionSource != null && b.IncrementedVersion == maxVersion.IncrementedVersion)
                     .ToList();