Created NewNextVersionCalculator which is the new version calculation

Author: JakeGinnivan

GitVersionCore.Tests/GitVersionCore.Tests.csproj

@@ -116,6 +116,7 @@
     <Compile Include="TestFileSystem.cs" />
     <Compile Include="VariableProviderTests.cs" />
     <Compile Include="VersionCalculation\BaseVersionCalculatorTests.cs" />
+    <Compile Include="VersionCalculation\NewNextVersionCalculatorTests.cs" />
     <Compile Include="VersionCalculation\Strategies\ConfigNextVersionBaseVersionStrategyTests.cs" />
     <Compile Include="GitVersionContextBuilder.cs" />
     <Compile Include="VersionCalculation\Strategies\LastTagBaseVersionStrategyTests.cs" />

GitVersionCore.Tests/TestEffectiveConfiguration.cs

@@ -10,7 +10,7 @@ public TestEffectiveConfiguration(
             string gitTagPrefix = "v", 
             string tag = "",
             string nextVersion = null) : 
-                base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion)
+                base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch)
         {
         }
     }

GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs

@@ -0,0 +1,44 @@
+namespace GitVersionCore.Tests.VersionCalculation
+{
+    using GitVersion;
+    using GitVersion.VersionCalculation;
+    using NUnit.Framework;
+    using Shouldly;
+
+    public class NewNextVersionCalculatorTests
+    {
+        [Test]
+        public void ShouldIncrementVersionBasedOnConfig()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1));
+            var sut = new NewNextVersionCalculator(baseCalculator);
+            var config = new Config();
+            config.Branches.Add("master", new BranchConfig
+            {
+                Increment = IncrementStrategy.Major
+            });
+            var context = new GitVersionContextBuilder().WithConfig(config).Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("2.0.0");
+        }
+
+        [Test]
+        public void DoesNotIncrementWhenBaseVersionSaysNotTo()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1));
+            var sut = new NewNextVersionCalculator(baseCalculator);
+            var config = new Config();
+            config.Branches.Add("master", new BranchConfig
+            {
+                Increment = IncrementStrategy.Major
+            });
+            var context = new GitVersionContextBuilder().WithConfig(config).Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("1.0.0");
+        }
+    }
+}

GitVersionCore.Tests/VersionCalculation/TestBaseVersionCalculator.cs

@@ -0,0 +1,23 @@
+namespace GitVersionCore.Tests.VersionCalculation
+{
+    using GitVersion;
+    using GitVersion.VersionCalculation;
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
+
+    public class TestBaseVersionCalculator : IBaseVersionCalculator
+    {
+        readonly SemanticVersion semanticVersion;
+        bool shouldIncrement;
+
+        public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion)
+        {
+            this.semanticVersion = semanticVersion;
+            this.shouldIncrement = shouldIncrement;
+        }
+
+        public BaseVersion GetBaseVersion(GitVersionContext context)
+        {
+            return new BaseVersion(shouldIncrement, semanticVersion);
+        }
+    }
+}

GitVersionCore/Configuration/BranchConfig.cs

@@ -9,5 +9,8 @@ public class BranchConfig
 
         [YamlAlias("tag")]
         public string Tag { get; set; }
+
+        [YamlAlias("increment")]
+        public IncrementStrategy? Increment { get; set; }
     }
 }

GitVersionCore/Configuration/IncrementStrategy.cs

@@ -0,0 +1,10 @@
+namespace GitVersion
+{
+    public enum IncrementStrategy
+    {
+        None,
+        Major,
+        Minor,
+        Patch
+    }
+}

GitVersionCore/EffectiveConfiguration.cs

@@ -5,13 +5,14 @@
     /// </summary>
     public class EffectiveConfiguration
     {
-        public EffectiveConfiguration(AssemblyVersioningScheme assemblyVersioningScheme, VersioningMode versioningMode, string gitTagPrefix, string tag, string nextVersion)
+        public EffectiveConfiguration(AssemblyVersioningScheme assemblyVersioningScheme, VersioningMode versioningMode, string gitTagPrefix, string tag, string nextVersion, IncrementStrategy increment)
         {
             AssemblyVersioningScheme = assemblyVersioningScheme;
             VersioningMode = versioningMode;
             GitTagPrefix = gitTagPrefix;
             Tag = tag;
             NextVersion = nextVersion;
+            Increment = increment;
         }
 
         public VersioningMode VersioningMode { get; private set; }
@@ -29,5 +30,6 @@ public EffectiveConfiguration(AssemblyVersioningScheme assemblyVersioningScheme,
         public string Tag { get; private set; }
 
         public string NextVersion { get; private set; }
+        public IncrementStrategy Increment { get; private set; }
     }
 }

GitVersionCore/GitVersionContext.cs

@@ -88,8 +88,9 @@ void CalculateEffectiveConfiguration()
             var versioningMode = currentBranchConfig.VersioningMode ?? configuration.VersioningMode ?? VersioningMode.ContinuousDelivery;
             var tag = currentBranchConfig.Tag;
             var nextVersion = configuration.NextVersion;
+            var incrementStrategy = currentBranchConfig.Increment ?? IncrementStrategy.Patch;
 
-            Configuration = new EffectiveConfiguration(configuration.AssemblyVersioningScheme, versioningMode, configuration.TagPrefix, tag, nextVersion);
+            Configuration = new EffectiveConfiguration(configuration.AssemblyVersioningScheme, versioningMode, configuration.TagPrefix, tag, nextVersion, incrementStrategy);
         }
 
         BranchConfig GetBranchConfiguration(KeyValuePair<string, BranchConfig>[] matchingBranches)

GitVersionCore/GitVersionCore.csproj

@@ -74,6 +74,7 @@
     <Compile Include="Configuration\Config.cs" />
     <Compile Include="Configuration\ConfigReader.cs" />
     <Compile Include="Configuration\ConfigurationProvider.cs" />
+    <Compile Include="Configuration\IncrementStrategy.cs" />
     <Compile Include="Configuration\LegacyConfig.cs" />
     <Compile Include="Configuration\LegacyConfigNotifier.cs" />
     <Compile Include="Configuration\OldConfigurationException.cs" />
@@ -93,6 +94,8 @@
     <Compile Include="VersionCalculation\BaseVersionCalculators\LastTagBaseVersionStrategy.cs" />
     <Compile Include="VersionCalculation\BaseVersionCalculators\MergeMessageBaseVersionStrategy.cs" />
     <Compile Include="VersionCalculation\BaseVersionStrategy.cs" />
+    <Compile Include="VersionCalculation\IBaseVersionCalculator.cs" />
+    <Compile Include="VersionCalculation\NewNextVersionCalculator.cs" />
     <Compile Include="VersioningModes\ContinuousDeliveryMode.cs" />
     <Compile Include="VersioningModes\ContinuousDeploymentMode.cs" />
     <Compile Include="VersioningModes\VersioningMode.cs" />

GitVersionCore/VersionCalculation/BaseVersionCalculator.cs

@@ -1,9 +1,9 @@
 namespace GitVersion.VersionCalculation
 {
     using System.Linq;
-    using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using BaseVersionCalculators;
 
-    public class BaseVersionCalculator
+    public class BaseVersionCalculator : IBaseVersionCalculator
     {
         readonly BaseVersionStrategy[] strategies;
 

GitVersionCore/VersionCalculation/IBaseVersionCalculator.cs

@@ -0,0 +1,9 @@
+namespace GitVersion.VersionCalculation
+{
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
+
+    public interface IBaseVersionCalculator
+    {
+        BaseVersion GetBaseVersion(GitVersionContext context);
+    }
+}

GitVersionCore/VersionCalculation/NewNextVersionCalculator.cs

@@ -0,0 +1,56 @@
+namespace GitVersion.VersionCalculation
+{
+    using System;
+    using BaseVersionCalculators;
+
+    public class NewNextVersionCalculator
+    {
+        IBaseVersionCalculator baseVersionFinder;
+
+        public NewNextVersionCalculator(IBaseVersionCalculator baseVersionCalculator = null)
+        {
+            baseVersionFinder = baseVersionCalculator ??
+                new BaseVersionCalculator(
+                new ConfigNextVersionBaseVersionStrategy(),
+                new LastTagBaseVersionStrategy(),
+                new MergeMessageBaseVersionStrategy());
+        }
+
+        public SemanticVersion FindVersion(GitVersionContext context)
+        {
+            var baseVersion = baseVersionFinder.GetBaseVersion(context);
+
+            if (baseVersion.ShouldIncrement) IncrementVersion(context, baseVersion);
+
+            return baseVersion.SemanticVersion;
+        }
+
+        static void IncrementVersion(GitVersionContext context, BaseVersion baseVersion)
+        {
+            if (!baseVersion.SemanticVersion.PreReleaseTag.HasTag())
+            {
+                switch (context.Configuration.Increment)
+                {
+                    case IncrementStrategy.None:
+                        break;
+                    case IncrementStrategy.Major:
+                        baseVersion.SemanticVersion.Major++;
+                        break;
+                    case IncrementStrategy.Minor:
+                        baseVersion.SemanticVersion.Minor++;
+                        break;
+                    case IncrementStrategy.Patch:
+                        baseVersion.SemanticVersion.Patch++;
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+            else
+            {
+                baseVersion.SemanticVersion.PreReleaseTag.Number = baseVersion.SemanticVersion.PreReleaseTag.Number ?? 0;
+                baseVersion.SemanticVersion.PreReleaseTag.Number++;
+            }
+        }
+    }
+}