#3341 - make sure to forward correctly the SemverVersionFormat

arturcic · arturcic · commit 4eed0c695b1e · 2023-02-18T06:27:04.000+01:00
diff --git a/src/GitVersion.Core/Configuration/Init/SetNextVersion.cs b/src/GitVersion.Core/Configuration/Init/SetNextVersion.cs
@@ -19,7 +19,7 @@ protected override StepResult HandleResult(string? result, Queue<ConfigInitWizar
             return StepResult.Ok();
         }
 
-        if (!SemanticVersion.TryParse(result, string.Empty, out var semVer))
+        if (!SemanticVersion.TryParse(result, string.Empty, out var semVer, configuration.SemanticVersionFormat))
             return StepResult.InvalidResponseSelected();
 
         configuration.NextVersion = semVer.ToString("t");
diff --git a/src/GitVersion.Core/Core/Abstractions/IRepositoryStore.cs b/src/GitVersion.Core/Core/Abstractions/IRepositoryStore.cs
@@ -38,10 +38,10 @@ public interface IRepositoryStore
 
     IEnumerable<IBranch> GetSourceBranches(IBranch branch, GitVersionConfiguration configuration, IEnumerable<IBranch> excludedBranches);
 
-    SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, bool handleDetachedBranch);
+    SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, SemanticVersionFormat versionFormat, bool handleDetachedBranch);
 
-    IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex);
-    IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, DateTimeOffset? olderThan = null);
+    IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex, SemanticVersionFormat versionFormat);
+    IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, SemanticVersionFormat versionFormat, DateTimeOffset? olderThan = null);
 
     bool IsCommitOnBranch(ICommit? baseVersionSource, IBranch branch, ICommit firstMatchingCommit);
 
diff --git a/src/GitVersion.Core/Core/GitVersionContextFactory.cs b/src/GitVersion.Core/Core/GitVersionContextFactory.cs
@@ -33,7 +33,7 @@ public GitVersionContext Create(GitVersionOptions gitVersionOptions)
             currentBranch = branchForCommit ?? currentBranch;
         }
 
-        var currentCommitTaggedVersion = this.repositoryStore.GetCurrentCommitTaggedVersion(currentCommit, configuration.LabelPrefix, handleDetachedBranch: currentBranch.IsDetachedHead);
+        var currentCommitTaggedVersion = this.repositoryStore.GetCurrentCommitTaggedVersion(currentCommit, configuration.LabelPrefix, configuration.SemanticVersionFormat, handleDetachedBranch: currentBranch.IsDetachedHead);
         var numberOfUncommittedChanges = this.repositoryStore.GetNumberOfUncommittedChanges();
 
         return new GitVersionContext(currentBranch, currentCommit, configuration, currentCommitTaggedVersion, numberOfUncommittedChanges);
diff --git a/src/GitVersion.Core/Core/RepositoryStore.cs b/src/GitVersion.Core/Core/RepositoryStore.cs
@@ -219,24 +219,24 @@ public IEnumerable<BranchCommit> FindCommitBranchesWasBranchedFrom(IBranch branc
         }
     }
 
-    public SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, bool handleDetachedBranch)
+    public SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, SemanticVersionFormat versionFormat, bool handleDetachedBranch)
         => this.repository.Tags
-            .SelectMany(t => GetCurrentCommitSemanticVersions(commit, tagPrefix, t, handleDetachedBranch))
+            .SelectMany(tag => GetCurrentCommitSemanticVersions(commit, tagPrefix, tag, versionFormat, handleDetachedBranch))
             .Max();
 
-    public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex)
+    public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex, SemanticVersionFormat versionFormat)
     {
         branch = branch.NotNull();
 
-        if (this.semanticVersionTagsOnBranchCache.ContainsKey(branch))
+        if (this.semanticVersionTagsOnBranchCache.TryGetValue(branch, out var onBranch))
         {
             this.log.Debug($"Cache hit for version tags on branch '{branch.Name.Canonical}");
-            return this.semanticVersionTagsOnBranchCache[branch];
+            return onBranch;
         }
 
         using (this.log.IndentLog($"Getting version tags from branch '{branch.Name.Canonical}'."))
         {
-            var tags = GetValidVersionTags(tagPrefixRegex);
+            var tags = GetValidVersionTags(tagPrefixRegex, versionFormat);
             var tagsBySha = tags.Where(t => t.Tag.TargetSha != null).ToLookup(t => t.Tag.TargetSha, t => t);
 
             var versionTags = (branch.Commits?.SelectMany(c => tagsBySha[c.Sha].Select(t => t.Semver)) ?? Enumerable.Empty<SemanticVersion>()).ToList();
@@ -246,13 +246,13 @@ public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, strin
         }
     }
 
-    public IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, DateTimeOffset? olderThan = null)
+    public IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, SemanticVersionFormat versionFormat, DateTimeOffset? olderThan = null)
     {
         var tags = new List<(ITag, SemanticVersion, ICommit)>();
 
         foreach (var tag in this.repository.Tags)
         {
-            if (!SemanticVersion.TryParse(tag.Name.Friendly, tagPrefixRegex, out var semver))
+            if (!SemanticVersion.TryParse(tag.Name.Friendly, tagPrefixRegex, out var semver, versionFormat))
                 continue;
 
             var commit = tag.PeeledTargetCommit();
@@ -290,7 +290,7 @@ public bool IsCommitOnBranch(ICommit? baseVersionSource, IBranch branch, ICommit
     private static bool IsReleaseBranch(INamedReference branch, IEnumerable<KeyValuePair<string, BranchConfiguration>> releaseBranchConfig)
         => releaseBranchConfig.Any(c => c.Value?.Regex != null && Regex.IsMatch(branch.Name.Friendly, c.Value.Regex));
 
-    private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? commit, string? tagPrefix, ITag tag, bool handleDetachedBranch)
+    private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? commit, string? tagPrefix, ITag tag, SemanticVersionFormat versionFormat, bool handleDetachedBranch)
     {
         if (commit == null)
             return Array.Empty<SemanticVersion>();
@@ -303,7 +303,7 @@ private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? c
 
         var tagName = tag.Name.Friendly;
 
-        return Equals(targetCommit, commitToCompare) && SemanticVersion.TryParse(tagName, tagPrefix, out var version)
+        return Equals(targetCommit, commitToCompare) && SemanticVersion.TryParse(tagName, tagPrefix, out var version, versionFormat)
             ? new[] { version }
             : Array.Empty<SemanticVersion>();
     }
diff --git a/src/GitVersion.Core/MergeMessage.cs b/src/GitVersion.Core/MergeMessage.cs
@@ -29,25 +29,25 @@ public MergeMessage(string? mergeMessage, GitVersionConfiguration configuration)
         foreach (var format in allFormats)
         {
             var match = format.Pattern.Match(mergeMessage);
-            if (match.Success)
-            {
-                FormatName = format.Name;
-                MergedBranch = match.Groups["SourceBranch"].Value;
-
-                if (match.Groups["TargetBranch"].Success)
-                {
-                    TargetBranch = match.Groups["TargetBranch"].Value;
-                }
+            if (!match.Success)
+                continue;
 
-                if (int.TryParse(match.Groups["PullRequestNumber"].Value, out var pullNumber))
-                {
-                    PullRequestNumber = pullNumber;
-                }
+            FormatName = format.Name;
+            MergedBranch = match.Groups["SourceBranch"].Value;
 
-                Version = ParseVersion(configuration.LabelPrefix);
+            if (match.Groups["TargetBranch"].Success)
+            {
+                TargetBranch = match.Groups["TargetBranch"].Value;
+            }
 
-                break;
+            if (int.TryParse(match.Groups["PullRequestNumber"].Value, out var pullNumber))
+            {
+                PullRequestNumber = pullNumber;
             }
+
+            Version = ParseVersion(configuration.LabelPrefix, configuration.SemanticVersionFormat);
+
+            break;
         }
     }
 
@@ -58,7 +58,7 @@ public MergeMessage(string? mergeMessage, GitVersionConfiguration configuration)
     public int? PullRequestNumber { get; }
     public SemanticVersion? Version { get; }
 
-    private SemanticVersion? ParseVersion(string? tagPrefix)
+    private SemanticVersion? ParseVersion(string? tagPrefix, SemanticVersionFormat versionFormat)
     {
         if (tagPrefix is null)
             return null;
@@ -69,7 +69,7 @@ public MergeMessage(string? mergeMessage, GitVersionConfiguration configuration)
         var versionMatch = new Regex(@"^(?<!://)\d+\.\d+(\.*\d+)*");
         var version = versionMatch.Match(toMatch);
 
-        if (version.Success && SemanticVersion.TryParse(version.Value, tagPrefix, out var val))
+        if (version.Success && SemanticVersion.TryParse(version.Value, tagPrefix, out var val, versionFormat))
         {
             return val;
         }
diff --git a/src/GitVersion.Core/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs b/src/GitVersion.Core/VersionCalculation/BaseVersionCalculators/TaggedCommitVersionStrategy.cs
@@ -23,14 +23,14 @@ internal IEnumerable<BaseVersion> GetTaggedVersions(IBranch currentBranch, DateT
     {
         if (currentBranch is null)
             return Enumerable.Empty<BaseVersion>();
-        var versionTags = this.repositoryStore.GetValidVersionTags(Context.Configuration.LabelPrefix, olderThan);
-        var versionTagsByCommit = versionTags.ToLookup(vt => vt.Item3.Id.Sha);
+        var versionTags = this.repositoryStore.GetValidVersionTags(Context.Configuration.LabelPrefix, Context.Configuration.SemanticVersionFormat, olderThan);
+        var versionTagsByCommit = versionTags.ToLookup(vt => vt.Commit.Id.Sha);
         var commitsOnBranch = currentBranch.Commits;
         if (commitsOnBranch == null)
             return Enumerable.Empty<BaseVersion>();
 
         var versionTagsOnBranch = commitsOnBranch.SelectMany(commit => versionTagsByCommit[commit.Id.Sha]);
-        var versionTaggedCommits = versionTagsOnBranch.Select(t => new VersionTaggedCommit(t.Item3, t.Item2, t.Item1.Name.Friendly));
+        var versionTaggedCommits = versionTagsOnBranch.Select(t => new VersionTaggedCommit(t.Commit, t.Semver, t.Tag.Name.Friendly));
         var taggedVersions = versionTaggedCommits.Select(versionTaggedCommit => CreateBaseVersion(Context, versionTaggedCommit)).ToList();
         var taggedVersionsOnCurrentCommit = taggedVersions.Where(version => !version.ShouldIncrement).ToList();
         return taggedVersionsOnCurrentCommit.Any() ? taggedVersionsOnCurrentCommit : taggedVersions;
diff --git a/src/GitVersion.Core/VersionCalculation/BaseVersionCalculators/VersionInBranchNameVersionStrategy.cs b/src/GitVersion.Core/VersionCalculation/BaseVersionCalculators/VersionInBranchNameVersionStrategy.cs
@@ -19,24 +19,25 @@ public VersionInBranchNameVersionStrategy(IRepositoryStore repositoryStore, Lazy
     public override IEnumerable<BaseVersion> GetBaseVersions(EffectiveBranchConfiguration configuration)
     {
         string nameWithoutOrigin = NameWithoutOrigin(configuration.Branch);
-        if (Context.Configuration.IsReleaseBranch(nameWithoutOrigin))
+        var contextConfiguration = Context.Configuration;
+        if (contextConfiguration.IsReleaseBranch(nameWithoutOrigin))
         {
-            var versionInBranch = GetVersionInBranch(configuration.Branch.Name.Friendly, Context.Configuration.LabelPrefix);
+            var versionInBranch = GetVersionInBranch(configuration.Branch.Name.Friendly, contextConfiguration.LabelPrefix, contextConfiguration.SemanticVersionFormat);
             if (versionInBranch != null)
             {
-                var commitBranchWasBranchedFrom = this.repositoryStore.FindCommitBranchWasBranchedFrom(configuration.Branch, Context.Configuration);
+                var commitBranchWasBranchedFrom = this.repositoryStore.FindCommitBranchWasBranchedFrom(configuration.Branch, contextConfiguration);
                 var branchNameOverride = Context.CurrentBranch.Name.Friendly.RegexReplace("[-/]" + versionInBranch.Item1, string.Empty);
                 yield return new BaseVersion("Version in branch name", false, versionInBranch.Item2, commitBranchWasBranchedFrom.Commit, branchNameOverride);
             }
         }
     }
 
-    private static Tuple<string, SemanticVersion>? GetVersionInBranch(string branchName, string? tagPrefixRegex)
+    private static Tuple<string, SemanticVersion>? GetVersionInBranch(string branchName, string? tagPrefixRegex, SemanticVersionFormat versionFormat)
     {
         var branchParts = branchName.Split('/', '-');
         foreach (var part in branchParts)
         {
-            if (SemanticVersion.TryParse(part, tagPrefixRegex, out var semanticVersion))
+            if (SemanticVersion.TryParse(part, tagPrefixRegex, out var semanticVersion, versionFormat))
             {
                 return Tuple.Create(part, semanticVersion);
             }
diff --git a/src/GitVersion.Core/VersionCalculation/NextVersionCalculator.cs b/src/GitVersion.Core/VersionCalculation/NextVersionCalculator.cs
@@ -130,7 +130,7 @@ private void UpdatePreReleaseTag(EffectiveBranchConfiguration configuration, Sem
 
         // TODO: Please update the pre release-tag in the IVersionStrategy implementation.
         var lastTag = this.repositoryStore
-            .GetVersionTagsOnBranch(Context.CurrentBranch, Context.Configuration.LabelPrefix)
+            .GetVersionTagsOnBranch(Context.CurrentBranch, Context.Configuration.LabelPrefix, Context.Configuration.SemanticVersionFormat)
             .FirstOrDefault(v => v.PreReleaseTag?.Name?.IsEquivalentTo(tagToUse) == true);
 
         if (lastTag != null && MajorMinorPatchEqual(lastTag, semanticVersion) && lastTag.HasPreReleaseTagWithLabel)
diff --git a/src/GitVersion.Core/VersionCalculation/SemanticVersioning/SemanticVersion.cs b/src/GitVersion.Core/VersionCalculation/SemanticVersioning/SemanticVersion.cs
@@ -133,9 +133,9 @@ public override int GetHashCode()
         return v1.CompareTo(v2) < 0;
     }
 
-    public static SemanticVersion Parse(string version, string? tagPrefixRegex, SemanticVersionFormat format = SemanticVersionFormat.Strict)
+    public static SemanticVersion Parse(string version, string? tagPrefixRegex, SemanticVersionFormat versionFormat = SemanticVersionFormat.Strict)
     {
-        if (!TryParse(version, tagPrefixRegex, out var semanticVersion, format))
+        if (!TryParse(version, tagPrefixRegex, out var semanticVersion, versionFormat))
             throw new WarningException($"Failed to parse {version} into a Semantic Version");
 
         return semanticVersion;

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ protected override StepResult HandleResult(string? result, Queue<ConfigInitWizar`
`19`	`19`	`return StepResult.Ok();`
`20`	`20`	`}`
`21`	`21`
`22`		`- if (!SemanticVersion.TryParse(result, string.Empty, out var semVer))`
	`22`	`+ if (!SemanticVersion.TryParse(result, string.Empty, out var semVer, configuration.SemanticVersionFormat))`
`23`	`23`	`return StepResult.InvalidResponseSelected();`
`24`	`24`
`25`	`25`	`configuration.NextVersion = semVer.ToString("t");`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public GitVersionContext Create(GitVersionOptions gitVersionOptions)`
`33`	`33`	`currentBranch = branchForCommit ?? currentBranch;`
`34`	`34`	`}`
`35`	`35`
`36`		`- var currentCommitTaggedVersion = this.repositoryStore.GetCurrentCommitTaggedVersion(currentCommit, configuration.LabelPrefix, handleDetachedBranch: currentBranch.IsDetachedHead);`
	`36`	`+ var currentCommitTaggedVersion = this.repositoryStore.GetCurrentCommitTaggedVersion(currentCommit, configuration.LabelPrefix, configuration.SemanticVersionFormat, handleDetachedBranch: currentBranch.IsDetachedHead);`
`37`	`37`	`var numberOfUncommittedChanges = this.repositoryStore.GetNumberOfUncommittedChanges();`
`38`	`38`
`39`	`39`	`return new GitVersionContext(currentBranch, currentCommit, configuration, currentCommitTaggedVersion, numberOfUncommittedChanges);`
Original file line number	Diff line number	Diff line change
`@@ -219,24 +219,24 @@ public IEnumerable<BranchCommit> FindCommitBranchesWasBranchedFrom(IBranch branc`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`222`		`- public SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, bool handleDetachedBranch)`
	`222`	`+ public SemanticVersion? GetCurrentCommitTaggedVersion(ICommit? commit, string? tagPrefix, SemanticVersionFormat versionFormat, bool handleDetachedBranch)`
`223`	`223`	`=> this.repository.Tags`
`224`		`- .SelectMany(t => GetCurrentCommitSemanticVersions(commit, tagPrefix, t, handleDetachedBranch))`
	`224`	`+ .SelectMany(tag => GetCurrentCommitSemanticVersions(commit, tagPrefix, tag, versionFormat, handleDetachedBranch))`
`225`	`225`	`.Max();`
`226`	`226`
`227`		`- public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex)`
	`227`	`+ public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, string? tagPrefixRegex, SemanticVersionFormat versionFormat)`
`228`	`228`	`{`
`229`	`229`	`branch = branch.NotNull();`
`230`	`230`
`231`		`- if (this.semanticVersionTagsOnBranchCache.ContainsKey(branch))`
	`231`	`+ if (this.semanticVersionTagsOnBranchCache.TryGetValue(branch, out var onBranch))`
`232`	`232`	`{`
`233`	`233`	`this.log.Debug($"Cache hit for version tags on branch '{branch.Name.Canonical}");`
`234`		`- return this.semanticVersionTagsOnBranchCache[branch];`
	`234`	`+ return onBranch;`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`using (this.log.IndentLog($"Getting version tags from branch '{branch.Name.Canonical}'."))`
`238`	`238`	`{`
`239`		`- var tags = GetValidVersionTags(tagPrefixRegex);`
	`239`	`+ var tags = GetValidVersionTags(tagPrefixRegex, versionFormat);`
`240`	`240`	`var tagsBySha = tags.Where(t => t.Tag.TargetSha != null).ToLookup(t => t.Tag.TargetSha, t => t);`
`241`	`241`
`242`	`242`	`var versionTags = (branch.Commits?.SelectMany(c => tagsBySha[c.Sha].Select(t => t.Semver)) ?? Enumerable.Empty<SemanticVersion>()).ToList();`
`@@ -246,13 +246,13 @@ public IEnumerable<SemanticVersion> GetVersionTagsOnBranch(IBranch branch, strin`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`
`249`		`- public IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, DateTimeOffset? olderThan = null)`
	`249`	`+ public IEnumerable<(ITag Tag, SemanticVersion Semver, ICommit Commit)> GetValidVersionTags(string? tagPrefixRegex, SemanticVersionFormat versionFormat, DateTimeOffset? olderThan = null)`
`250`	`250`	`{`
`251`	`251`	`var tags = new List<(ITag, SemanticVersion, ICommit)>();`
`252`	`252`
`253`	`253`	`foreach (var tag in this.repository.Tags)`
`254`	`254`	`{`
`255`		`- if (!SemanticVersion.TryParse(tag.Name.Friendly, tagPrefixRegex, out var semver))`
	`255`	`+ if (!SemanticVersion.TryParse(tag.Name.Friendly, tagPrefixRegex, out var semver, versionFormat))`
`256`	`256`	`continue;`
`257`	`257`
`258`	`258`	`var commit = tag.PeeledTargetCommit();`
`@@ -290,7 +290,7 @@ public bool IsCommitOnBranch(ICommit? baseVersionSource, IBranch branch, ICommit`
`290`	`290`	`private static bool IsReleaseBranch(INamedReference branch, IEnumerable<KeyValuePair<string, BranchConfiguration>> releaseBranchConfig)`
`291`	`291`	`=> releaseBranchConfig.Any(c => c.Value?.Regex != null && Regex.IsMatch(branch.Name.Friendly, c.Value.Regex));`
`292`	`292`
`293`		`- private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? commit, string? tagPrefix, ITag tag, bool handleDetachedBranch)`
	`293`	`+ private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? commit, string? tagPrefix, ITag tag, SemanticVersionFormat versionFormat, bool handleDetachedBranch)`
`294`	`294`	`{`
`295`	`295`	`if (commit == null)`
`296`	`296`	`return Array.Empty<SemanticVersion>();`
`@@ -303,7 +303,7 @@ private IEnumerable<SemanticVersion> GetCurrentCommitSemanticVersions(ICommit? c`
`303`	`303`
`304`	`304`	`var tagName = tag.Name.Friendly;`
`305`	`305`
`306`		`- return Equals(targetCommit, commitToCompare) && SemanticVersion.TryParse(tagName, tagPrefix, out var version)`
	`306`	`+ return Equals(targetCommit, commitToCompare) && SemanticVersion.TryParse(tagName, tagPrefix, out var version, versionFormat)`
`307`	`307`	`? new[] { version }`
`308`	`308`	`: Array.Empty<SemanticVersion>();`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,24 +19,25 @@ public VersionInBranchNameVersionStrategy(IRepositoryStore repositoryStore, Lazy`
`19`	`19`	`public override IEnumerable<BaseVersion> GetBaseVersions(EffectiveBranchConfiguration configuration)`
`20`	`20`	`{`
`21`	`21`	`string nameWithoutOrigin = NameWithoutOrigin(configuration.Branch);`
`22`		`- if (Context.Configuration.IsReleaseBranch(nameWithoutOrigin))`
	`22`	`+ var contextConfiguration = Context.Configuration;`
	`23`	`+ if (contextConfiguration.IsReleaseBranch(nameWithoutOrigin))`
`23`	`24`	`{`
`24`		`- var versionInBranch = GetVersionInBranch(configuration.Branch.Name.Friendly, Context.Configuration.LabelPrefix);`
	`25`	`+ var versionInBranch = GetVersionInBranch(configuration.Branch.Name.Friendly, contextConfiguration.LabelPrefix, contextConfiguration.SemanticVersionFormat);`
`25`	`26`	`if (versionInBranch != null)`
`26`	`27`	`{`
`27`		`- var commitBranchWasBranchedFrom = this.repositoryStore.FindCommitBranchWasBranchedFrom(configuration.Branch, Context.Configuration);`
	`28`	`+ var commitBranchWasBranchedFrom = this.repositoryStore.FindCommitBranchWasBranchedFrom(configuration.Branch, contextConfiguration);`
`28`	`29`	`var branchNameOverride = Context.CurrentBranch.Name.Friendly.RegexReplace("[-/]" + versionInBranch.Item1, string.Empty);`
`29`	`30`	`yield return new BaseVersion("Version in branch name", false, versionInBranch.Item2, commitBranchWasBranchedFrom.Commit, branchNameOverride);`
`30`	`31`	`}`
`31`	`32`	`}`
`32`	`33`	`}`
`33`	`34`
`34`		`- private static Tuple<string, SemanticVersion>? GetVersionInBranch(string branchName, string? tagPrefixRegex)`
	`35`	`+ private static Tuple<string, SemanticVersion>? GetVersionInBranch(string branchName, string? tagPrefixRegex, SemanticVersionFormat versionFormat)`
`35`	`36`	`{`
`36`	`37`	`var branchParts = branchName.Split('/', '-');`
`37`	`38`	`foreach (var part in branchParts)`
`38`	`39`	`{`
`39`		`- if (SemanticVersion.TryParse(part, tagPrefixRegex, out var semanticVersion))`
	`40`	`+ if (SemanticVersion.TryParse(part, tagPrefixRegex, out var semanticVersion, versionFormat))`
`40`	`41`	`{`
`41`	`42`	`return Tuple.Create(part, semanticVersion);`
`42`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,9 +133,9 @@ public override int GetHashCode()`
`133`	`133`	`return v1.CompareTo(v2) < 0;`
`134`	`134`	`}`
`135`	`135`
`136`		`- public static SemanticVersion Parse(string version, string? tagPrefixRegex, SemanticVersionFormat format = SemanticVersionFormat.Strict)`
	`136`	`+ public static SemanticVersion Parse(string version, string? tagPrefixRegex, SemanticVersionFormat versionFormat = SemanticVersionFormat.Strict)`
`137`	`137`	`{`
`138`		`- if (!TryParse(version, tagPrefixRegex, out var semanticVersion, format))`
	`138`	`+ if (!TryParse(version, tagPrefixRegex, out var semanticVersion, versionFormat))`
`139`	`139`	`throw new WarningException($"Failed to parse {version} into a Semantic Version");`
`140`	`140`
`141`	`141`	`return semanticVersion;`