Added MetaDataCalculator in and fixed up some other shortcomings in the design

JakeGinnivan · JakeGinnivan · commit b7f238645c55 · 2015-01-10T22:52:03.000Z
diff --git a/GitVersionCore.Tests/GitVersionCore.Tests.csproj b/GitVersionCore.Tests/GitVersionCore.Tests.csproj
@@ -121,6 +121,8 @@
     <Compile Include="GitVersionContextBuilder.cs" />
     <Compile Include="VersionCalculation\Strategies\LastTagBaseVersionStrategyTests.cs" />
     <Compile Include="VersionCalculation\Strategies\MergeMessageBaseVersionStrategyTests.cs" />
+    <Compile Include="VersionCalculation\TestBaseVersionCalculator.cs" />
+    <Compile Include="VersionCalculation\TestMetaDataCalculator.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs b/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs
@@ -1,5 +1,6 @@
 ﻿namespace GitVersionCore.Tests.VersionCalculation
 {
+    using System;
     using GitVersion;
     using GitVersion.VersionCalculation;
     using GitVersion.VersionCalculation.BaseVersionCalculators;
@@ -13,27 +14,71 @@ public class BaseVersionCalculatorTests
         public void ChoosesHighestVersionReturnedFromStrategies()
         {
             var context = new GitVersionContextBuilder().Build();
-            var sut = new BaseVersionCalculator(new V1Strategy(), new V2Strategy());
+            var dateTimeOffset = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(DateTimeOffset.Now), new V2Strategy(dateTimeOffset));
 
             var baseVersion = sut.GetBaseVersion(context);
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionWhenFrom.ShouldBe(dateTimeOffset);
+        }
+
+        [Test]
+        public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()
+        {
+            var context = new GitVersionContextBuilder().Build();
+            var when = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(when), new V2Strategy(null));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
+            baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionWhenFrom.ShouldBe(when);
+        }
+
+        [Test]
+        public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()
+        {
+            var context = new GitVersionContextBuilder().Build();
+            var when = DateTimeOffset.Now;
+            var sut = new BaseVersionCalculator(new V1Strategy(null), new V2Strategy(when));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
+            baseVersion.ShouldIncrement.ShouldBe(true);
+            baseVersion.BaseVersionWhenFrom.ShouldBe(when);
         }
 
         class V1Strategy : BaseVersionStrategy
         {
+            readonly DateTimeOffset? when;
+
+            public V1Strategy(DateTimeOffset? when)
+            {
+                this.when = when;
+            }
+
             public override BaseVersion GetVersion(GitVersionContext context)
             {
-                return new BaseVersion(false, new SemanticVersion(1));
+                return new BaseVersion(false, new SemanticVersion(1), when);
             }
         }
 
         class V2Strategy : BaseVersionStrategy
         {
+            DateTimeOffset? when;
+
+            public V2Strategy(DateTimeOffset? when)
+            {
+                this.when = when;
+            }
+
             public override BaseVersion GetVersion(GitVersionContext context)
             {
-                return new BaseVersion(true, new SemanticVersion(2));
+                return new BaseVersion(true, new SemanticVersion(2), when);
             }
         }
     }
diff --git a/GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs b/GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs
@@ -1,5 +1,6 @@
 ﻿namespace GitVersionCore.Tests.VersionCalculation
 {
+    using System;
     using GitVersion;
     using GitVersion.VersionCalculation;
     using NUnit.Framework;
@@ -10,8 +11,9 @@ public class NewNextVersionCalculatorTests
         [Test]
         public void ShouldIncrementVersionBasedOnConfig()
         {
-            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1));
-            var sut = new NewNextVersionCalculator(baseCalculator);
+            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), DateTimeOffset.Now);
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
             var config = new Config();
             config.Branches.Add("master", new BranchConfig
             {
@@ -27,8 +29,9 @@ public void ShouldIncrementVersionBasedOnConfig()
         [Test]
         public void DoesNotIncrementWhenBaseVersionSaysNotTo()
         {
-            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1));
-            var sut = new NewNextVersionCalculator(baseCalculator);
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), DateTimeOffset.Now);
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
             var config = new Config();
             config.Branches.Add("master", new BranchConfig
             {
diff --git a/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs b/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs
@@ -70,7 +70,11 @@ static void AssertMergeMessage(string message, string expectedVersion, List<Comm
             var context = new GitVersionContextBuilder()
                 .WithRepository(new MockRepository
                 {
-                    Head = new MockBranch("master") { commit }
+                    Head = new MockBranch("master")
+                    {
+                        commit,
+                        new MockCommit()
+                    }
                 })
                 .Build();
             var sut = new MergeMessageBaseVersionStrategy();
diff --git a/GitVersionCore.Tests/VersionCalculation/TestBaseVersionCalculator.cs b/GitVersionCore.Tests/VersionCalculation/TestBaseVersionCalculator.cs
@@ -1,5 +1,6 @@
 namespace GitVersionCore.Tests.VersionCalculation
 {
+    using System;
     using GitVersion;
     using GitVersion.VersionCalculation;
     using GitVersion.VersionCalculation.BaseVersionCalculators;
@@ -8,16 +9,18 @@ public class TestBaseVersionCalculator : IBaseVersionCalculator
     {
         readonly SemanticVersion semanticVersion;
         bool shouldIncrement;
+        DateTimeOffset? when;
 
-        public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion)
+        public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? when)
         {
             this.semanticVersion = semanticVersion;
+            this.when = when;
             this.shouldIncrement = shouldIncrement;
         }
 
         public BaseVersion GetBaseVersion(GitVersionContext context)
         {
-            return new BaseVersion(shouldIncrement, semanticVersion);
+            return new BaseVersion(shouldIncrement, semanticVersion, when);
         }
     }
 }
diff --git a/GitVersionCore.Tests/VersionCalculation/TestMetaDataCalculator.cs b/GitVersionCore.Tests/VersionCalculation/TestMetaDataCalculator.cs
@@ -0,0 +1,21 @@
+﻿namespace GitVersionCore.Tests.VersionCalculation
+{
+    using System;
+    using GitVersion;
+    using GitVersion.VersionCalculation;
+
+    public class TestMetaDataCalculator : IMetaDataCalculator
+    {
+        SemanticVersionBuildMetaData metaData;
+
+        public TestMetaDataCalculator(SemanticVersionBuildMetaData metaData)
+        {
+            this.metaData = metaData;
+        }
+
+        public SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context)
+        {
+            return metaData;
+        }
+    }
+}
diff --git a/GitVersionCore/GitVersionCore.csproj b/GitVersionCore/GitVersionCore.csproj
@@ -95,6 +95,8 @@
     <Compile Include="VersionCalculation\BaseVersionCalculators\MergeMessageBaseVersionStrategy.cs" />
     <Compile Include="VersionCalculation\BaseVersionStrategy.cs" />
     <Compile Include="VersionCalculation\IBaseVersionCalculator.cs" />
+    <Compile Include="VersionCalculation\IMetaDataCalculator.cs" />
+    <Compile Include="VersionCalculation\MetaDataCalculator.cs" />
     <Compile Include="VersionCalculation\NewNextVersionCalculator.cs" />
     <Compile Include="VersioningModes\ContinuousDeliveryMode.cs" />
     <Compile Include="VersioningModes\ContinuousDeploymentMode.cs" />
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs
@@ -17,7 +17,15 @@ public BaseVersion GetBaseVersion(GitVersionContext context)
             return strategies
                 .Select(s => s.GetVersion(context))
                 .Where(v => v != null)
-                .Aggregate((v1, v2) => v1.SemanticVersion > v2.SemanticVersion ? v1 : v2);
+                .Aggregate((v1, v2) =>
+                {
+                    if (v1.SemanticVersion > v2.SemanticVersion)
+                    {
+                        return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionWhenFrom ?? v2.BaseVersionWhenFrom);
+                    }
+
+                    return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionWhenFrom ?? v1.BaseVersionWhenFrom);
+                });
         }
     }
 }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/BaseVersion.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/BaseVersion.cs
@@ -1,15 +1,25 @@
 ﻿namespace GitVersion.VersionCalculation.BaseVersionCalculators
 {
+    using System;
+
     public class BaseVersion
     {
-        public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion)
+        public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? baseVersionWhenFrom)
         {
             ShouldIncrement = shouldIncrement;
             SemanticVersion = semanticVersion;
+            BaseVersionWhenFrom = baseVersionWhenFrom;
         }
 
         public bool ShouldIncrement { get; private set; }
 
         public SemanticVersion SemanticVersion { get; private set; }
+
+        /// <summary>
+        /// Can be null even if the base version has a version
+        /// 
+        /// This happens when the base version doesn't have a time it came from
+        /// </summary>
+        public DateTimeOffset? BaseVersionWhenFrom { get; private set; }
     }
 }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/ConfigNextVersionBaseVersionStrategy.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/ConfigNextVersionBaseVersionStrategy.cs
@@ -6,7 +6,7 @@ public override BaseVersion GetVersion(GitVersionContext context)
         {
             if (string.IsNullOrEmpty(context.Configuration.NextVersion))
                 return null;
-            return new BaseVersion(false, SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix));
+            return new BaseVersion(false, SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix), null);
         }
     }
 }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/LastTagBaseVersionStrategy.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/LastTagBaseVersionStrategy.cs
@@ -6,7 +6,7 @@ public override BaseVersion GetVersion(GitVersionContext context)
         {
             VersionTaggedCommit version;
             if (new LastTaggedReleaseFinder(context).GetVersion(out version))
-                return new BaseVersion(true, version.SemVer);
+                return new BaseVersion(true, version.SemVer, version.Commit.When());
 
             return null;
         }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageBaseVersionStrategy.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageBaseVersionStrategy.cs
@@ -4,11 +4,13 @@ public class MergeMessageBaseVersionStrategy : BaseVersionStrategy
     {
         public override BaseVersion GetVersion(GitVersionContext context)
         {
-            // TODO when this approach works, inline the other class into here
-            SemanticVersion semanticVersion;
-            if (MergeMessageParser.TryParse(context.CurrentCommit, context.Configuration, out semanticVersion))
-                return new BaseVersion(true, semanticVersion);
-
+            foreach (var commit in context.CurrentBranch.CommitsPriorToThan(context.CurrentCommit.When()))
+            {
+                SemanticVersion semanticVersion;
+                // TODO when this approach works, inline the other class into here
+                if (MergeMessageParser.TryParse(context.CurrentCommit, context.Configuration, out semanticVersion))
+                    return new BaseVersion(true, semanticVersion, commit.When());
+            }
             return null;
         }
     }
diff --git a/GitVersionCore/VersionCalculation/IMetaDataCalculator.cs b/GitVersionCore/VersionCalculation/IMetaDataCalculator.cs
@@ -0,0 +1,9 @@
+﻿namespace GitVersion.VersionCalculation
+{
+    using System;
+
+    public interface IMetaDataCalculator
+    {
+        SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context);
+    }
+}
diff --git a/GitVersionCore/VersionCalculation/MetaDataCalculator.cs b/GitVersionCore/VersionCalculation/MetaDataCalculator.cs
@@ -0,0 +1,25 @@
+﻿namespace GitVersion.VersionCalculation
+{
+    using System;
+    using System.Linq;
+    using LibGit2Sharp;
+
+    public class MetaDataCalculator : IMetaDataCalculator
+    {
+        public SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context)
+        {
+            var qf = new CommitFilter
+            {
+                Since = baseVersionWhenFrom,
+                Until = context.CurrentCommit,
+                SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Time
+            };
+
+            return new SemanticVersionBuildMetaData(
+                context.Repository.Commits.QueryBy(qf).Count(),
+                context.CurrentBranch.Name,
+                context.CurrentCommit.Sha,
+                context.CurrentCommit.When());
+        }
+    }
+}
diff --git a/GitVersionCore/VersionCalculation/NewNextVersionCalculator.cs b/GitVersionCore/VersionCalculation/NewNextVersionCalculator.cs
@@ -6,9 +6,11 @@
     public class NewNextVersionCalculator
     {
         IBaseVersionCalculator baseVersionFinder;
+        IMetaDataCalculator metaDataCalculator;
 
-        public NewNextVersionCalculator(IBaseVersionCalculator baseVersionCalculator = null)
+        public NewNextVersionCalculator(IBaseVersionCalculator baseVersionCalculator = null, IMetaDataCalculator metaDataCalculator = null)
         {
+            this.metaDataCalculator = metaDataCalculator ?? new MetaDataCalculator();
             baseVersionFinder = baseVersionCalculator ??
                 new BaseVersionCalculator(
                 new ConfigNextVersionBaseVersionStrategy(),
@@ -22,6 +24,8 @@ public SemanticVersion FindVersion(GitVersionContext context)
 
             if (baseVersion.ShouldIncrement) IncrementVersion(context, baseVersion);
 
+            baseVersion.SemanticVersion.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionWhenFrom, context);
+
             return baseVersion.SemanticVersion;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`namespace GitVersionCore.Tests.VersionCalculation`
`2`	`2`	`{`
	`3`	`+ using System;`
`3`	`4`	`using GitVersion;`
`4`	`5`	`using GitVersion.VersionCalculation;`
`5`	`6`	`using NUnit.Framework;`
`@@ -10,8 +11,9 @@ public class NewNextVersionCalculatorTests`
`10`	`11`	`[Test]`
`11`	`12`	`public void ShouldIncrementVersionBasedOnConfig()`
`12`	`13`	`{`
`13`		`- var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1));`
`14`		`- var sut = new NewNextVersionCalculator(baseCalculator);`
	`14`	`+ var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), DateTimeOffset.Now);`
	`15`	`+ var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);`
	`16`	`+ var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));`
`15`	`17`	`var config = new Config();`
`16`	`18`	`config.Branches.Add("master", new BranchConfig`
`17`	`19`	`{`
`@@ -27,8 +29,9 @@ public void ShouldIncrementVersionBasedOnConfig()`
`27`	`29`	`[Test]`
`28`	`30`	`public void DoesNotIncrementWhenBaseVersionSaysNotTo()`
`29`	`31`	`{`
`30`		`- var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1));`
`31`		`- var sut = new NewNextVersionCalculator(baseCalculator);`
	`32`	`+ var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), DateTimeOffset.Now);`
	`33`	`+ var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);`
	`34`	`+ var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));`
`32`	`35`	`var config = new Config();`
`33`	`36`	`config.Branches.Add("master", new BranchConfig`
`34`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,15 @@ public BaseVersion GetBaseVersion(GitVersionContext context)`
`17`	`17`	`return strategies`
`18`	`18`	`.Select(s => s.GetVersion(context))`
`19`	`19`	`.Where(v => v != null)`
`20`		`- .Aggregate((v1, v2) => v1.SemanticVersion > v2.SemanticVersion ? v1 : v2);`
	`20`	`+ .Aggregate((v1, v2) =>`
	`21`	`+ {`
	`22`	`+ if (v1.SemanticVersion > v2.SemanticVersion)`
	`23`	`+ {`
	`24`	`+ return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionWhenFrom ?? v2.BaseVersionWhenFrom);`
	`25`	`+ }`
	`26`	`+`
	`27`	`+ return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionWhenFrom ?? v1.BaseVersionWhenFrom);`
	`28`	`+ });`
`21`	`29`	`}`
`22`	`30`	`}`
`23`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,25 @@`
`1`	`1`	`namespace GitVersion.VersionCalculation.BaseVersionCalculators`
`2`	`2`	`{`
	`3`	`+ using System;`
	`4`	`+`
`3`	`5`	`public class BaseVersion`
`4`	`6`	`{`
`5`		`- public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion)`
	`7`	`+ public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? baseVersionWhenFrom)`
`6`	`8`	`{`
`7`	`9`	`ShouldIncrement = shouldIncrement;`
`8`	`10`	`SemanticVersion = semanticVersion;`
	`11`	`+ BaseVersionWhenFrom = baseVersionWhenFrom;`
`9`	`12`	`}`
`10`	`13`
`11`	`14`	`public bool ShouldIncrement { get; private set; }`
`12`	`15`
`13`	`16`	`public SemanticVersion SemanticVersion { get; private set; }`
	`17`	`+`
	`18`	`+ /// <summary>`
	`19`	`+ /// Can be null even if the base version has a version`
	`20`	`+ ///`
	`21`	`+ /// This happens when the base version doesn't have a time it came from`
	`22`	`+ /// </summary>`
	`23`	`+ public DateTimeOffset? BaseVersionWhenFrom { get; private set; }`
`14`	`24`	`}`
`15`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ public override BaseVersion GetVersion(GitVersionContext context)`
`6`	`6`	`{`
`7`	`7`	`if (string.IsNullOrEmpty(context.Configuration.NextVersion))`
`8`	`8`	`return null;`
`9`		`- return new BaseVersion(false, SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix));`
	`9`	`+ return new BaseVersion(false, SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix), null);`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ public override BaseVersion GetVersion(GitVersionContext context)`
`6`	`6`	`{`
`7`	`7`	`VersionTaggedCommit version;`
`8`	`8`	`if (new LastTaggedReleaseFinder(context).GetVersion(out version))`
`9`		`- return new BaseVersion(true, version.SemVer);`
	`9`	`+ return new BaseVersion(true, version.SemVer, version.Commit.When());`
`10`	`10`
`11`	`11`	`return null;`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,13 @@ public class MergeMessageBaseVersionStrategy : BaseVersionStrategy`
`4`	`4`	`{`
`5`	`5`	`public override BaseVersion GetVersion(GitVersionContext context)`
`6`	`6`	`{`
`7`		`- // TODO when this approach works, inline the other class into here`
`8`		`- SemanticVersion semanticVersion;`
`9`		`- if (MergeMessageParser.TryParse(context.CurrentCommit, context.Configuration, out semanticVersion))`
`10`		`- return new BaseVersion(true, semanticVersion);`
`11`		`-`
	`7`	`+ foreach (var commit in context.CurrentBranch.CommitsPriorToThan(context.CurrentCommit.When()))`
	`8`	`+ {`
	`9`	`+ SemanticVersion semanticVersion;`
	`10`	`+ // TODO when this approach works, inline the other class into here`
	`11`	`+ if (MergeMessageParser.TryParse(context.CurrentCommit, context.Configuration, out semanticVersion))`
	`12`	`+ return new BaseVersion(true, semanticVersion, commit.When());`
	`13`	`+ }`
`12`	`14`	`return null;`
`13`	`15`	`}`
`14`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,11 @@`
`6`	`6`	`public class NewNextVersionCalculator`
`7`	`7`	`{`
`8`	`8`	`IBaseVersionCalculator baseVersionFinder;`
	`9`	`+ IMetaDataCalculator metaDataCalculator;`
`9`	`10`
`10`		`- public NewNextVersionCalculator(IBaseVersionCalculator baseVersionCalculator = null)`
	`11`	`+ public NewNextVersionCalculator(IBaseVersionCalculator baseVersionCalculator = null, IMetaDataCalculator metaDataCalculator = null)`
`11`	`12`	`{`
	`13`	`+ this.metaDataCalculator = metaDataCalculator ?? new MetaDataCalculator();`
`12`	`14`	`baseVersionFinder = baseVersionCalculator ??`
`13`	`15`	`new BaseVersionCalculator(`
`14`	`16`	`new ConfigNextVersionBaseVersionStrategy(),`
`@@ -22,6 +24,8 @@ public SemanticVersion FindVersion(GitVersionContext context)`
`22`	`24`
`23`	`25`	`if (baseVersion.ShouldIncrement) IncrementVersion(context, baseVersion);`
`24`	`26`
	`27`	`+ baseVersion.SemanticVersion.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionWhenFrom, context);`
	`28`	`+`
`25`	`29`	`return baseVersion.SemanticVersion;`
`26`	`30`	`}`
`27`	`31`