public void FindsGitDirectoryInParent()
{
var childDir = Path.Combine(workDirectory, "child");
Directory.CreateDirectory(childDir);
try
{
var arguments = new Arguments {
TargetPath = childDir, NoFetch = true
};
var options = Options.Create(arguments);
var gitPreparer = new GitPreparer(log, environment, options);
var configurationProvider = new ConfigProvider(testFileSystem, log, configFileLocator, gitPreparer, configInitWizard);
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, environment);
var gitVersionCalculator = new GitVersionCalculator(testFileSystem, log, configFileLocator, configurationProvider, buildServerResolver, gitVersionCache, gitVersionFinder, gitPreparer, variableProvider, options);
gitVersionCalculator.CalculateVersionVariables();
}
catch (Exception ex)
{
// TODO I think this test is wrong.. It throws a different exception
// `RepositoryNotFoundException` means that it couldn't find the .git directory,
// any other exception means that the .git was found but there was some other issue that this test doesn't care about.
Assert.IsNotAssignableFrom <RepositoryNotFoundException>(ex);
}
}
public void ShouldCreateFile(string fileExtension)
{
var fileSystem = new TestFileSystem();
var directory = Path.GetTempPath();
var fileName = "GitVersionInformation.g." + fileExtension;
var fullPath = Path.Combine(directory, fileName);
var semanticVersion = new SemanticVersion
{
Major = 1,
Minor = 2,
Patch = 3,
PreReleaseTag = "unstable4",
BuildMetaData = new SemanticVersionBuildMetaData("versionSourceSha", 5,
"feature1", "commitSha", "commitShortSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
};
var log = new NullLog();
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var variables = variableProvider.GetVariablesFor(semanticVersion, new TestEffectiveConfiguration(), false);
var generator = new GitVersionInformationGenerator(fileName, directory, variables, fileSystem);
generator.Generate();
fileSystem.ReadAllText(fullPath).ShouldMatchApproved(c => c.SubFolder(Path.Combine("Approved", fileExtension)));
}
public void CreateTemporaryRepository()
{
workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
gitDirectory = Repository.Init(workDirectory).TrimEnd(Path.DirectorySeparatorChar);
testFileSystem = new TestFileSystem();
log = new NullLog();
environment = new TestEnvironment();
var stepFactory = new ConfigInitStepFactory();
configInitWizard = new ConfigInitWizard(new ConsoleAdapter(), stepFactory);
configFileLocator = new DefaultConfigFileLocator(testFileSystem, log);
gitVersionCache = new GitVersionCache(testFileSystem, log);
buildServerResolver = new BuildServerResolver(null, log);
metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
gitVersionFinder = new GitVersionFinder(log, nextVersionCalculator);
Assert.NotNull(gitDirectory);
}
private void RepositoryScope(ILog log, Action <EmptyRepositoryFixture, VersionVariables> fixtureAction = null)
{
// Make sure GitVersion doesn't trigger build server mode when we are running the tests
environment.SetEnvironmentVariable(AppVeyor.EnvironmentVariableName, null);
environment.SetEnvironmentVariable(TravisCi.EnvironmentVariableName, null);
environment.SetEnvironmentVariable(AzurePipelines.EnvironmentVariableName, null);
using var fixture = new EmptyRepositoryFixture();
var arguments = new Arguments {
TargetPath = fixture.RepositoryPath
};
var options = Options.Create(arguments);
var gitPreparer = new GitPreparer(log, environment, options);
var stepFactory = new ConfigInitStepFactory();
var configInitWizard = new ConfigInitWizard(new ConsoleAdapter(), stepFactory);
var configurationProvider = new ConfigProvider(fileSystem, log, configFileLocator, gitPreparer, configInitWizard);
var baseVersionCalculator = new BaseVersionCalculator(this.log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(this.log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(this.log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var gitVersionCalculator = new GitVersionCalculator(fileSystem, log, configFileLocator, configurationProvider, buildServerResolver, gitVersionCache, gitVersionFinder, gitPreparer, variableProvider, options);
fixture.Repository.MakeACommit();
var vv = gitVersionCalculator.CalculateVersionVariables();
vv.AssemblySemVer.ShouldBe("0.1.0.0");
vv.FileName.ShouldNotBeNullOrEmpty();
fixtureAction?.Invoke(fixture, vv);
}
public static VersionVariables GetVersion(this RepositoryFixtureBase fixture, Config configuration = null, IRepository repository = null, string commitId = null, bool isForTrackedBranchOnly = true, string targetBranch = null)
{
if (configuration == null)
{
configuration = new Config();
configuration.Reset();
}
var log = new NullLog();
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new TestBaseVersionStrategiesCalculator(log);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var gitVersionContext = new GitVersionContext(repository ?? fixture.Repository, log, targetBranch, configuration, isForTrackedBranchOnly, commitId);
var executeGitVersion = ExecuteGitVersion(gitVersionContext);
var variables = variableProvider.GetVariablesFor(executeGitVersion, gitVersionContext.Configuration, gitVersionContext.IsCurrentCommitTagged);
try
{
return(variables);
}
catch (Exception)
{
Console.WriteLine("Test failing, dumping repository graph");
gitVersionContext.Repository.DumpGraph();
throw;
}
}
public void SetUp()
{
environment = new TestEnvironment();
log = new NullLog();
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
}
public void Setup()
{
ShouldlyConfiguration.ShouldMatchApprovedDefaults.LocateTestMethodUsingAttribute <TestAttribute>();
var log = new NullLog();
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
}
private static SemanticVersion ExecuteGitVersion(GitVersionContext context)
{
var log = new NullLog();
var metadataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new TestBaseVersionStrategiesCalculator(log);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metadataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metadataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var vf = new GitVersionFinder(log, nextVersionCalculator);
return(vf.FindVersion(context));
}
public void DoesNotIncrementWhenBaseVersionSaysNotTo()
{
var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var config = new Config();
var context = new GitVersionContextBuilder().WithConfig(config).Build();
var version = sut.FindVersion(context);
version.ToString().ShouldBe("1.0.0");
}
public void DoesNotIncrementWhenBaseVersionSaysNotTo()
{
var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData("ef7d0d7e1e700f1c7c9fa01ea6791bb778a5c37c", 1, "master", "b1a34edbd80e141f7cc046c074f109be7d022074", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var config = new Config();
var context = new GitVersionContextBuilder().WithConfig(config).Build();
var version = sut.FindVersion(context);
version.ToString().ShouldBe("1.0.0");
}
public void ShouldIncrementVersionBasedOnConfig()
{
var baseCalculator = new TestBaseVersionCalculator(true, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(1, "master", "b1a34edbd80e141f7cc046c074f109be7d022074", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var config = new Config();
var context = new GitVersionContextBuilder().WithConfig(config).Build();
var version = sut.FindVersion(context);
version.ToString().ShouldBe("1.0.1");
}
public void AppliesBranchPreReleaseTag()
{
var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData("ef7d0d7e1e700f1c7c9fa01ea6791bb778a5c37c", 2, "develop", "b1a34edbd80e141f7cc046c074f109be7d022074", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var context = new GitVersionContextBuilder()
.WithDevelopBranch()
.Build();
var version = sut.FindVersion(context);
version.ToString("f").ShouldBe("1.0.0-alpha.1+2");
}
public void AppliesBranchPreReleaseTag()
{
var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(2, "develop", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var context = new GitVersionContextBuilder()
.WithDevelopBranch()
.Build();
var version = sut.FindVersion(context);
version.ToString("f").ShouldBe("1.0.0-alpha.1+2");
}
public void VersionSourceShaOneCommit()
{
var config = new Config().ApplyDefaults();
using var fixture = new EmptyRepositoryFixture();
var initialCommit = fixture.Repository.MakeACommit();
var context = new GitVersionContext(fixture.Repository, new NullLog(), fixture.Repository.Head, config);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var version = nextVersionCalculator.FindVersion(context);
version.BuildMetaData.VersionSourceSha.ShouldBe(initialCommit.Sha);
version.BuildMetaData.CommitsSinceVersionSource.ShouldBe(0);
}
public void SetUp()
{
fileSystem = new FileSystem();
environment = new TestEnvironment();
log = new NullLog();
configFileLocator = new DefaultConfigFileLocator(fileSystem, log);
buildServerResolver = new BuildServerResolver(null, log);
gitVersionCache = new GitVersionCache(fileSystem, log);
metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new TestBaseVersionStrategiesCalculator(log);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
gitVersionFinder = new GitVersionFinder(log, nextVersionCalculator);
}
private GitVersionCalculator GetGitVersionCalculator(Arguments arguments)
{
var options = Options.Create(arguments);
var gitPreparer = new GitPreparer(log, environment, options);
var stepFactory = new ConfigInitStepFactory();
var configInitWizard = new ConfigInitWizard(new ConsoleAdapter(), stepFactory);
var configurationProvider = new ConfigProvider(fileSystem, log, configFileLocator, gitPreparer, configInitWizard);
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var gitVersionCalculator = new GitVersionCalculator(fileSystem, log, configFileLocator, configurationProvider, buildServerResolver, gitVersionCache, gitVersionFinder, gitPreparer, variableProvider, options);
return(gitVersionCalculator);
}
public void FindsVersionInDynamicRepo(string name, string url, string targetBranch, string commitId, string expectedFullSemVer)
{
var root = Path.Combine(workDirectory, name);
var dynamicDirectory = Path.Combine(root, "D"); // dynamic, keeping directory as short as possible
var workingDirectory = Path.Combine(root, "W"); // working, keeping directory as short as possible
var arguments = new Arguments
{
TargetUrl = url,
DynamicRepositoryLocation = dynamicDirectory,
TargetBranch = targetBranch,
NoFetch = false,
TargetPath = workingDirectory,
CommitId = commitId
};
var options = Options.Create(arguments);
Directory.CreateDirectory(dynamicDirectory);
Directory.CreateDirectory(workingDirectory);
var testFileSystem = new TestFileSystem();
var log = new NullLog();
var configFileLocator = new DefaultConfigFileLocator(testFileSystem, log);
var gitVersionCache = new GitVersionCache(testFileSystem, log);
var buildServerResolver = new BuildServerResolver(null, log);
var metadataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new TestBaseVersionStrategiesCalculator(log);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metadataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metadataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var gitVersionFinder = new GitVersionFinder(log, nextVersionCalculator);
var gitPreparer = new GitPreparer(log, new TestEnvironment(), options);
var stepFactory = new ConfigInitStepFactory();
var configInitWizard = new ConfigInitWizard(new ConsoleAdapter(), stepFactory);
var configurationProvider = new ConfigProvider(testFileSystem, log, configFileLocator, gitPreparer, configInitWizard);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var gitVersionCalculator = new GitVersionCalculator(testFileSystem, log, configFileLocator, configurationProvider, buildServerResolver, gitVersionCache, gitVersionFinder, gitPreparer, variableProvider, options);
var versionVariables = gitVersionCalculator.CalculateVersionVariables();
Assert.AreEqual(expectedFullSemVer, versionVariables.FullSemVer);
}
public void CalculateNotTaggedCommitVersionTest()
{
var baseCalculatorMock = new Mock <IBaseVersionCalculator>();
var baseCalculator = baseCalculatorMock.Object;
baseCalculatorMock.Setup(c => c.CalculateVersion(It.IsAny <IVersionContext>()))
.Returns(new BaseVersion("", new SemanticVersion(1), null, shouldIncrement: true));
var metadatCalculatorMock = new Mock <IMetadataCalculator>();
var metadataCalculator = metadatCalculatorMock.Object;
metadatCalculatorMock.Setup(m => m.CalculateMetadata(
It.IsAny <IVersionContext>(),
It.IsAny <ICommit>()))
.Returns((BuildMetadata)null);
var tagCalculatorMock = new Mock <IPreReleaseTagCalculator>();
var tagCalculator = tagCalculatorMock.Object;
tagCalculatorMock.Setup(t => t.CalculateTag(
It.IsAny <IVersionContext>(),
It.IsAny <SemanticVersion>(),
It.IsAny <string>()))
.Returns((PreReleaseTag)null);
var contextMock = new Mock <IVersionContext>();
var context = contextMock.Object;
contextMock.Setup(c => c.Configuration).Returns(new TestEffectiveConfiguration());
contextMock.Setup(c => c.IsCurrentCommitTagged).Returns(false);
var versionCalculator = new NextVersionCalculator(
baseCalculator,
metadataCalculator,
tagCalculator);
var version = versionCalculator.CalculateVersion(context);
var expected = SemanticVersion.Parse("1.0.1");
Assert.That(version, Is.EqualTo(expected));
}
public void PreReleaseTagCanUseBranchNameVariable()
{
var baseCalculator = new TestBaseVersionCalculator(false, new SemanticVersion(1), new MockCommit());
var semanticVersionBuildMetaData = new SemanticVersionBuildMetaData(2, "develop", "b1a34e", DateTimeOffset.Now);
var sut = new NextVersionCalculator(baseCalculator, new TestMetaDataCalculator(semanticVersionBuildMetaData));
var config = new Config();
config.Branches.Add("custom/", new BranchConfig
{
Tag = "alpha.{BranchName}"
});
var context = new GitVersionContextBuilder()
.WithConfig(config)
.WithDevelopBranch()
.AddBranch("custom/foo")
.Build();
var version = sut.FindVersion(context);
version.ToString("f").ShouldBe("1.0.0-alpha.foo.1+2");
}
public void VersionSourceSha()
{
var config = new Config().ApplyDefaults();
using (var fixture = new EmptyRepositoryFixture())
{
var initialCommit = fixture.Repository.MakeACommit();
Commands.Checkout(fixture.Repository, fixture.Repository.CreateBranch("develop"));
_ = fixture.Repository.MakeACommit();
var featureBranch = fixture.Repository.CreateBranch("feature/foo");
Commands.Checkout(fixture.Repository, featureBranch);
_ = fixture.Repository.MakeACommit();
var context = new GitVersionContext(fixture.Repository, fixture.Repository.Head, config);
var nextVersionCalculator = new NextVersionCalculator();
var version = nextVersionCalculator.FindVersion(context);
version.BuildMetaData.VersionSourceSha.ShouldBe(initialCommit.Sha);
version.BuildMetaData.CommitsSinceVersionSource.ShouldBe(2);
}
}
public void VersionSourceShaUsingTag()
{
var config = new Config().ApplyDefaults();
using var fixture = new EmptyRepositoryFixture();
_ = fixture.Repository.MakeACommit();
Commands.Checkout(fixture.Repository, fixture.Repository.CreateBranch("develop"));
var secondCommit = fixture.Repository.MakeACommit();
_ = fixture.Repository.Tags.Add("1.0", secondCommit);
var featureBranch = fixture.Repository.CreateBranch("feature/foo");
Commands.Checkout(fixture.Repository, featureBranch);
_ = fixture.Repository.MakeACommit();
var context = new GitVersionContext(fixture.Repository, new NullLog(), fixture.Repository.Head, config);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var version = nextVersionCalculator.FindVersion(context);
version.BuildMetaData.VersionSourceSha.ShouldBe(secondCommit.Sha);
version.BuildMetaData.CommitsSinceVersionSource.ShouldBe(1);
}
public SemanticVersion FindVersion(IVersionContext context)
{
var branchName = context.CurrentBranch.Name;
var commit = context.CurrentCommit == null ? "-" : context.CurrentCommit.Hash;
Logger.WriteInfo($"Running against branch: {branchName} ({commit})");
if (context.IsCurrentCommitTagged)
{
Logger.WriteInfo(
$"Current commit is tagged with version {context.CurrentCommitTaggedVersion}, "
+ "version calcuation is for metadata only.");
}
var calculator = new NextVersionCalculator(
new BaseVersionCalculator(context
.Configuration
.BaseVersionStrategies
.ToArray()));
return(calculator.CalculateVersion(context));
}
public void UpdateWixVersionFile()
{
var fileSystem = new TestFileSystem();
var workingDir = Path.GetTempPath();
var semVer = new SemanticVersion
{
Major = 1,
Minor = 2,
Patch = 3,
BuildMetaData = "5.Branch.develop"
};
semVer.BuildMetaData.VersionSourceSha = "versionSourceSha";
semVer.BuildMetaData.Sha = "commitSha";
semVer.BuildMetaData.ShortSha = "commitShortSha";
semVer.BuildMetaData.CommitDate = DateTimeOffset.Parse("2019-02-20 23:59:59Z");
var config = new TestEffectiveConfiguration(buildMetaDataPadding: 2, legacySemVerPadding: 5);
var stringBuilder = new StringBuilder();
void Action(string s) => stringBuilder.AppendLine(s);
var logAppender = new TestLogAppender(Action);
var log = new Log(logAppender);
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var vars = variableProvider.GetVariablesFor(semVer, config, false);
using var wixVersionFileUpdater = new WixVersionFileUpdater(workingDir, vars, fileSystem, log);
wixVersionFileUpdater.Update();
fileSystem.ReadAllText(wixVersionFileUpdater.WixVersionFile).
ShouldMatchApproved(c => c.SubFolder(Path.Combine("Approved")));
}
public void Json()
{
var semanticVersion = new SemanticVersion
{
Major = 1,
Minor = 2,
Patch = 0,
PreReleaseTag = "unstable4",
BuildMetaData = new SemanticVersionBuildMetaData("versionSourceSha", 5, "feature1", "commitSha", "commitShortSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
};
var config = new TestEffectiveConfiguration();
var log = new NullLog();
var metaDataCalculator = new MetaDataCalculator();
var baseVersionCalculator = new BaseVersionCalculator(log, null);
var mainlineVersionCalculator = new MainlineVersionCalculator(log, metaDataCalculator);
var nextVersionCalculator = new NextVersionCalculator(log, metaDataCalculator, baseVersionCalculator, mainlineVersionCalculator);
var variableProvider = new VariableProvider(nextVersionCalculator, new TestEnvironment());
var variables = variableProvider.GetVariablesFor(semanticVersion, config, false);
var json = JsonOutputFormatter.ToJson(variables);
json.ShouldMatchApproved(c => c.SubFolder("Approved"));
}
public static 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);
string informationalVersion;
if (string.IsNullOrEmpty(config.AssemblyInformationalFormat))
{
informationalVersion = semverFormatValues.DefaultInformationalVersion;
}
else
{
try
{
informationalVersion = config.AssemblyInformationalFormat.FormatWith <SemanticVersionFormatValues>(semverFormatValues);
}
catch (ArgumentException formex)
{
throw new WarningException(string.Format("Unable to format AssemblyInformationalVersion. Check your format string: {0}", formex.Message));
}
}
var variables = new VersionVariables(
semverFormatValues.Major,
semverFormatValues.Minor,
semverFormatValues.Patch,
semverFormatValues.BuildMetaData,
semverFormatValues.BuildMetaDataPadded,
semverFormatValues.FullBuildMetaData,
semverFormatValues.BranchName,
semverFormatValues.Sha,
semverFormatValues.MajorMinorPatch,
semverFormatValues.SemVer,
semverFormatValues.LegacySemVer,
semverFormatValues.LegacySemVerPadded,
semverFormatValues.FullSemVer,
semverFormatValues.AssemblySemVer,
semverFormatValues.AssemblyFileSemVer,
semverFormatValues.PreReleaseTag,
semverFormatValues.PreReleaseTagWithDash,
semverFormatValues.PreReleaseLabel,
semverFormatValues.PreReleaseNumber,
informationalVersion,
semverFormatValues.CommitDate,
semverFormatValues.NuGetVersion,
semverFormatValues.NuGetVersionV2,
semverFormatValues.NuGetPreReleaseTag,
semverFormatValues.NuGetPreReleaseTagV2,
semverFormatValues.CommitsSinceVersionSource,
semverFormatValues.CommitsSinceVersionSourcePadded);
return(variables);
}
