cleanup

arturcic · arturcic · commit fa6d7eca72ed · 2021-01-19T17:12:49.000+02:00
diff --git a/src/GitVersion.LibGit2Sharp/Git/Commit.cs b/src/GitVersion.LibGit2Sharp/Git/Commit.cs
@@ -9,40 +9,40 @@ internal class Commit : ICommit
         private static readonly LambdaEqualityHelper<ICommit> equalityHelper = new(x => x.Id);
         private static readonly LambdaKeyComparer<ICommit, string> comparerHelper = new(x => x.Sha);
 
-        private readonly LibGit2Sharp.Commit innerObjectId;
+        private readonly LibGit2Sharp.Commit innerCommit;
 
-        internal Commit(LibGit2Sharp.Commit objectId) => innerObjectId = objectId;
+        internal Commit(LibGit2Sharp.Commit objectId) => innerCommit = objectId;
 
         public int CompareTo(ICommit other) => comparerHelper.Compare(this, other);
         public override bool Equals(object obj) => Equals((obj as ICommit)!);
         public bool Equals(ICommit other) => equalityHelper.Equals(this, other);
         public override int GetHashCode() => equalityHelper.GetHashCode(this);
 
-        public static implicit operator LibGit2Sharp.Commit(Commit d) => d.innerObjectId;
+        public static implicit operator LibGit2Sharp.Commit(Commit d) => d.innerCommit;
 
         public virtual IEnumerable<ICommit?> Parents
         {
             get
             {
-                if (innerObjectId == null) yield return null;
+                if (innerCommit == null) yield return null;
                 else
-                    foreach (var parent in innerObjectId.Parents)
+                    foreach (var parent in innerCommit.Parents)
                         yield return new Commit(parent);
             }
         }
 
-        public virtual string Sha => innerObjectId.Sha;
+        public virtual string Sha => innerCommit.Sha;
 
         public virtual IObjectId? Id
         {
             get
             {
-                var objectId = innerObjectId.Id;
+                var objectId = innerCommit.Id;
                 return objectId is null ? null : new ObjectId(objectId);
             }
         }
 
-        public virtual DateTimeOffset CommitterWhen => innerObjectId.Committer.When;
-        public virtual string Message => innerObjectId.Message;
+        public virtual DateTimeOffset When => innerCommit.Committer.When;
+        public virtual string Message => innerCommit.Message;
     }
 }
diff --git a/src/GitVersion.LibGit2Sharp/Git/CommitCollection.cs b/src/GitVersion.LibGit2Sharp/Git/CommitCollection.cs
@@ -18,7 +18,7 @@ public virtual IEnumerator<ICommit> GetEnumerator()
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        public IEnumerable<ICommit> GetCommitsPriorTo(DateTimeOffset olderThan) => this.SkipWhile(c => c.CommitterWhen > olderThan);
+        public IEnumerable<ICommit> GetCommitsPriorTo(DateTimeOffset olderThan) => this.SkipWhile(c => c.When > olderThan);
         public virtual ICommitCollection QueryBy(CommitFilter commitFilter)
         {
             static object? GetReacheableFrom(object item)
diff --git a/src/GitVersionCore.Tests/Extensions/GitToolsTestingExtensions.cs b/src/GitVersionCore.Tests/Extensions/GitToolsTestingExtensions.cs
@@ -34,7 +34,7 @@ public static ICommit CreateMockCommit()
             commit.Sha.Returns(objectId.Sha);
             commit.Message.Returns("Commit " + commitCount++);
             commit.Parents.Returns(Enumerable.Empty<ICommit>());
-            commit.CommitterWhen.Returns(when.AddSeconds(1));
+            commit.When.Returns(when.AddSeconds(1));
             return commit;
         }
         public static IBranch CreateMockBranch(string name, params ICommit[] commits)
diff --git a/src/GitVersionCore.Tests/IntegrationTests/IgnoreBeforeScenarios.cs b/src/GitVersionCore.Tests/IntegrationTests/IgnoreBeforeScenarios.cs
@@ -19,14 +19,14 @@ public void ShouldFallbackToBaseVersionWhenAllCommitsAreIgnored()
             var objectId = fixture.Repository.MakeACommit();
             var commit = Substitute.For<ICommit>();
             commit.Sha.Returns(objectId.Sha);
-            commit.CommitterWhen.Returns(DateTimeOffset.Now);
+            commit.When.Returns(DateTimeOffset.Now);
 
             var config = new ConfigurationBuilder()
                 .Add(new Config
                 {
                     Ignore = new IgnoreConfig
                     {
-                        Before = commit.CommitterWhen.AddMinutes(1)
+                        Before = commit.When.AddMinutes(1)
                     }
                 }).Build();
 
diff --git a/src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs b/src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs
@@ -33,7 +33,7 @@ public void ChoosesHighestVersionReturnedFromStrategies()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(dateTimeOffset);
+            baseVersion.BaseVersionSource.When.ShouldBe(dateTimeOffset);
         }
 
         [Test]
@@ -55,7 +55,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(when);
+            baseVersion.BaseVersionSource.When.ShouldBe(when);
         }
 
         [Test]
@@ -77,7 +77,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()
 
             baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");
             baseVersion.ShouldIncrement.ShouldBe(true);
-            baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(when);
+            baseVersion.BaseVersionSource.When.ShouldBe(when);
         }
 
         [Test]
@@ -220,7 +220,7 @@ public V1Strategy(DateTimeOffset? when)
                 if (when != null)
                 {
                     this.when = GitToolsTestingExtensions.CreateMockCommit();
-                    this.when.CommitterWhen.Returns(when.Value);
+                    this.when.When.Returns(when.Value);
                 }
                 else
                 {
@@ -243,7 +243,7 @@ public V2Strategy(DateTimeOffset? when)
                 if (when != null)
                 {
                     this.when = GitToolsTestingExtensions.CreateMockCommit();
-                    this.when.CommitterWhen.Returns(when.Value);
+                    this.when.When.Returns(when.Value);
                 }
                 else
                 {
diff --git a/src/GitVersionCore/Core/Abstractions/Git/ICommit.cs b/src/GitVersionCore/Core/Abstractions/Git/ICommit.cs
@@ -8,7 +8,7 @@ public interface ICommit : IEquatable<ICommit>, IComparable<ICommit>
         IEnumerable<ICommit> Parents { get; }
         string Sha { get; }
         IObjectId Id { get; }
-        DateTimeOffset CommitterWhen { get; }
+        DateTimeOffset When { get; }
         string Message { get; }
     }
 }
diff --git a/src/GitVersionCore/Core/RepositoryMetadataProvider.cs b/src/GitVersionCore/Core/RepositoryMetadataProvider.cs
@@ -371,7 +371,7 @@ public IEnumerable<Tuple<ITag, SemanticVersion>> GetValidVersionTags(string tagP
                 if (commit == null)
                     continue;
 
-                if (olderThan.HasValue && commit.CommitterWhen > olderThan.Value)
+                if (olderThan.HasValue && commit.When > olderThan.Value)
                     continue;
 
                 if (SemanticVersion.TryParse(tag.FriendlyName, tagPrefixRegex, out var semver))
@@ -435,7 +435,7 @@ private IEnumerable<BranchCommit> GetMergeCommitsForBranch(IBranch branch, Confi
                     return new BranchCommit(findMergeBase, otherBranch);
                 })
                 .Where(b => b.Commit != null)
-                .OrderByDescending(b => b.Commit.CommitterWhen)
+                .OrderByDescending(b => b.Commit.When)
                 .ToList();
             mergeBaseCommitsCache.Add(branch, branchMergeBases);
 
diff --git a/src/GitVersionCore/Helpers/LambdaKeyComparer.cs b/src/GitVersionCore/Helpers/LambdaKeyComparer.cs
@@ -5,15 +5,15 @@ namespace GitVersion.Helpers
 {
     public class LambdaKeyComparer<TSource, TKey> : Comparer<TSource> where TSource : class
     {
-        private readonly Func<TSource, TKey> _keySelector;
-        private readonly IComparer<TKey> _innerComparer;
+        private readonly Func<TSource, TKey> keySelector;
+        private readonly IComparer<TKey> innerComparer;
 
         public LambdaKeyComparer(
             Func<TSource, TKey> keySelector,
             IComparer<TKey> innerComparer = null)
         {
-            _keySelector = keySelector;
-            _innerComparer = innerComparer ?? Comparer<TKey>.Default;
+            this.keySelector = keySelector;
+            this.innerComparer = innerComparer ?? Comparer<TKey>.Default;
         }
 
         public override int Compare(TSource x, TSource y)
@@ -25,9 +25,9 @@ public override int Compare(TSource x, TSource y)
             if (y == null)
                 return 1;
 
-            var xKey = _keySelector(x);
-            var yKey = _keySelector(y);
-            return _innerComparer.Compare(xKey, yKey);
+            var xKey = keySelector(x);
+            var yKey = keySelector(y);
+            return innerComparer.Compare(xKey, yKey);
         }
     }
 }
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs
@@ -58,7 +58,7 @@ public BaseVersion GetBaseVersion()
                 BaseVersion baseVersionWithOldestSource;
                 if (matchingVersionsOnceIncremented.Any())
                 {
-                    var oldest = matchingVersionsOnceIncremented.Aggregate((v1, v2) => v1.Version.BaseVersionSource.CommitterWhen < v2.Version.BaseVersionSource.CommitterWhen ? v1 : v2);
+                    var oldest = matchingVersionsOnceIncremented.Aggregate((v1, v2) => v1.Version.BaseVersionSource.When < v2.Version.BaseVersionSource.When ? v1 : v2);
                     baseVersionWithOldestSource = oldest.Version;
                     maxVersion = oldest;
                     log.Info($"Found multiple base versions which will produce the same SemVer ({maxVersion.IncrementedVersion}), taking oldest source for commit counting ({baseVersionWithOldestSource.Source})");
@@ -68,7 +68,7 @@ public BaseVersion GetBaseVersion()
                     baseVersionWithOldestSource = versions
                         .Where(v => v.Version.BaseVersionSource != null)
                         .OrderByDescending(v => v.IncrementedVersion)
-                        .ThenByDescending(v => v.Version.BaseVersionSource.CommitterWhen)
+                        .ThenByDescending(v => v.Version.BaseVersionSource.When)
                         .First()
                         .Version;
                 }
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageVersionStrategy.cs
@@ -24,7 +24,7 @@ public MergeMessageVersionStrategy(ILog log, Lazy<GitVersionContext> versionCont
 
         public override IEnumerable<BaseVersion> GetVersions()
         {
-            var commitsPriorToThan = Context.CurrentBranch.Commits.GetCommitsPriorTo(Context.CurrentCommit.CommitterWhen);
+            var commitsPriorToThan = Context.CurrentBranch.Commits.GetCommitsPriorTo(Context.CurrentCommit.When);
             var baseVersions = commitsPriorToThan
                 .SelectMany(c =>
                 {
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs
@@ -21,7 +21,7 @@ public TaggedCommitVersionStrategy(IRepositoryMetadataProvider repositoryMetadat
 
         public override IEnumerable<BaseVersion> GetVersions()
         {
-            return GetTaggedVersions(Context.CurrentBranch, Context.CurrentCommit.CommitterWhen);
+            return GetTaggedVersions(Context.CurrentBranch, Context.CurrentCommit.When);
         }
 
         internal IEnumerable<BaseVersion> GetTaggedVersions(IBranch currentBranch, DateTimeOffset? olderThan)
diff --git a/src/GitVersionCore/VersionCalculation/MainlineVersionCalculator.cs b/src/GitVersionCore/VersionCalculation/MainlineVersionCalculator.cs
@@ -96,7 +96,7 @@ public SemanticVersionBuildMetaData CreateVersionBuildMetaData(ICommit baseVersi
                 context.CurrentBranch.FriendlyName,
                 context.CurrentCommit.Sha,
                 shortSha,
-                context.CurrentCommit.CommitterWhen,
+                context.CurrentCommit.When,
                 context.NumberOfUncommittedChanges);
         }
 
diff --git a/src/GitVersionCore/VersionCalculation/MinDateVersionFilter.cs b/src/GitVersionCore/VersionCalculation/MinDateVersionFilter.cs
@@ -18,7 +18,7 @@ public bool Exclude(BaseVersion version, out string reason)
             reason = null;
 
             if (version.BaseVersionSource != null &&
-                version.BaseVersionSource.CommitterWhen < minimum)
+                version.BaseVersionSource.When < minimum)
             {
                 reason = "Source was ignored due to commit date being outside of configured range";
                 return true;

Original file line number	Diff line number	Diff line change
`@@ -9,40 +9,40 @@ internal class Commit : ICommit`
`9`	`9`	`private static readonly LambdaEqualityHelper<ICommit> equalityHelper = new(x => x.Id);`
`10`	`10`	`private static readonly LambdaKeyComparer<ICommit, string> comparerHelper = new(x => x.Sha);`
`11`	`11`
`12`		`- private readonly LibGit2Sharp.Commit innerObjectId;`
	`12`	`+ private readonly LibGit2Sharp.Commit innerCommit;`
`13`	`13`
`14`		`- internal Commit(LibGit2Sharp.Commit objectId) => innerObjectId = objectId;`
	`14`	`+ internal Commit(LibGit2Sharp.Commit objectId) => innerCommit = objectId;`
`15`	`15`
`16`	`16`	`public int CompareTo(ICommit other) => comparerHelper.Compare(this, other);`
`17`	`17`	`public override bool Equals(object obj) => Equals((obj as ICommit)!);`
`18`	`18`	`public bool Equals(ICommit other) => equalityHelper.Equals(this, other);`
`19`	`19`	`public override int GetHashCode() => equalityHelper.GetHashCode(this);`
`20`	`20`
`21`		`- public static implicit operator LibGit2Sharp.Commit(Commit d) => d.innerObjectId;`
	`21`	`+ public static implicit operator LibGit2Sharp.Commit(Commit d) => d.innerCommit;`
`22`	`22`
`23`	`23`	`public virtual IEnumerable<ICommit?> Parents`
`24`	`24`	`{`
`25`	`25`	`get`
`26`	`26`	`{`
`27`		`- if (innerObjectId == null) yield return null;`
	`27`	`+ if (innerCommit == null) yield return null;`
`28`	`28`	`else`
`29`		`- foreach (var parent in innerObjectId.Parents)`
	`29`	`+ foreach (var parent in innerCommit.Parents)`
`30`	`30`	`yield return new Commit(parent);`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`		`- public virtual string Sha => innerObjectId.Sha;`
	`34`	`+ public virtual string Sha => innerCommit.Sha;`
`35`	`35`
`36`	`36`	`public virtual IObjectId? Id`
`37`	`37`	`{`
`38`	`38`	`get`
`39`	`39`	`{`
`40`		`- var objectId = innerObjectId.Id;`
	`40`	`+ var objectId = innerCommit.Id;`
`41`	`41`	`return objectId is null ? null : new ObjectId(objectId);`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`- public virtual DateTimeOffset CommitterWhen => innerObjectId.Committer.When;`
`46`		`- public virtual string Message => innerObjectId.Message;`
	`45`	`+ public virtual DateTimeOffset When => innerCommit.Committer.When;`
	`46`	`+ public virtual string Message => innerCommit.Message;`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public virtual IEnumerator<ICommit> GetEnumerator()`
`18`	`18`
`19`	`19`	`IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();`
`20`	`20`
`21`		`- public IEnumerable<ICommit> GetCommitsPriorTo(DateTimeOffset olderThan) => this.SkipWhile(c => c.CommitterWhen > olderThan);`
	`21`	`+ public IEnumerable<ICommit> GetCommitsPriorTo(DateTimeOffset olderThan) => this.SkipWhile(c => c.When > olderThan);`
`22`	`22`	`public virtual ICommitCollection QueryBy(CommitFilter commitFilter)`
`23`	`23`	`{`
`24`	`24`	`static object? GetReacheableFrom(object item)`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public static ICommit CreateMockCommit()`
`34`	`34`	`commit.Sha.Returns(objectId.Sha);`
`35`	`35`	`commit.Message.Returns("Commit " + commitCount++);`
`36`	`36`	`commit.Parents.Returns(Enumerable.Empty<ICommit>());`
`37`		`- commit.CommitterWhen.Returns(when.AddSeconds(1));`
	`37`	`+ commit.When.Returns(when.AddSeconds(1));`
`38`	`38`	`return commit;`
`39`	`39`	`}`
`40`	`40`	`public static IBranch CreateMockBranch(string name, params ICommit[] commits)`
Original file line number	Diff line number	Diff line change
`@@ -19,14 +19,14 @@ public void ShouldFallbackToBaseVersionWhenAllCommitsAreIgnored()`
`19`	`19`	`var objectId = fixture.Repository.MakeACommit();`
`20`	`20`	`var commit = Substitute.For<ICommit>();`
`21`	`21`	`commit.Sha.Returns(objectId.Sha);`
`22`		`- commit.CommitterWhen.Returns(DateTimeOffset.Now);`
	`22`	`+ commit.When.Returns(DateTimeOffset.Now);`
`23`	`23`
`24`	`24`	`var config = new ConfigurationBuilder()`
`25`	`25`	`.Add(new Config`
`26`	`26`	`{`
`27`	`27`	`Ignore = new IgnoreConfig`
`28`	`28`	`{`
`29`		`- Before = commit.CommitterWhen.AddMinutes(1)`
	`29`	`+ Before = commit.When.AddMinutes(1)`
`30`	`30`	`}`
`31`	`31`	`}).Build();`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void ChoosesHighestVersionReturnedFromStrategies()`
`33`	`33`
`34`	`34`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`35`	`35`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`36`		`- baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(dateTimeOffset);`
	`36`	`+ baseVersion.BaseVersionSource.When.ShouldBe(dateTimeOffset);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`[Test]`
`@@ -55,7 +55,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhen()`
`55`	`55`
`56`	`56`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`57`	`57`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`58`		`- baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(when);`
	`58`	`+ baseVersion.BaseVersionSource.When.ShouldBe(when);`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`[Test]`
`@@ -77,7 +77,7 @@ public void UsesWhenFromNextBestMatchIfHighestDoesntHaveWhenReversedOrder()`
`77`	`77`
`78`	`78`	`baseVersion.SemanticVersion.ToString().ShouldBe("2.0.0");`
`79`	`79`	`baseVersion.ShouldIncrement.ShouldBe(true);`
`80`		`- baseVersion.BaseVersionSource.CommitterWhen.ShouldBe(when);`
	`80`	`+ baseVersion.BaseVersionSource.When.ShouldBe(when);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`[Test]`
`@@ -220,7 +220,7 @@ public V1Strategy(DateTimeOffset? when)`
`220`	`220`	`if (when != null)`
`221`	`221`	`{`
`222`	`222`	`this.when = GitToolsTestingExtensions.CreateMockCommit();`
`223`		`- this.when.CommitterWhen.Returns(when.Value);`
	`223`	`+ this.when.When.Returns(when.Value);`
`224`	`224`	`}`
`225`	`225`	`else`
`226`	`226`	`{`
`@@ -243,7 +243,7 @@ public V2Strategy(DateTimeOffset? when)`
`243`	`243`	`if (when != null)`
`244`	`244`	`{`
`245`	`245`	`this.when = GitToolsTestingExtensions.CreateMockCommit();`
`246`		`- this.when.CommitterWhen.Returns(when.Value);`
	`246`	`+ this.when.When.Returns(when.Value);`
`247`	`247`	`}`
`248`	`248`	`else`
`249`	`249`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public interface ICommit : IEquatable<ICommit>, IComparable<ICommit>`
`8`	`8`	`IEnumerable<ICommit> Parents { get; }`
`9`	`9`	`string Sha { get; }`
`10`	`10`	`IObjectId Id { get; }`
`11`		`- DateTimeOffset CommitterWhen { get; }`
	`11`	`+ DateTimeOffset When { get; }`
`12`	`12`	`string Message { get; }`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,15 @@ namespace GitVersion.Helpers`
`5`	`5`	`{`
`6`	`6`	`public class LambdaKeyComparer<TSource, TKey> : Comparer<TSource> where TSource : class`
`7`	`7`	`{`
`8`		`- private readonly Func<TSource, TKey> _keySelector;`
`9`		`- private readonly IComparer<TKey> _innerComparer;`
	`8`	`+ private readonly Func<TSource, TKey> keySelector;`
	`9`	`+ private readonly IComparer<TKey> innerComparer;`
`10`	`10`
`11`	`11`	`public LambdaKeyComparer(`
`12`	`12`	`Func<TSource, TKey> keySelector,`
`13`	`13`	`IComparer<TKey> innerComparer = null)`
`14`	`14`	`{`
`15`		`- _keySelector = keySelector;`
`16`		`- _innerComparer = innerComparer ?? Comparer<TKey>.Default;`
	`15`	`+ this.keySelector = keySelector;`
	`16`	`+ this.innerComparer = innerComparer ?? Comparer<TKey>.Default;`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public override int Compare(TSource x, TSource y)`
`@@ -25,9 +25,9 @@ public override int Compare(TSource x, TSource y)`
`25`	`25`	`if (y == null)`
`26`	`26`	`return 1;`
`27`	`27`
`28`		`- var xKey = _keySelector(x);`
`29`		`- var yKey = _keySelector(y);`
`30`		`- return _innerComparer.Compare(xKey, yKey);`
	`28`	`+ var xKey = keySelector(x);`
	`29`	`+ var yKey = keySelector(y);`
	`30`	`+ return innerComparer.Compare(xKey, yKey);`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public MergeMessageVersionStrategy(ILog log, Lazy<GitVersionContext> versionCont`
`24`	`24`
`25`	`25`	`public override IEnumerable<BaseVersion> GetVersions()`
`26`	`26`	`{`
`27`		`- var commitsPriorToThan = Context.CurrentBranch.Commits.GetCommitsPriorTo(Context.CurrentCommit.CommitterWhen);`
	`27`	`+ var commitsPriorToThan = Context.CurrentBranch.Commits.GetCommitsPriorTo(Context.CurrentCommit.When);`
`28`	`28`	`var baseVersions = commitsPriorToThan`
`29`	`29`	`.SelectMany(c =>`
`30`	`30`	`{`