private static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return(null);
}
var commitMessage = mergeCommit.Message;
var lastIndexOf = commitMessage.LastIndexOf("into", StringComparison.OrdinalIgnoreCase);
if (lastIndexOf != -1)
{
commitMessage = commitMessage.Substring(0, lastIndexOf);
}
//TODO: Make the version prefixes customizable
var possibleVersions = Regex.Matches(commitMessage, @"^.*?(([rR]elease|[hH]otfix|[aA]lpha)-|-v|/|/v|'|Finish )(?<PossibleVersions>(?<!://)\d+\.\d+(\.*\d+)*)")
.Cast <Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return(possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null));
}
public GitVersionContext Create(GitVersionOptions gitVersionOptions)
{
var currentBranch = this.repositoryStore.GetTargetBranch(gitVersionOptions.RepositoryInfo.TargetBranch);
if (currentBranch == null)
{
throw new InvalidOperationException("Need a branch to operate on");
}
var currentCommit = this.repositoryStore.GetCurrentCommit(currentBranch, gitVersionOptions.RepositoryInfo.CommitId);
var configuration = this.configProvider.Provide(this.options.Value.ConfigInfo.OverrideConfig);
if (currentBranch.IsDetachedHead)
{
var branchForCommit = this.repositoryStore.GetBranchesContainingCommit(currentCommit, onlyTrackedBranches: gitVersionOptions.Settings.OnlyTrackedBranches).OnlyOrDefault();
currentBranch = branchForCommit ?? currentBranch;
}
var currentBranchConfig = this.branchConfigurationCalculator.GetBranchConfiguration(currentBranch, currentCommit, configuration);
var effectiveConfiguration = new EffectiveConfiguration(configuration, currentBranchConfig);
var currentCommitTaggedVersion = this.repositoryStore.GetCurrentCommitTaggedVersion(currentCommit, effectiveConfiguration);
var numberOfUncommittedChanges = this.repositoryStore.GetNumberOfUncommittedChanges();
return(new GitVersionContext(currentBranch, currentCommit, configuration, effectiveConfiguration, currentCommitTaggedVersion, numberOfUncommittedChanges));
}
/// <summary>
/// Format semantic version according to current configuration
/// </summary>
/// <param name="version">Semantic version</param>
/// <param name="config">Current configuration</param>
/// <param name="isCurrentCommitTagged">Defines if current commit is tagged</param>
public static SemanticVersion FormatVersion(this SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged = false)
{
return(version
.EnsurePreReleaseTag(config, isCurrentCommitTagged)
.AppendTagNumberPattern(config)
.PromoteNumberOfCommitsToTagNumber(config, isCurrentCommitTagged));
}
private static string EnsurePreReleaseTagName(SemanticVersion version, EffectiveConfiguration config)
{
var name = PreReleaseTagCalculator.GetBranchSpecificTag(config, version.BuildMetadata.Branch, null);
if (!string.IsNullOrEmpty(name))
{
return(name);
}
return(config.ContinuousDeploymentFallbackTag);
}
public static void OverrideVersionManuallyIfNeeded(this SemanticVersion version, EffectiveConfiguration configuration)
{
if (!configuration.NextVersion.IsNullOrEmpty() && SemanticVersion.TryParse(configuration.NextVersion, configuration.GitTagPrefix, out var manualNextVersion))
{
if (manualNextVersion > version)
{
version.Major = manualNextVersion.Major;
version.Minor = manualNextVersion.Minor;
version.Patch = manualNextVersion.Patch;
}
}
}
public GitVersionContext(IBranch currentBranch, ICommit?currentCommit,
Config configuration, EffectiveConfiguration effectiveConfiguration,
SemanticVersion currentCommitTaggedVersion, int numberOfUncommittedChanges)
{
CurrentBranch = currentBranch;
CurrentCommit = currentCommit;
FullConfiguration = configuration;
Configuration = effectiveConfiguration;
CurrentCommitTaggedVersion = currentCommitTaggedVersion;
NumberOfUncommittedChanges = numberOfUncommittedChanges;
}
private static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return(null);
}
var possibleVersions = Regex.Matches(mergeCommit.Message, @"^.*?(-|/|'|Finish )(?<PossibleVersions>\d+\.\d+\.\d+)")
.Cast <Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return(possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null));
}
private static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return null;
}
var possibleVersions = Regex.Matches(mergeCommit.Message, @"^.*?(-|/|'|Finish )(?<PossibleVersions>\d+\.\d+\.\d+)")
.Cast<Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null);
}
private static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return null;
}
//TODO: Make the version prefixes customizable
var possibleVersions = Regex.Matches(mergeCommit.Message, @"^.*?(([rR]elease|[hH]otfix|[aA]lpha)-|-v|/|/v|'|Finish )(?<PossibleVersions>(?<!://)\d+\.\d+(\.*\d+)*)")
.Cast<Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null);
}
private static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return(null);
}
//TODO: Make the version prefixes customizable
var possibleVersions = Regex.Matches(mergeCommit.Message, @"^.*?(([rR]elease|[hH]otfix|[aA]lpha)-|-v|/|/v|'|Finish )(?<PossibleVersions>\d+\.\d+(\.*\d+)*)")
.Cast <Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return(possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null));
}
void CreateTempAssemblyInfo(CachedVersion semanticVersion, EffectiveConfiguration configuration)
{
if (IntermediateOutputPath == null)
{
var tempFileName = string.Format("AssemblyInfo_{0}_{1}.g.cs", Path.GetFileNameWithoutExtension(ProjectFile), Path.GetRandomFileName());
AssemblyInfoTempFilePath = Path.Combine(TempFileTracker.TempPath, tempFileName);
}
else
{
AssemblyInfoTempFilePath = Path.Combine(IntermediateOutputPath, "GitVersionTaskAssemblyInfo.g.cs");
}
var assemblyInfoBuilder = new AssemblyInfoBuilder
{
CachedVersion = semanticVersion
};
var assemblyInfo = assemblyInfoBuilder.GetAssemblyInfoText(configuration);
File.WriteAllText(AssemblyInfoTempFilePath, assemblyInfo);
}
public static string GetBranchSpecificTag(EffectiveConfiguration configuration, string branchFriendlyName, string branchNameOverride)
{
var tagToUse = configuration.Tag;
if (tagToUse == "useBranchName")
{
tagToUse = "{BranchName}";
}
if (tagToUse.Contains("{BranchName}"))
{
var branchName = branchNameOverride ?? branchFriendlyName;
if (!string.IsNullOrWhiteSpace(configuration.BranchPrefixToTrim))
{
branchName = Regex.Replace(branchName, configuration.BranchPrefixToTrim, string.Empty, RegexOptions.IgnoreCase);
}
branchName = Regex.Replace(branchName, "[^a-zA-Z0-9-]", "-");
tagToUse = tagToUse.Replace("{BranchName}", branchName);
}
return(tagToUse);
}
public string GetAssemblyInfoText(EffectiveConfiguration configuration)
{
var semanticVersion = CachedVersion.SemanticVersion;
var vars = VariableProvider.GetVariablesFor(semanticVersion, configuration.AssemblyVersioningScheme, configuration.VersioningMode, "ci", false);
var assemblyInfo = string.Format(@"
using System;
using System.Reflection;
[assembly: AssemblyVersion(""{0}"")]
[assembly: AssemblyFileVersion(""{1}"")]
[assembly: AssemblyInformationalVersion(""{2}"")]
[assembly: ReleaseDate(""{3}"")]
[System.Runtime.CompilerServices.CompilerGenerated]
sealed class ReleaseDateAttribute : System.Attribute
{{
public string Date {{ get; private set; }}
public ReleaseDateAttribute(string date)
{{
Date = date;
}}
}}
[System.Runtime.CompilerServices.CompilerGenerated]
static class GitVersionInformation
{{
{4}
}}
",
vars.AssemblySemVer,
vars.MajorMinorPatch + ".0",
semanticVersion.ToString("i"),
semanticVersion.BuildMetaData.CommitDate.UtcDateTime.ToString("yyyy-MM-dd"),
GenerateVariableMembers(vars));
return(assemblyInfo);
}
public static string GetBranchSpecificTag(EffectiveConfiguration configuration, string branchFriendlyName, string branchNameOverride)
{
var tagToUse = configuration.Tag;
if (tagToUse == "useBranchName")
{
tagToUse = "{BranchName}";
}
if (tagToUse.Contains("{BranchName}"))
{
Logger.WriteInfo("Using branch name to calculate version tag");
var branchName = branchNameOverride ?? branchFriendlyName;
if (!string.IsNullOrWhiteSpace(configuration.BranchPrefixToTrim))
{
branchName = branchName.RegexReplace(configuration.BranchPrefixToTrim, string.Empty, RegexOptions.IgnoreCase);
}
branchName = branchName.RegexReplace("[^a-zA-Z0-9-]", "-");
tagToUse = tagToUse.Replace("{BranchName}", branchName);
}
return tagToUse;
}
public void CommitDateFormatTest(string format, string expectedOutcome)
{
var date = new DateTime(2017, 10, 6);
var buildMetadata = new BuildMetadata(
0, "master",
"3139d4eeb044f46057693473eacc2655b3b27e7d",
new DateTimeOffset(date, TimeSpan.Zero)); // assume time zone is UTC
var config = new EffectiveConfiguration(
AssemblyVersioningScheme.MajorMinorPatch,
AssemblyFileVersioningScheme.MajorMinorPatch,
"", VersioningMode.ContinuousDelivery, "", "", "",
IncrementStrategyType.Inherit,
"", true, "", "", false, "", "", "", "",
CommitMessageIncrementMode.Enabled, 4, 4,
Enumerable.Empty <IVersionFilter>(), false, true, format);
var version = new SemanticVersion(1, 0, 0, null, buildMetadata);
var values = new VersionFormatValues(version, config);
Assert.That(values.CommitDate, Is.EqualTo(expectedOutcome));
}
public static VersionVariables GetVariablesFor(SemanticVersion semanticVersion, EffectiveConfiguration config, bool isCurrentCommitTagged)
{
if (config.VersioningMode == VersioningMode.ContinuousDeployment && !isCurrentCommitTagged)
{
semanticVersion = new SemanticVersion(semanticVersion);
// Continuous Deployment always requires a pre-release tag unless the commit is tagged
if (!semanticVersion.PreReleaseTag.HasTag())
{
semanticVersion.PreReleaseTag.Name = config.ContinuousDeploymentFallbackTag;
}
// For continuous deployment the commits since tag gets promoted to the pre-release number
semanticVersion.PreReleaseTag.Number = semanticVersion.BuildMetaData.CommitsSinceTag;
semanticVersion.BuildMetaData.CommitsSinceTag = null;
}
var variables = new VersionVariables(
major: semanticVersion.Major.ToString(),
minor: semanticVersion.Minor.ToString(),
patch: semanticVersion.Patch.ToString(),
preReleaseTag: semanticVersion.PreReleaseTag,
preReleaseTagWithDash: semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null,
buildMetaData: semanticVersion.BuildMetaData,
buildMetaDataPadded: semanticVersion.BuildMetaData.ToString("p" + config.BuildMetaDataPadding),
fullBuildMetaData: semanticVersion.BuildMetaData.ToString("f"),
majorMinorPatch: string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch),
semVer: semanticVersion.ToString(),
legacySemVer: semanticVersion.ToString("l"),
legacySemVerPadded: semanticVersion.ToString("lp" + config.LegacySemVerPadding),
assemblySemVer: semanticVersion.GetAssemblyVersion(config.AssemblyVersioningScheme),
fullSemVer: semanticVersion.ToString("f"),
informationalVersion: semanticVersion.ToString("i"),
branchName: semanticVersion.BuildMetaData.Branch,
sha: semanticVersion.BuildMetaData.Sha,
commitDate: semanticVersion.BuildMetaData.CommitDate.UtcDateTime.ToString("yyyy-MM-dd"));
return variables;
}
public static string GetBranchSpecificTag(EffectiveConfiguration configuration, string branchFriendlyName, string branchNameOverride)
{
var tagToUse = configuration.Tag;
if (tagToUse == "useBranchName")
{
tagToUse = "{BranchName}";
}
if (tagToUse.Contains("{BranchName}"))
{
var branchName = branchNameOverride ?? branchFriendlyName;
if (!string.IsNullOrWhiteSpace(configuration.BranchPrefixToTrim))
{
branchName = Regex.Replace(branchName, configuration.BranchPrefixToTrim, string.Empty, RegexOptions.IgnoreCase);
}
//Replacing non-ASCII symbols according to SemVer2.0 specification (https://semver.org/spec/v2.0.0.html#spec-item-9)
branchName = Regex.Replace(branchName, "[^a-zA-Z0-9-]", "-");
tagToUse = tagToUse.Replace("{BranchName}", branchName);
}
return(tagToUse);
}
static SemanticVersion Inner(Commit mergeCommit, EffectiveConfiguration configuration)
{
if (mergeCommit.Parents.Count() < 2)
{
return null;
}
var commitMessage = mergeCommit.Message;
var lastIndexOf = commitMessage.LastIndexOf("into", StringComparison.OrdinalIgnoreCase);
if (lastIndexOf != -1)
commitMessage = commitMessage.Substring(0, lastIndexOf);
//TODO: Make the version prefixes customizable
var possibleVersions = Regex.Matches(commitMessage, @"^.*?(([rR]elease|[hH]otfix|[aA]lpha)-|-v|/|/v|'|Finish )(?<PossibleVersions>(?<!://)\d+\.\d+(\.*\d+)*)")
.Cast<Match>()
.Select(m => m.Groups["PossibleVersions"].Value);
return possibleVersions
.Select(part =>
{
SemanticVersion v;
return SemanticVersion.TryParse(part, configuration.GitTagPrefix, out v) ? v : null;
}).FirstOrDefault(v => v != null);
}
public static string GetBranchSpecificTag(this EffectiveConfiguration configuration, ILog log, string?branchFriendlyName, string?branchNameOverride)
{
var tagToUse = configuration.Tag ?? "{BranchName}";
if (tagToUse == "useBranchName")
{
tagToUse = "{BranchName}";
}
if (tagToUse.Contains("{BranchName}"))
{
log.Info("Using branch name to calculate version tag");
var branchName = branchNameOverride ?? branchFriendlyName;
if (!configuration.BranchPrefixToTrim.IsNullOrWhiteSpace())
{
var branchNameTrimmed = branchName?.RegexReplace(configuration.BranchPrefixToTrim, string.Empty, RegexOptions.IgnoreCase);
branchName = branchNameTrimmed.IsNullOrEmpty() ? branchName : branchNameTrimmed;
}
branchName = branchName?.RegexReplace("[^a-zA-Z0-9-]", "-");
tagToUse = tagToUse.Replace("{BranchName}", branchName);
}
return(tagToUse);
}
private static SemanticVersion EnsurePreReleaseTag(this SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged)
{
// Continuous Deployment always requires a pre-release tag unless the commit is tagged
if (config.VersioningMode != VersioningMode.ContinuousDeployment || isCurrentCommitTagged)
{
return(version);
}
if (!version.PreReleaseTag.IsNull())
{
return(version);
}
return(version.Copy(
preReleaseTag: new PreReleaseTag(
name: EnsurePreReleaseTagName(version, config),
number: version.BuildMetadata.CommitsSinceTag)));
}
public static VersionVariables GetVariablesFor(SemanticVersion semanticVersion, EffectiveConfiguration config, bool isCurrentCommitTagged)
{
if (config.VersioningMode == VersioningMode.ContinuousDeployment && !isCurrentCommitTagged)
{
semanticVersion = new SemanticVersion(semanticVersion);
// Continuous Deployment always requires a pre-release tag unless the commit is tagged
if (!semanticVersion.PreReleaseTag.HasTag())
{
semanticVersion.PreReleaseTag.Name = config.ContinuousDeploymentFallbackTag;
}
// For continuous deployment the commits since tag gets promoted to the pre-release number
semanticVersion.PreReleaseTag.Number = semanticVersion.BuildMetaData.CommitsSinceTag;
semanticVersion.BuildMetaData.CommitsSinceTag = null;
}
var variables = new VersionVariables(
major: semanticVersion.Major.ToString(),
minor: semanticVersion.Minor.ToString(),
patch: semanticVersion.Patch.ToString(),
preReleaseTag: semanticVersion.PreReleaseTag,
preReleaseTagWithDash: semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null,
buildMetaData: semanticVersion.BuildMetaData,
buildMetaDataPadded: semanticVersion.BuildMetaData.ToString("p" + config.BuildMetaDataPadding),
fullBuildMetaData: semanticVersion.BuildMetaData.ToString("f"),
majorMinorPatch: string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch),
semVer: semanticVersion.ToString(),
legacySemVer: semanticVersion.ToString("l"),
legacySemVerPadded: semanticVersion.ToString("lp" + config.LegacySemVerPadding),
assemblySemVer: semanticVersion.GetAssemblyVersion(config.AssemblyVersioningScheme),
fullSemVer: semanticVersion.ToString("f"),
informationalVersion: semanticVersion.ToString("i"),
branchName: semanticVersion.BuildMetaData.Branch,
sha: semanticVersion.BuildMetaData.Sha,
commitDate: semanticVersion.BuildMetaData.CommitDate.UtcDateTime.ToString("yyyy-MM-dd"));
return(variables);
}
private static SemanticVersion AppendTagNumberPattern(this SemanticVersion version, EffectiveConfiguration config)
{
if (!CanAppendTagNumberPattern(version, config))
{
return(version);
}
var match = Regex.Match(version.BuildMetadata.Branch, config.TagNumberPattern);
var numberGroup = match.Groups["number"];
if (!numberGroup.Success)
{
return(version);
}
var tagNumberPattern = numberGroup.Value.PadLeft(config.BuildMetaDataPadding, '0');
return(version.Copy(
preReleaseTag: new PreReleaseTag(
name: version.PreReleaseTag.Name + tagNumberPattern,
number: version.PreReleaseTag.Number)));
}
public SemanticVersionFormatValues(SemanticVersion semver, EffectiveConfiguration config)
{
this.semver = semver;
this.config = config;
}
public VersionVariables GetVariablesFor(SemanticVersion semanticVersion, EffectiveConfiguration config, bool isCurrentCommitTagged)
{
var isContinuousDeploymentMode = config.VersioningMode == VersioningMode.ContinuousDeployment && !isCurrentCommitTagged;
if (isContinuousDeploymentMode)
{
semanticVersion = new SemanticVersion(semanticVersion);
// Continuous Deployment always requires a pre-release tag unless the commit is tagged
if (!semanticVersion.PreReleaseTag.HasTag())
{
semanticVersion.PreReleaseTag.Name = nextVersionCalculator.GetBranchSpecificTag(config, semanticVersion.BuildMetaData.Branch, null);
if (string.IsNullOrEmpty(semanticVersion.PreReleaseTag.Name))
{
semanticVersion.PreReleaseTag.Name = config.ContinuousDeploymentFallbackTag;
}
}
}
// Evaluate tag number pattern and append to prerelease tag, preserving build metadata
var appendTagNumberPattern = !string.IsNullOrEmpty(config.TagNumberPattern) && semanticVersion.PreReleaseTag.HasTag();
if (appendTagNumberPattern)
{
var match = Regex.Match(semanticVersion.BuildMetaData.Branch, config.TagNumberPattern);
var numberGroup = match.Groups["number"];
if (numberGroup.Success)
{
semanticVersion.PreReleaseTag.Name += numberGroup.Value.PadLeft(config.BuildMetaDataPadding, '0');
}
}
if (isContinuousDeploymentMode || appendTagNumberPattern || config.VersioningMode == VersioningMode.Mainline)
{
PromoteNumberOfCommitsToTagNumber(semanticVersion);
}
var semverFormatValues = new SemanticVersionFormatValues(semanticVersion, config);
var informationalVersion = CheckAndFormatString(config.AssemblyInformationalFormat, semverFormatValues,
environment, semverFormatValues.InformationalVersion, "AssemblyInformationalVersion");
var assemblyFileSemVer = CheckAndFormatString(config.AssemblyFileVersioningFormat, semverFormatValues,
environment, semverFormatValues.AssemblyFileSemVer, "AssemblyFileVersioningFormat");
var assemblySemVer = CheckAndFormatString(config.AssemblyVersioningFormat, semverFormatValues,
environment, semverFormatValues.AssemblySemVer, "AssemblyVersioningFormat");
var variables = new VersionVariables(
semverFormatValues.Major,
semverFormatValues.Minor,
semverFormatValues.Patch,
semverFormatValues.BuildMetaData,
semverFormatValues.BuildMetaDataPadded,
semverFormatValues.FullBuildMetaData,
semverFormatValues.BranchName,
semverFormatValues.EscapedBranchName,
semverFormatValues.Sha,
semverFormatValues.ShortSha,
semverFormatValues.MajorMinorPatch,
semverFormatValues.SemVer,
semverFormatValues.LegacySemVer,
semverFormatValues.LegacySemVerPadded,
semverFormatValues.FullSemVer,
assemblySemVer,
assemblyFileSemVer,
semverFormatValues.PreReleaseTag,
semverFormatValues.PreReleaseTagWithDash,
semverFormatValues.PreReleaseLabel,
semverFormatValues.PreReleaseNumber,
semverFormatValues.WeightedPreReleaseNumber,
informationalVersion,
semverFormatValues.CommitDate,
semverFormatValues.NuGetVersion,
semverFormatValues.NuGetVersionV2,
semverFormatValues.NuGetPreReleaseTag,
semverFormatValues.NuGetPreReleaseTagV2,
semverFormatValues.VersionSourceSha,
semverFormatValues.CommitsSinceVersionSource,
semverFormatValues.CommitsSinceVersionSourcePadded);
return(variables);
}
/// <summary>
/// Converts a <see cref="SemanticVersion"/> into <see cref="VersionVariables"/>
/// </summary>
/// <param name="version">Semantic version</param>
/// <param name="config">Effective configuration</param>
/// <param name="isCurrentCommitTagged">Defines, if current commit is tagged</param>
public static VersionVariables ToVersionVariables(this SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged = false)
{
return(new VersionVariablesProvider(version, config, isCurrentCommitTagged)
.GetVariables());
}
public VersionFormatValues(SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged = false)
{
_version = version.FormatVersion(config, isCurrentCommitTagged);
_config = config;
}
private static bool CanAppendTagNumberPattern(SemanticVersion version, EffectiveConfiguration config)
{
return(!string.IsNullOrEmpty(config.TagNumberPattern) &&
!version.PreReleaseTag.IsNull());
}
static bool TryParse(Commit mergeCommit, EffectiveConfiguration configuration, out SemanticVersion semanticVersion)
{
semanticVersion = Inner(mergeCommit, configuration);
return semanticVersion != null;
}
public SemanticVersionFormatValues(SemanticVersion semver, EffectiveConfiguration config)
{
_semver = semver;
_config = config;
}
private static SemanticVersion PromoteNumberOfCommitsToTagNumber(this SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged)
{
if (IsContinuousDeploymentMode(config, isCurrentCommitTagged) ||
CanAppendTagNumberPattern(version, config) ||
config.VersioningMode == VersioningMode.Mainline)
{
// For continuous deployment the commits since tag gets promoted to the pre-release number
return(version.Copy(
preReleaseTag: new PreReleaseTag(
name: version.PreReleaseTag.Name,
number: version.BuildMetadata.CommitsSinceTag),
buildMetadata: new BuildMetadata(
commitsSinceTag: null,
branch: version.BuildMetadata.Branch,
commitHash: version.BuildMetadata.Hash,
commitDate: version.BuildMetadata.CommitDate,
commitsSinceVersionSource: version.BuildMetadata.CommitsSinceTag ?? 0,
otherMetadata: version.BuildMetadata.OtherMetadata)));
}
return(version);
}
static bool TryParse(Commit mergeCommit, EffectiveConfiguration configuration, out SemanticVersion semanticVersion)
{
semanticVersion = Inner(mergeCommit, configuration);
return(semanticVersion != null);
}
private static bool IsContinuousDeploymentMode(EffectiveConfiguration config, bool isCurrentCommitTagged)
{
return(config.VersioningMode == VersioningMode.ContinuousDeployment &&
!isCurrentCommitTagged);
}
public VersionVariablesProvider(SemanticVersion version, EffectiveConfiguration config, bool isCurrentCommitTagged = false)
{
_formatValues = new VersionFormatValues(version, config, isCurrentCommitTagged);
}
