injected IGitVersionContextFactory into VersionStrategyBase

arturcic · arturcic · commit 57ecfd1c897b · 2020-03-23T17:08:46.000+02:00
diff --git a/src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs b/src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs
@@ -182,7 +182,7 @@ public V1Strategy(DateTimeOffset? when)
                 this.when = when == null ? null : new MockCommit { CommitterEx = Generate.Signature(when.Value) };
             }
 
-            public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+            public IEnumerable<BaseVersion> GetVersions()
             {
                 yield return new BaseVersion("Source 1", false, new SemanticVersion(1), when, null);
             }
@@ -197,7 +197,7 @@ public V2Strategy(DateTimeOffset? when)
                 this.when = when == null ? null : new MockCommit { CommitterEx = Generate.Signature(when.Value) };
             }
 
-            public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+            public IEnumerable<BaseVersion> GetVersions()
             {
                 yield return new BaseVersion("Source 2", true, new SemanticVersion(2), when, null);
             }
@@ -212,7 +212,7 @@ public TestVersionStrategy(params BaseVersion[] versions)
                 this.versions = versions;
             }
 
-            public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+            public IEnumerable<BaseVersion> GetVersions()
             {
                 return versions;
             }
diff --git a/src/GitVersionCore.Tests/VersionCalculation/Strategies/ConfigNextVersionBaseVersionStrategyTests.cs b/src/GitVersionCore.Tests/VersionCalculation/Strategies/ConfigNextVersionBaseVersionStrategyTests.cs
@@ -44,12 +44,11 @@ private static BaseVersion GetBaseVersion(Config config = null)
                 contextBuilder = contextBuilder.WithConfig(config);
             }
 
-            var gitVersionContext = contextBuilder.Build();
-
+            contextBuilder.Build();
             var contextFactory = contextBuilder.ServicesProvider.GetService<IGitVersionContextFactory>();
             var strategy = new ConfigNextVersionVersionStrategy(contextFactory);
 
-            return strategy.GetVersions(gitVersionContext).SingleOrDefault();
+            return strategy.GetVersions().SingleOrDefault();
         }
     }
 }
diff --git a/src/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs b/src/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs
@@ -29,13 +29,12 @@ public void ShouldNotAllowIncrementOfVersion()
                     ParentsEx = GetParents(true)
                 } }
             });
-            var context = contextBuilder.Build();
-
+            contextBuilder.Build();
             var log = contextBuilder.ServicesProvider.GetService<ILog>();
             var contextFactory = contextBuilder.ServicesProvider.GetService<IGitVersionContextFactory>();
             var strategy = new MergeMessageVersionStrategy(log, contextFactory);
 
-            var baseVersion = strategy.GetVersions(context).Single();
+            var baseVersion = strategy.GetVersions().Single();
 
             baseVersion.ShouldIncrement.ShouldBe(false);
         }
@@ -169,13 +168,12 @@ private void AssertMergeMessage(string message, string expectedVersion, IList<Co
                         new MockCommit()
                     }
                 });
-            var context = contextBuilder.Build();
-
+            contextBuilder.Build();
             var log = contextBuilder.ServicesProvider.GetService<ILog>();
             var contextFactory = contextBuilder.ServicesProvider.GetService<IGitVersionContextFactory>();
             var strategy = new MergeMessageVersionStrategy(log, contextFactory);
 
-            var baseVersion = strategy.GetVersions(context).SingleOrDefault();
+            var baseVersion = strategy.GetVersions().SingleOrDefault();
 
             if (expectedVersion == null)
             {
diff --git a/src/GitVersionCore.Tests/VersionCalculation/Strategies/VersionInBranchNameBaseVersionStrategyTests.cs b/src/GitVersionCore.Tests/VersionCalculation/Strategies/VersionInBranchNameBaseVersionStrategyTests.cs
@@ -29,8 +29,7 @@ public void CanTakeVersionFromNameOfReleaseBranch(string branchName, string expe
 
             var gitVersionContextFactory = GetGitVersionContextFactory();
             gitVersionContextFactory.Init(fixture.Repository, branch);
-            var context = gitVersionContextFactory.Context;
-            var baseVersion = strategy.GetVersions(context).Single();
+            var baseVersion = strategy.GetVersions().Single();
 
             baseVersion.SemanticVersion.ToString().ShouldBe(expectedBaseVersion);
         }
@@ -47,8 +46,7 @@ public void ShouldNotTakeVersionFromNameOfNonReleaseBranch(string branchName)
 
             var gitVersionContextFactory = GetGitVersionContextFactory();
             gitVersionContextFactory.Init(fixture.Repository, branch);
-            var context = gitVersionContextFactory.Context;
-            var baseVersions = strategy.GetVersions(context);
+            var baseVersions = strategy.GetVersions();
 
             baseVersions.ShouldBeEmpty();
         }
@@ -67,8 +65,7 @@ public void CanTakeVersionFromNameOfConfiguredReleaseBranch(string branchName, s
             var gitVersionContextFactory = GetGitVersionContextFactory(config);
 
             gitVersionContextFactory.Init(fixture.Repository, branch);
-            var context = gitVersionContextFactory.Context;
-            var baseVersion = strategy.GetVersions(context).Single();
+            var baseVersion = strategy.GetVersions().Single();
 
             baseVersion.SemanticVersion.ToString().ShouldBe(expectedBaseVersion);
         }
@@ -87,8 +84,7 @@ public void CanTakeVersionFromNameOfRemoteReleaseBranch(string branchName, strin
 
             var gitVersionContextFactory = GetGitVersionContextFactory();
             gitVersionContextFactory.Init(fixture.Repository, branch);
-            var context = gitVersionContextFactory.Context;
-            var baseVersion = strategy.GetVersions(context).Single();
+            var baseVersion = strategy.GetVersions().Single();
 
             baseVersion.SemanticVersion.ToString().ShouldBe(expectedBaseVersion);
         }
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs
@@ -22,10 +22,11 @@ public BaseVersionCalculator(ILog log, IGitVersionContextFactory gitVersionConte
         public BaseVersion GetBaseVersion()
         {
             var context = gitVersionContextFactory.Context;
+
             using (log.IndentLog("Calculating base versions"))
             {
                 var baseVersions = strategies
-                    .SelectMany(s => s.GetVersions(context))
+                    .SelectMany(s => s.GetVersions())
                     .Where(v =>
                     {
                         if (v == null) return false;
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/ConfigNextVersionVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/ConfigNextVersionVersionStrategy.cs
@@ -13,8 +13,9 @@ public ConfigNextVersionVersionStrategy(IGitVersionContextFactory gitVersionCont
         {
         }
 
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
+            var context = ContextFactory.Context;
             if (string.IsNullOrEmpty(context.Configuration.NextVersion) || context.IsCurrentCommitTagged)
                 yield break;
             var semanticVersion = SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix);
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/FallbackVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/FallbackVersionStrategy.cs
@@ -14,8 +14,9 @@ public class FallbackVersionStrategy : VersionStrategyBase
         public FallbackVersionStrategy(IGitVersionContextFactory gitVersionContextFactory) : base(gitVersionContextFactory)
         {
         }
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
+            var context = ContextFactory.Context;
             Commit baseVersionSource;
             var currentBranchTip = context.CurrentBranch.Tip;
 
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/MergeMessageVersionStrategy.cs
@@ -23,8 +23,9 @@ public MergeMessageVersionStrategy(ILog log, IGitVersionContextFactory gitVersio
             this.log = log ?? throw new ArgumentNullException(nameof(log));
         }
 
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
+            var context = ContextFactory.Context;
             var commitsPriorToThan = context.CurrentBranch
                 .CommitsPriorToThan(context.CurrentCommit.When());
             var baseVersions = commitsPriorToThan
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs
@@ -21,13 +21,15 @@ public TaggedCommitVersionStrategy(IGitRepoMetadataProvider gitRepoMetadataProvi
             this.gitRepoMetadataProvider = gitRepoMetadataProvider ?? throw new ArgumentNullException(nameof(gitRepoMetadataProvider));
         }
 
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
-            return GetTaggedVersions(context, context.CurrentBranch, context.CurrentCommit.When());
+            var context = ContextFactory.Context;
+            return GetTaggedVersions(context.CurrentBranch, context.CurrentCommit.When());
         }
 
-        public IEnumerable<BaseVersion> GetTaggedVersions(GitVersionContext context, Branch currentBranch, DateTimeOffset? olderThan)
+        internal IEnumerable<BaseVersion> GetTaggedVersions(Branch currentBranch, DateTimeOffset? olderThan)
         {
+            var context = ContextFactory.Context;
             var allTags = gitRepoMetadataProvider.GetValidVersionTags(context.Configuration.GitTagPrefix, olderThan);
 
             var tagsOnBranch = currentBranch
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TrackReleaseBranchesVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/TrackReleaseBranchesVersionStrategy.cs
@@ -38,8 +38,9 @@ public TrackReleaseBranchesVersionStrategy(IGitRepoMetadataProvider gitRepoMetad
             taggedCommitVersionStrategy = new TaggedCommitVersionStrategy(gitRepoMetadataProvider, gitVersionContextFactory);
         }
 
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
+            var context = ContextFactory.Context;
             if (context.Configuration.TracksReleaseBranches)
             {
                 return ReleaseBranchBaseVersions(context).Union(MasterTagsVersions(context));
@@ -53,7 +54,7 @@ private IEnumerable<BaseVersion> MasterTagsVersions(GitVersionContext context)
             var master = context.Repository.FindBranch("master");
             if (master != null)
             {
-                return taggedCommitVersionStrategy.GetTaggedVersions(context, master, null);
+                return taggedCommitVersionStrategy.GetTaggedVersions(master, null);
             }
 
             return new BaseVersion[0];
@@ -100,7 +101,7 @@ private IEnumerable<BaseVersion> GetReleaseVersion(GitVersionContext context, Br
             }
 
             return releaseVersionStrategy
-                .GetVersions(context, tagPrefixRegex, releaseBranch)
+                .GetVersions(tagPrefixRegex, releaseBranch)
                 .Select(b => new BaseVersion(b.Source, true, b.SemanticVersion, baseSource, b.BranchNameOverride));
         }
     }
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/VersionInBranchNameVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/VersionInBranchNameVersionStrategy.cs
@@ -21,15 +21,17 @@ public VersionInBranchNameVersionStrategy(IGitRepoMetadataProvider gitRepoMetada
             this.gitRepoMetadataProvider = gitRepoMetadataProvider ?? throw new ArgumentNullException(nameof(gitRepoMetadataProvider));
         }
 
-        public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+        public override IEnumerable<BaseVersion> GetVersions()
         {
+            var context = ContextFactory.Context;
             var currentBranch = context.CurrentBranch;
             var tagPrefixRegex = context.Configuration.GitTagPrefix;
-            return GetVersions(context, tagPrefixRegex, currentBranch);
+            return GetVersions(tagPrefixRegex, currentBranch);
         }
 
-        public IEnumerable<BaseVersion> GetVersions(GitVersionContext context, string tagPrefixRegex, Branch currentBranch)
+        internal IEnumerable<BaseVersion> GetVersions(string tagPrefixRegex, Branch currentBranch)
         {
+            var context = ContextFactory.Context;
             if (!context.FullConfiguration.IsReleaseBranch(currentBranch.NameWithoutOrigin()))
             {
                 yield break;
diff --git a/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/VersionStrategyBase.cs b/src/GitVersionCore/VersionCalculation/BaseVersionCalculators/VersionStrategyBase.cs
@@ -9,8 +9,11 @@ public class VersionStrategyBase : IVersionStrategy
 
         public VersionStrategyBase(IGitVersionContextFactory gitVersionContextFactory)
         {
-            this.ContextFactory = gitVersionContextFactory ?? throw new ArgumentNullException(nameof(gitVersionContextFactory));
+            ContextFactory = gitVersionContextFactory ?? throw new ArgumentNullException(nameof(gitVersionContextFactory));
+        }
+        public virtual IEnumerable<BaseVersion> GetVersions()
+        {
+            throw new NotImplementedException();
         }
-        public virtual IEnumerable<BaseVersion> GetVersions(GitVersionContext context) => throw new NotImplementedException();
     }
 }
diff --git a/src/GitVersionCore/VersionCalculation/IVersionStrategy.cs b/src/GitVersionCore/VersionCalculation/IVersionStrategy.cs
@@ -5,14 +5,11 @@ namespace GitVersion.VersionCalculation
     public interface IVersionStrategy
     {
         /// <summary>
-        /// Calculates the <see cref="T:GitVersion.VersionCalculation.BaseVersionCalculators.BaseVersion" /> values for the given <paramref name="context" />.
+        /// Calculates the <see cref="T:GitVersion.VersionCalculation.BaseVersionCalculators.BaseVersion" /> values.
         /// </summary>
-        /// <param name="context">
-        /// The context for calculating the <see cref="T:GitVersion.VersionCalculation.BaseVersionCalculators.BaseVersion" />.
-        /// </param>
         /// <returns>
         /// An <see cref="T:System.Collections.Generic.IEnumerable`1" /> of the base version values found by the strategy.
         /// </returns>
-        IEnumerable<BaseVersion> GetVersions(GitVersionContext context);
+        IEnumerable<BaseVersion> GetVersions();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ public V1Strategy(DateTimeOffset? when)`
`182`	`182`	`this.when = when == null ? null : new MockCommit { CommitterEx = Generate.Signature(when.Value) };`
`183`	`183`	`}`
`184`	`184`
`185`		`- public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`185`	`+ public IEnumerable<BaseVersion> GetVersions()`
`186`	`186`	`{`
`187`	`187`	`yield return new BaseVersion("Source 1", false, new SemanticVersion(1), when, null);`
`188`	`188`	`}`
`@@ -197,7 +197,7 @@ public V2Strategy(DateTimeOffset? when)`
`197`	`197`	`this.when = when == null ? null : new MockCommit { CommitterEx = Generate.Signature(when.Value) };`
`198`	`198`	`}`
`199`	`199`
`200`		`- public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`200`	`+ public IEnumerable<BaseVersion> GetVersions()`
`201`	`201`	`{`
`202`	`202`	`yield return new BaseVersion("Source 2", true, new SemanticVersion(2), when, null);`
`203`	`203`	`}`
`@@ -212,7 +212,7 @@ public TestVersionStrategy(params BaseVersion[] versions)`
`212`	`212`	`this.versions = versions;`
`213`	`213`	`}`
`214`	`214`
`215`		`- public IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`215`	`+ public IEnumerable<BaseVersion> GetVersions()`
`216`	`216`	`{`
`217`	`217`	`return versions;`
`218`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,12 +44,11 @@ private static BaseVersion GetBaseVersion(Config config = null)`
`44`	`44`	`contextBuilder = contextBuilder.WithConfig(config);`
`45`	`45`	`}`
`46`	`46`
`47`		`- var gitVersionContext = contextBuilder.Build();`
`48`		`-`
	`47`	`+ contextBuilder.Build();`
`49`	`48`	`var contextFactory = contextBuilder.ServicesProvider.GetService<IGitVersionContextFactory>();`
`50`	`49`	`var strategy = new ConfigNextVersionVersionStrategy(contextFactory);`
`51`	`50`
`52`		`- return strategy.GetVersions(gitVersionContext).SingleOrDefault();`
	`51`	`+ return strategy.GetVersions().SingleOrDefault();`
`53`	`52`	`}`
`54`	`53`	`}`
`55`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,11 @@ public BaseVersionCalculator(ILog log, IGitVersionContextFactory gitVersionConte`
`22`	`22`	`public BaseVersion GetBaseVersion()`
`23`	`23`	`{`
`24`	`24`	`var context = gitVersionContextFactory.Context;`
	`25`	`+`
`25`	`26`	`using (log.IndentLog("Calculating base versions"))`
`26`	`27`	`{`
`27`	`28`	`var baseVersions = strategies`
`28`		`- .SelectMany(s => s.GetVersions(context))`
	`29`	`+ .SelectMany(s => s.GetVersions())`
`29`	`30`	`.Where(v =>`
`30`	`31`	`{`
`31`	`32`	`if (v == null) return false;`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ public ConfigNextVersionVersionStrategy(IGitVersionContextFactory gitVersionCont`
`13`	`13`	`{`
`14`	`14`	`}`
`15`	`15`
`16`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`16`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`17`	`17`	`{`
	`18`	`+ var context = ContextFactory.Context;`
`18`	`19`	`if (string.IsNullOrEmpty(context.Configuration.NextVersion) \|\| context.IsCurrentCommitTagged)`
`19`	`20`	`yield break;`
`20`	`21`	`var semanticVersion = SemanticVersion.Parse(context.Configuration.NextVersion, context.Configuration.GitTagPrefix);`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,9 @@ public class FallbackVersionStrategy : VersionStrategyBase`
`14`	`14`	`public FallbackVersionStrategy(IGitVersionContextFactory gitVersionContextFactory) : base(gitVersionContextFactory)`
`15`	`15`	`{`
`16`	`16`	`}`
`17`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`17`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`18`	`18`	`{`
	`19`	`+ var context = ContextFactory.Context;`
`19`	`20`	`Commit baseVersionSource;`
`20`	`21`	`var currentBranchTip = context.CurrentBranch.Tip;`
`21`	`22`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,9 @@ public MergeMessageVersionStrategy(ILog log, IGitVersionContextFactory gitVersio`
`23`	`23`	`this.log = log ?? throw new ArgumentNullException(nameof(log));`
`24`	`24`	`}`
`25`	`25`
`26`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`26`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`27`	`27`	`{`
	`28`	`+ var context = ContextFactory.Context;`
`28`	`29`	`var commitsPriorToThan = context.CurrentBranch`
`29`	`30`	`.CommitsPriorToThan(context.CurrentCommit.When());`
`30`	`31`	`var baseVersions = commitsPriorToThan`
Original file line number	Diff line number	Diff line change
`@@ -21,13 +21,15 @@ public TaggedCommitVersionStrategy(IGitRepoMetadataProvider gitRepoMetadataProvi`
`21`	`21`	`this.gitRepoMetadataProvider = gitRepoMetadataProvider ?? throw new ArgumentNullException(nameof(gitRepoMetadataProvider));`
`22`	`22`	`}`
`23`	`23`
`24`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`24`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`25`	`25`	`{`
`26`		`- return GetTaggedVersions(context, context.CurrentBranch, context.CurrentCommit.When());`
	`26`	`+ var context = ContextFactory.Context;`
	`27`	`+ return GetTaggedVersions(context.CurrentBranch, context.CurrentCommit.When());`
`27`	`28`	`}`
`28`	`29`
`29`		`- public IEnumerable<BaseVersion> GetTaggedVersions(GitVersionContext context, Branch currentBranch, DateTimeOffset? olderThan)`
	`30`	`+ internal IEnumerable<BaseVersion> GetTaggedVersions(Branch currentBranch, DateTimeOffset? olderThan)`
`30`	`31`	`{`
	`32`	`+ var context = ContextFactory.Context;`
`31`	`33`	`var allTags = gitRepoMetadataProvider.GetValidVersionTags(context.Configuration.GitTagPrefix, olderThan);`
`32`	`34`
`33`	`35`	`var tagsOnBranch = currentBranch`
Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,9 @@ public TrackReleaseBranchesVersionStrategy(IGitRepoMetadataProvider gitRepoMetad`
`38`	`38`	`taggedCommitVersionStrategy = new TaggedCommitVersionStrategy(gitRepoMetadataProvider, gitVersionContextFactory);`
`39`	`39`	`}`
`40`	`40`
`41`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`41`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`42`	`42`	`{`
	`43`	`+ var context = ContextFactory.Context;`
`43`	`44`	`if (context.Configuration.TracksReleaseBranches)`
`44`	`45`	`{`
`45`	`46`	`return ReleaseBranchBaseVersions(context).Union(MasterTagsVersions(context));`
`@@ -53,7 +54,7 @@ private IEnumerable<BaseVersion> MasterTagsVersions(GitVersionContext context)`
`53`	`54`	`var master = context.Repository.FindBranch("master");`
`54`	`55`	`if (master != null)`
`55`	`56`	`{`
`56`		`- return taggedCommitVersionStrategy.GetTaggedVersions(context, master, null);`
	`57`	`+ return taggedCommitVersionStrategy.GetTaggedVersions(master, null);`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`return new BaseVersion[0];`
`@@ -100,7 +101,7 @@ private IEnumerable<BaseVersion> GetReleaseVersion(GitVersionContext context, Br`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`return releaseVersionStrategy`
`103`		`- .GetVersions(context, tagPrefixRegex, releaseBranch)`
	`104`	`+ .GetVersions(tagPrefixRegex, releaseBranch)`
`104`	`105`	`.Select(b => new BaseVersion(b.Source, true, b.SemanticVersion, baseSource, b.BranchNameOverride));`
`105`	`106`	`}`
`106`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,15 +21,17 @@ public VersionInBranchNameVersionStrategy(IGitRepoMetadataProvider gitRepoMetada`
`21`	`21`	`this.gitRepoMetadataProvider = gitRepoMetadataProvider ?? throw new ArgumentNullException(nameof(gitRepoMetadataProvider));`
`22`	`22`	`}`
`23`	`23`
`24`		`- public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)`
	`24`	`+ public override IEnumerable<BaseVersion> GetVersions()`
`25`	`25`	`{`
	`26`	`+ var context = ContextFactory.Context;`
`26`	`27`	`var currentBranch = context.CurrentBranch;`
`27`	`28`	`var tagPrefixRegex = context.Configuration.GitTagPrefix;`
`28`		`- return GetVersions(context, tagPrefixRegex, currentBranch);`
	`29`	`+ return GetVersions(tagPrefixRegex, currentBranch);`
`29`	`30`	`}`
`30`	`31`
`31`		`- public IEnumerable<BaseVersion> GetVersions(GitVersionContext context, string tagPrefixRegex, Branch currentBranch)`
	`32`	`+ internal IEnumerable<BaseVersion> GetVersions(string tagPrefixRegex, Branch currentBranch)`
`32`	`33`	`{`
	`34`	`+ var context = ContextFactory.Context;`
`33`	`35`	`if (!context.FullConfiguration.IsReleaseBranch(currentBranch.NameWithoutOrigin()))`
`34`	`36`	`{`
`35`	`37`	`yield break;`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,11 @@ public class VersionStrategyBase : IVersionStrategy`
`9`	`9`
`10`	`10`	`public VersionStrategyBase(IGitVersionContextFactory gitVersionContextFactory)`
`11`	`11`	`{`
`12`		`- this.ContextFactory = gitVersionContextFactory ?? throw new ArgumentNullException(nameof(gitVersionContextFactory));`
	`12`	`+ ContextFactory = gitVersionContextFactory ?? throw new ArgumentNullException(nameof(gitVersionContextFactory));`
	`13`	`+ }`
	`14`	`+ public virtual IEnumerable<BaseVersion> GetVersions()`
	`15`	`+ {`
	`16`	`+ throw new NotImplementedException();`
`13`	`17`	`}`
`14`		`- public virtual IEnumerable<BaseVersion> GetVersions(GitVersionContext context) => throw new NotImplementedException();`
`15`	`18`	`}`
`16`	`19`	`}`