Uncomment line in GitVersionFinder to test new way of doing things. It kinda works but lots of small differences causing test breaks

JakeGinnivan · JakeGinnivan · commit 7311fd5c7345 · 2015-01-10T23:09:49.000Z
diff --git a/GitVersionCore.Tests/GitVersionContextBuilder.cs b/GitVersionCore.Tests/GitVersionContextBuilder.cs
@@ -29,6 +29,18 @@ public GitVersionContextBuilder WithTaggedMaster()
             return this;
         }
 
+        public GitVersionContextBuilder WithDevelopBranch()
+        {
+            repository = CreateRepository();
+            var mockBranch = new MockBranch("develop")
+            {
+                new MockCommit()
+            };
+            ((MockBranchCollection) repository.Branches).Add(mockBranch);
+            ((MockRepository)repository).Head = mockBranch;
+            return this;
+        }
+
         public GitVersionContext Build()
         {
             return new GitVersionContext(repository ?? CreateRepository(), config ?? new Config());
diff --git a/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs b/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs
@@ -4,6 +4,7 @@
     using GitVersion;
     using GitVersion.VersionCalculation;
     using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using LibGit2Sharp;
     using NUnit.Framework;
     using Shouldly;
 
@@ -21,7 +22,7 @@ public void ChoosesHighestVersionReturnedFromStrategies()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionWhenFrom.ShouldBe(dateTimeOffset);
+            baseVersion.BaseVersionSource.When().ShouldBe(dateTimeOffset);
         }
 
         [Test]
@@ -35,7 +36,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionWhenFrom.ShouldBe(when);
+            baseVersion.BaseVersionSource.When().ShouldBe(when);
         }
 
         [Test]
@@ -49,16 +50,16 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionWhenFrom.ShouldBe(when);
+            baseVersion.BaseVersionSource.When().ShouldBe(when);
         }
 
         class V1Strategy : BaseVersionStrategy
         {
-            readonly DateTimeOffset? when;
+            readonly Commit when;
 
             public V1Strategy(DateTimeOffset? when)
             {
-                this.when = when;
+                this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };
             }
 
             public override BaseVersion GetVersion(GitVersionContext context)
@@ -69,11 +70,11 @@ public override BaseVersion GetVersion(GitVersionContext context)
 
         class V2Strategy : BaseVersionStrategy
         {
-            DateTimeOffset? when;
+            Commit when;
 
             public V2Strategy(DateTimeOffset? when)
             {
-                this.when = when;
+                this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };
             }
 
             public override BaseVersion GetVersion(GitVersionContext context)
diff --git a/GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs b/GitVersionCore.Tests/VersionCalculation/NewNextVersionCalculatorTests.cs
@@ -11,7 +11,7 @@ public class NewNextVersionCalculatorTests
         [Test]
         public void ShouldIncrementVersionBasedOnConfig()
         {
-            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), DateTimeOffset.Now);
+            var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), new MockCommit());
             var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
             var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
             var config = new Config();
@@ -29,7 +29,7 @@ public void ShouldIncrementVersionBasedOnConfig()
         [Test]
         public void DoesNotIncrementWhenBaseVersionSaysNotTo()
         {
-            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), DateTimeOffset.Now);
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
             var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
             var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
             var config = new Config();
@@ -43,5 +43,20 @@ public void DoesNotIncrementWhenBaseVersionSaysNotTo()
 
             version.ToString().ShouldBe("1.0.0");
         }
+
+        [Test]
+        public void AppliesBranchPreReleaseTag()
+        {
+            var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
+            var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "develop", "b1a34e", DateTimeOffset.Now);
+            var sut = new NewNextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
+            var context = new GitVersionContextBuilder()
+                .WithDevelopBranch()
+                .Build();
+
+            var version = sut.FindVersion(context);
+
+            version.ToString().ShouldBe("1.0.0-unstable.1");
+        }
     }
 }
diff --git a/GitVersionCore.Tests/VersionCalculation/TestBaseVersionCalculator.cs b/GitVersionCore.Tests/VersionCalculation/TestBaseVersionCalculator.cs
@@ -1,26 +1,26 @@
 namespace GitVersionCore.Tests.VersionCalculation
 {
-    using System;
     using GitVersion;
     using GitVersion.VersionCalculation;
     using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using LibGit2Sharp;
 
     public class TestBaseVersionCalculator : IBaseVersionCalculator
     {
         readonly SemanticVersion semanticVersion;
         bool shouldIncrement;
-        DateTimeOffset? when;
+        Commit source;
 
-        public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? when)
+        public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion, Commit source)
         {
             this.semanticVersion = semanticVersion;
-            this.when = when;
+            this.source = source;
             this.shouldIncrement = shouldIncrement;
         }
 
         public BaseVersion GetBaseVersion(GitVersionContext context)
         {
-            return new BaseVersion(shouldIncrement, semanticVersion, when);
+            return new BaseVersion(shouldIncrement, semanticVersion, source);
         }
     }
 }
diff --git a/GitVersionCore.Tests/VersionCalculation/TestMetaDataCalculator.cs b/GitVersionCore.Tests/VersionCalculation/TestMetaDataCalculator.cs
@@ -1,8 +1,8 @@
 ﻿namespace GitVersionCore.Tests.VersionCalculation
 {
-    using System;
     using GitVersion;
     using GitVersion.VersionCalculation;
+    using LibGit2Sharp;
 
     public class TestMetaDataCalculator : IMetaDataCalculator
     {
@@ -13,7 +13,7 @@ public TestMetaDataCalculator(SemanticVersionBuildMetaData metaData)
             this.metaData = metaData;
         }
 
-        public SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context)
+        public SemanticVersionBuildMetaData Create(Commit baseVersionSource, GitVersionContext context)
         {
             return metaData;
         }
diff --git a/GitVersionCore/Configuration/Config.cs b/GitVersionCore/Configuration/Config.cs
@@ -18,6 +18,7 @@ public Config()
             Branches["develop"] = new BranchConfig
             {
                 Tag = "unstable",
+                Increment = IncrementStrategy.Minor,
                 VersioningMode = GitVersion.VersioningMode.ContinuousDeployment
             };
         }
diff --git a/GitVersionCore/GitVersionFinder.cs b/GitVersionCore/GitVersionFinder.cs
@@ -10,6 +10,8 @@ public SemanticVersion FindVersion(GitVersionContext context)
             Logger.WriteInfo("Running against branch: " + context.CurrentBranch.Name);
             EnsureMainTopologyConstraints(context);
 
+            //return new NewNextVersionCalculator().FindVersion(context);
+
             if (ShouldGitHubFlowVersioningSchemeApply(context.Repository))
             {
                 Logger.WriteInfo("GitHubFlow version strategy will be used");
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs
@@ -21,10 +21,10 @@ public BaseVersion GetBaseVersion(GitVersionContext context)
                 {
                     if (v1.SemanticVersion > v2.SemanticVersion)
                     {
-                        return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionWhenFrom ?? v2.BaseVersionWhenFrom);
+                        return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionSource ?? v2.BaseVersionSource);
                     }
 
-                    return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionWhenFrom ?? v1.BaseVersionWhenFrom);
+                    return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionSource ?? v1.BaseVersionSource);
                 });
         }
     }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/BaseVersion.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/BaseVersion.cs
@@ -1,25 +1,20 @@
 ﻿namespace GitVersion.VersionCalculation.BaseVersionCalculators
 {
-    using System;
+    using LibGit2Sharp;
 
     public class BaseVersion
     {
-        public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? baseVersionWhenFrom)
+        public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, Commit baseVersionSource)
         {
             ShouldIncrement = shouldIncrement;
             SemanticVersion = semanticVersion;
-            BaseVersionWhenFrom = baseVersionWhenFrom;
+            BaseVersionSource = baseVersionSource;
         }
 
         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; }
+        public Commit BaseVersionSource { get; private set; }
     }
 }
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, version.Commit.When());
+                return new BaseVersion(true, version.SemVer, version.Commit);
 
             return null;
         }
diff --git a/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageBaseVersionStrategy.cs b/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageBaseVersionStrategy.cs
@@ -9,7 +9,7 @@ public override BaseVersion GetVersion(GitVersionContext context)
                 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 new BaseVersion(true, semanticVersion, commit);
             }
             return null;
         }
diff --git a/GitVersionCore/VersionCalculation/IMetaDataCalculator.cs b/GitVersionCore/VersionCalculation/IMetaDataCalculator.cs
@@ -1,9 +1,9 @@
 ﻿namespace GitVersion.VersionCalculation
 {
-    using System;
+    using LibGit2Sharp;
 
     public interface IMetaDataCalculator
     {
-        SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context);
+        SemanticVersionBuildMetaData Create(Commit baseVersionSource, GitVersionContext context);
     }
 }
diff --git a/GitVersionCore/VersionCalculation/MetaDataCalculator.cs b/GitVersionCore/VersionCalculation/MetaDataCalculator.cs
@@ -1,16 +1,15 @@
 ﻿namespace GitVersion.VersionCalculation
 {
-    using System;
     using System.Linq;
     using LibGit2Sharp;
 
     public class MetaDataCalculator : IMetaDataCalculator
     {
-        public SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context)
+        public SemanticVersionBuildMetaData Create(Commit baseVersionSource, GitVersionContext context)
         {
             var qf = new CommitFilter
             {
-                Since = baseVersionWhenFrom,
+                Since = baseVersionSource,
                 Until = context.CurrentCommit,
                 SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Time
             };
diff --git a/GitVersionCore/VersionCalculation/NewNextVersionCalculator.cs b/GitVersionCore/VersionCalculation/NewNextVersionCalculator.cs
@@ -24,7 +24,12 @@ public SemanticVersion FindVersion(GitVersionContext context)
 
             if (baseVersion.ShouldIncrement) IncrementVersion(context, baseVersion);
 
-            baseVersion.SemanticVersion.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionWhenFrom, context);
+            if (!baseVersion.SemanticVersion.PreReleaseTag.HasTag() && !string.IsNullOrEmpty(context.Configuration.Tag))
+            {
+                baseVersion.SemanticVersion.PreReleaseTag = new SemanticVersionPreReleaseTag(context.Configuration.Tag, 1);
+            }
+
+            baseVersion.SemanticVersion.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionSource, context);
 
             return baseVersion.SemanticVersion;
         }

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using GitVersion;`
`5`	`5`	`using GitVersion.VersionCalculation;`
`6`	`6`	`using GitVersion.VersionCalculation.BaseVersionCalculators;`
	`7`	`+ using LibGit2Sharp;`
`7`	`8`	`using NUnit.Framework;`
`8`	`9`	`using Shouldly;`
`9`	`10`
`@@ -21,7 +22,7 @@ public void ChoosesHighestVersionReturnedFromStrategies()`
`21`	`22`
`22`	`23`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`23`	`24`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`24`		`- baseVersion.BaseVersionWhenFrom.ShouldBe(dateTimeOffset);`
	`25`	`+ baseVersion.BaseVersionSource.When().ShouldBe(dateTimeOffset);`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`[Test]`
`@@ -35,7 +36,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()`
`35`	`36`
`36`	`37`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`37`	`38`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`38`		`- baseVersion.BaseVersionWhenFrom.ShouldBe(when);`
	`39`	`+ baseVersion.BaseVersionSource.When().ShouldBe(when);`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`[Test]`
`@@ -49,16 +50,16 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()`
`49`	`50`
`50`	`51`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`51`	`52`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`52`		`- baseVersion.BaseVersionWhenFrom.ShouldBe(when);`
	`53`	`+ baseVersion.BaseVersionSource.When().ShouldBe(when);`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`class V1Strategy : BaseVersionStrategy`
`56`	`57`	`{`
`57`		`- readonly DateTimeOffset? when;`
	`58`	`+ readonly Commit when;`
`58`	`59`
`59`	`60`	`public V1Strategy(DateTimeOffset? when)`
`60`	`61`	`{`
`61`		`- this.when = when;`
	`62`	`+ this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`public override BaseVersion GetVersion(GitVersionContext context)`
`@@ -69,11 +70,11 @@ public override BaseVersion GetVersion(GitVersionContext context)`
`69`	`70`
`70`	`71`	`class V2Strategy : BaseVersionStrategy`
`71`	`72`	`{`
`72`		`- DateTimeOffset? when;`
	`73`	`+ Commit when;`
`73`	`74`
`74`	`75`	`public V2Strategy(DateTimeOffset? when)`
`75`	`76`	`{`
`76`		`- this.when = when;`
	`77`	`+ this.when = when == null ? null : new MockCommit { CommitterEx = when.Value.ToSignature() };`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`public override BaseVersion GetVersion(GitVersionContext context)`
Original file line number	Diff line number	Diff line change
`@@ -1,26 +1,26 @@`
`1`	`1`	`namespace GitVersionCore.Tests.VersionCalculation`
`2`	`2`	`{`
`3`		`- using System;`
`4`	`3`	`using GitVersion;`
`5`	`4`	`using GitVersion.VersionCalculation;`
`6`	`5`	`using GitVersion.VersionCalculation.BaseVersionCalculators;`
	`6`	`+ using LibGit2Sharp;`
`7`	`7`
`8`	`8`	`public class TestBaseVersionCalculator : IBaseVersionCalculator`
`9`	`9`	`{`
`10`	`10`	`readonly SemanticVersion semanticVersion;`
`11`	`11`	`bool shouldIncrement;`
`12`		`- DateTimeOffset? when;`
	`12`	`+ Commit source;`
`13`	`13`
`14`		`- public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? when)`
	`14`	`+ public TestBaseVersionCalculator(bool shouldIncrement, SemanticVersion semanticVersion, Commit source)`
`15`	`15`	`{`
`16`	`16`	`this.semanticVersion = semanticVersion;`
`17`		`- this.when = when;`
	`17`	`+ this.source = source;`
`18`	`18`	`this.shouldIncrement = shouldIncrement;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public BaseVersion GetBaseVersion(GitVersionContext context)`
`22`	`22`	`{`
`23`		`- return new BaseVersion(shouldIncrement, semanticVersion, when);`
	`23`	`+ return new BaseVersion(shouldIncrement, semanticVersion, source);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`namespace GitVersionCore.Tests.VersionCalculation`
`2`	`2`	`{`
`3`		`- using System;`
`4`	`3`	`using GitVersion;`
`5`	`4`	`using GitVersion.VersionCalculation;`
	`5`	`+ using LibGit2Sharp;`
`6`	`6`
`7`	`7`	`public class TestMetaDataCalculator : IMetaDataCalculator`
`8`	`8`	`{`
`@@ -13,7 +13,7 @@ public TestMetaDataCalculator(SemanticVersionBuildMetaData metaData)`
`13`	`13`	`this.metaData = metaData;`
`14`	`14`	`}`
`15`	`15`
`16`		`- public SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context)`
	`16`	`+ public SemanticVersionBuildMetaData Create(Commit baseVersionSource, GitVersionContext context)`
`17`	`17`	`{`
`18`	`18`	`return metaData;`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ public Config()`
`18`	`18`	`Branches["develop"] = new BranchConfig`
`19`	`19`	`{`
`20`	`20`	`Tag = "unstable",`
	`21`	`+ Increment = IncrementStrategy.Minor,`
`21`	`22`	`VersioningMode = GitVersion.VersioningMode.ContinuousDeployment`
`22`	`23`	`};`
`23`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@ public SemanticVersion FindVersion(GitVersionContext context)`
`10`	`10`	`Logger.WriteInfo("Running against branch: " + context.CurrentBranch.Name);`
`11`	`11`	`EnsureMainTopologyConstraints(context);`
`12`	`12`
	`13`	`+ //return new NewNextVersionCalculator().FindVersion(context);`
	`14`	`+`
`13`	`15`	`if (ShouldGitHubFlowVersioningSchemeApply(context.Repository))`
`14`	`16`	`{`
`15`	`17`	`Logger.WriteInfo("GitHubFlow version strategy will be used");`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,10 @@ public BaseVersion GetBaseVersion(GitVersionContext context)`
`21`	`21`	`{`
`22`	`22`	`if (v1.SemanticVersion > v2.SemanticVersion)`
`23`	`23`	`{`
`24`		`- return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionWhenFrom ?? v2.BaseVersionWhenFrom);`
	`24`	`+ return new BaseVersion(v1.ShouldIncrement, v1.SemanticVersion, v1.BaseVersionSource ?? v2.BaseVersionSource);`
`25`	`25`	`}`
`26`	`26`
`27`		`- return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionWhenFrom ?? v1.BaseVersionWhenFrom);`
	`27`	`+ return new BaseVersion(v2.ShouldIncrement, v2.SemanticVersion, v2.BaseVersionSource ?? v1.BaseVersionSource);`
`28`	`28`	`});`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,20 @@`
`1`	`1`	`namespace GitVersion.VersionCalculation.BaseVersionCalculators`
`2`	`2`	`{`
`3`		`- using System;`
	`3`	`+ using LibGit2Sharp;`
`4`	`4`
`5`	`5`	`public class BaseVersion`
`6`	`6`	`{`
`7`		`- public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, DateTimeOffset? baseVersionWhenFrom)`
	`7`	`+ public BaseVersion(bool shouldIncrement, SemanticVersion semanticVersion, Commit baseVersionSource)`
`8`	`8`	`{`
`9`	`9`	`ShouldIncrement = shouldIncrement;`
`10`	`10`	`SemanticVersion = semanticVersion;`
`11`		`- BaseVersionWhenFrom = baseVersionWhenFrom;`
	`11`	`+ BaseVersionSource = baseVersionSource;`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`public bool ShouldIncrement { get; private set; }`
`15`	`15`
`16`	`16`	`public SemanticVersion SemanticVersion { get; private set; }`
`17`	`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; }`
	`18`	`+ public Commit BaseVersionSource { get; private set; }`
`24`	`19`	`}`
`25`	`20`	`}`
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, version.Commit.When());`
	`9`	`+ return new BaseVersion(true, version.SemVer, version.Commit);`
`10`	`10`
`11`	`11`	`return null;`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public override BaseVersion GetVersion(GitVersionContext context)`
`9`	`9`	`SemanticVersion semanticVersion;`
`10`	`10`	`// TODO when this approach works, inline the other class into here`
`11`	`11`	`if (MergeMessageParser.TryParse(context.CurrentCommit, context.Configuration, out semanticVersion))`
`12`		`- return new BaseVersion(true, semanticVersion, commit.When());`
	`12`	`+ return new BaseVersion(true, semanticVersion, commit);`
`13`	`13`	`}`
`14`	`14`	`return null;`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,9 @@`
`1`	`1`	`namespace GitVersion.VersionCalculation`
`2`	`2`	`{`
`3`		`- using System;`
	`3`	`+ using LibGit2Sharp;`
`4`	`4`
`5`	`5`	`public interface IMetaDataCalculator`
`6`	`6`	`{`
`7`		`- SemanticVersionBuildMetaData Create(DateTimeOffset? baseVersionWhenFrom, GitVersionContext context);`
	`7`	`+ SemanticVersionBuildMetaData Create(Commit baseVersionSource, GitVersionContext context);`
`8`	`8`	`}`
`9`	`9`	`}`