public static Version GetVersion(string workDir, string tagPrefix, MajorMinor minMajorMinor, string buildMeta, VersionPart autoIncrement, string defaultPreReleasePhase, ILogger log, bool ignoreHeight = false)
{
log = log ?? throw new ArgumentNullException(nameof(log));
defaultPreReleasePhase = string.IsNullOrEmpty(defaultPreReleasePhase)
? "alpha"
: defaultPreReleasePhase;
var(version, height) = GetVersion(workDir, tagPrefix, defaultPreReleasePhase, log);
_ = height.HasValue && ignoreHeight && log.IsDebugEnabled && log.Debug("Ignoring height.");
version = !height.HasValue || ignoreHeight ? version : version.WithHeight(height.Value, autoIncrement, defaultPreReleasePhase);
version = version.AddBuildMetadata(buildMeta);
var calculatedVersion = version.Satisfying(minMajorMinor, defaultPreReleasePhase);
_ = calculatedVersion != version
? log.IsInfoEnabled && log.Info($"Bumping version to {calculatedVersion} to satisfy minimum major minor {minMajorMinor}.")
: log.IsDebugEnabled && log.Debug($"The calculated version {calculatedVersion} satisfies the minimum major minor {minMajorMinor}.");
_ = log.IsInfoEnabled && log.Info($"Calculated version {calculatedVersion}.");
return(calculatedVersion);
}
private static Version GetVersion(string repoOrWorkDir, string tagPrefix, MajorMinor minMajorMinor, string buildMeta, Verbosity verbosity)
{
var log = new Logger(verbosity);
if (log.IsDebugEnabled)
{
log.Debug($"MinVer {informationalVersion}.");
}
if (!RepositoryEx.TryCreateRepo(repoOrWorkDir, out var repo))
{
var version = new Version(minMajorMinor?.Major ?? 0, minMajorMinor?.Minor ?? 0, buildMeta);
log.WarnIsNotAValidRepositoryOrWorkDirUsingDefaultVersion(repoOrWorkDir, version);
return(version);
}
try
{
return(Versioner.GetVersion(repo, tagPrefix, minMajorMinor, buildMeta, log));
}
finally
{
repo.Dispose();
}
}
private static bool TryParse(string repoOrWorkDirOption, string minMajorMinorOption, string verbosityOption, out string repoOrWorkDir, out MajorMinor minMajorMinor, out Verbosity verbosity)
{
repoOrWorkDir = ".";
minMajorMinor = default;
verbosity = default;
if (!string.IsNullOrEmpty(repoOrWorkDirOption) && !Directory.Exists(repoOrWorkDir = repoOrWorkDirOption))
{
Logger.ErrorRepoOrWorkDirDoesNotExist(repoOrWorkDirOption);
return(false);
}
if (!string.IsNullOrEmpty(minMajorMinorOption) && !MajorMinor.TryParse(minMajorMinorOption, out minMajorMinor))
{
Logger.ErrorInvalidMinMajorMinor(minMajorMinorOption);
return(false);
}
if (!string.IsNullOrEmpty(verbosityOption) && !VerbosityMap.TryMap(verbosityOption, out verbosity))
{
Logger.ErrorInvalidVerbosity(verbosityOption);
return(false);
}
return(true);
}
public Chord(NoteLetter key, MajorMinor majorMinor)
{
_key = key;
_majorMinor = majorMinor;
_baseNotes = new List <NoteLetter>();
_addedNotes = new List <NoteLetter>();
}
public static Version GetVersion(string workDir, string tagPrefix, MajorMinor minMajorMinor, string buildMeta, VersionPart autoIncrement, string defaultPreReleasePhase, ILogger log)
{
log = log ?? new NullLogger();
defaultPreReleasePhase = string.IsNullOrEmpty(defaultPreReleasePhase)
? "alpha"
: defaultPreReleasePhase;
var version = GetVersion(workDir, tagPrefix, autoIncrement, defaultPreReleasePhase, log).AddBuildMetadata(buildMeta);
var calculatedVersion = version.Satisfying(minMajorMinor, defaultPreReleasePhase);
if (calculatedVersion != version)
{
log.Info($"Bumping version to {calculatedVersion} to satisfy minimum major minor {minMajorMinor}.");
}
else
{
if (minMajorMinor != null)
{
log.Debug($"The calculated version {calculatedVersion} satisfies the minimum major minor {minMajorMinor}.");
}
}
log.Info($"Calculated version {calculatedVersion}.");
return(calculatedVersion);
}
public static Version GetVersion(string repoOrWorkDir, string tagPrefix, MajorMinor minMajorMinor, string buildMeta, VersionPart autoIncrement, ILogger log)
{
if (log == null)
{
throw new System.ArgumentNullException(nameof(log));
}
var version = GetVersion(repoOrWorkDir, tagPrefix, autoIncrement, log).AddBuildMetadata(buildMeta);
var calculatedVersion = version.Satisfying(minMajorMinor);
if (calculatedVersion != version)
{
log.Info($"Bumping version to {calculatedVersion} to satisfy minimum major minor {minMajorMinor}.");
}
else
{
if (minMajorMinor != default)
{
log.Debug($"The calculated version {calculatedVersion} satisfies the minimum major minor {minMajorMinor}.");
}
}
log.Info($"Calculated version {calculatedVersion}.");
return(calculatedVersion);
}
private static bool TryParse(string workDirOption, string minMajorMinorOption, string verbosityOption, string autoIncrementOption, out string workDir, out MajorMinor minMajorMinor, out Verbosity verbosity, out VersionPart autoIncrement)
{
workDir = ".";
minMajorMinor = null;
verbosity = default;
autoIncrement = default;
if (!string.IsNullOrEmpty(workDirOption) && !Directory.Exists(workDir = workDirOption))
{
Logger.ErrorWorkDirDoesNotExist(workDirOption);
return(false);
}
if (!string.IsNullOrEmpty(minMajorMinorOption) && !MajorMinor.TryParse(minMajorMinorOption, out minMajorMinor))
{
Logger.ErrorInvalidMinMajorMinor(minMajorMinorOption);
return(false);
}
if (!string.IsNullOrEmpty(verbosityOption) && !VerbosityMap.TryMap(verbosityOption, out verbosity))
{
Logger.ErrorInvalidVerbosity(verbosityOption);
return(false);
}
if (!string.IsNullOrEmpty(autoIncrementOption) && !Enum.TryParse(autoIncrementOption, true, out autoIncrement))
{
Logger.ErrorInvalidAutoIncrement(autoIncrementOption);
return(false);
}
return(true);
}
public static bool TryParseEnvVars([NotNullWhen(returnValue: true)] out Options?options)
{
options = null;
VersionPart?autoIncrement = null;
MajorMinor? minMajorMinor = null;
Verbosity? verbosity = null;
Lib.Version?versionOverride = null;
var autoIncrementEnvVar = GetEnvVar("MinVerAutoIncrement");
if (!string.IsNullOrEmpty(autoIncrementEnvVar))
{
if (Enum.TryParse <VersionPart>(autoIncrementEnvVar, true, out var versionPart))
{
autoIncrement = versionPart;
}
else
{
Logger.ErrorInvalidEnvVar("MinVerAutoIncrement", autoIncrementEnvVar, VersionPartExtensions.ValidValues);
return(false);
}
}
var buildMeta = GetEnvVar("MinVerBuildMetadata");
var defaultPreReleasePhase = GetEnvVar("MinVerDefaultPreReleasePhase");
var minMajorMinorEnvVar = GetEnvVar("MinVerMinimumMajorMinor");
if (!string.IsNullOrEmpty(minMajorMinorEnvVar) && !MajorMinor.TryParse(minMajorMinorEnvVar, out minMajorMinor))
{
Logger.ErrorInvalidEnvVar("MinVerMinimumMajorMinor", minMajorMinorEnvVar, MajorMinor.ValidValues);
return(false);
}
var tagPrefix = GetEnvVar("MinVerTagPrefix");
var verbosityEnvVar = GetEnvVar("MinVerVerbosity");
if (!string.IsNullOrEmpty(verbosityEnvVar) && !VerbosityMap.TryMap(verbosityEnvVar, out verbosity))
{
Logger.ErrorInvalidEnvVar("MinVerVerbosity", verbosityEnvVar, VerbosityMap.ValidValues);
return(false);
}
var versionOverrideEnvVar = GetEnvVar("MinVerVersionOverride");
if (!string.IsNullOrEmpty(versionOverrideEnvVar) && !Lib.Version.TryParse(versionOverrideEnvVar, out versionOverride))
{
Logger.ErrorInvalidEnvVar("MinVerVersionOverride", versionOverrideEnvVar, "");
return(false);
}
options = new Options(autoIncrement, buildMeta, defaultPreReleasePhase, minMajorMinor, tagPrefix, verbosity, versionOverride);
return(true);
}
public static bool TryParse(
string?autoIncrementOption,
string?buildMetaOption,
string?defaultPreReleasePhaseOption,
bool?ignoreHeight,
string?minMajorMinorOption,
string?tagPrefixOption,
string?verbosityOption,
#if MINVER
string?versionOverrideOption,
#endif
[NotNullWhen(returnValue: true)] out Options?options)
{
options = null;
VersionPart?autoIncrement = null;
MajorMinor? minMajorMinor = null;
Verbosity? verbosity = null;
Lib.Version?versionOverride = null;
if (!string.IsNullOrEmpty(autoIncrementOption))
{
if (Enum.TryParse <VersionPart>(autoIncrementOption, true, out var versionPart))
{
autoIncrement = versionPart;
}
else
{
Logger.ErrorInvalidAutoIncrement(autoIncrementOption);
return(false);
}
}
if (!string.IsNullOrEmpty(minMajorMinorOption) && !MajorMinor.TryParse(minMajorMinorOption, out minMajorMinor))
{
Logger.ErrorInvalidMinMajorMinor(minMajorMinorOption);
return(false);
}
if (!string.IsNullOrEmpty(verbosityOption) && !VerbosityMap.TryMap(verbosityOption, out verbosity))
{
Logger.ErrorInvalidVerbosity(verbosityOption);
return(false);
}
#if MINVER
if (!string.IsNullOrEmpty(versionOverrideOption) && !Lib.Version.TryParse(versionOverrideOption, out versionOverride))
{
Logger.ErrorInvalidVersionOverride(versionOverrideOption);
return(false);
}
#endif
options = new Options(autoIncrement, buildMetaOption, defaultPreReleasePhaseOption, ignoreHeight, minMajorMinor, tagPrefixOption, verbosity, versionOverride);
return(true);
}
public ChordSongInterpreter(NoteLetter key, MajorMinor majorMinor, int sampleRate, int beatsPerMinute, int beatsPerMeasure)
{
_key = key;
_majorMinor = majorMinor;
_sampleRate = sampleRate;
_tempo = beatsPerMinute;
_timeSignature = beatsPerMeasure;
_fallbackInterpreter = new DefaultSongInterpreter(sampleRate, beatsPerMinute, beatsPerMeasure);
SetupChordLookup();
}
public static async Task RepoWithHistory(int minMajor, int minMinor)
{
// arrange
var minMajorMinor = new MajorMinor(minMajor, minMinor);
var historicalCommands =
@"
git commit --allow-empty -m '.'
git tag not-a-version
git checkout -b foo
git commit --allow-empty -m '.'
git tag 1.0.0-foo.1
git checkout main
git merge foo --no-edit --no-ff
git checkout -b bar
git commit --allow-empty -m '.'
git checkout main
git checkout -b baz
git commit --allow-empty -m '.'
git checkout main
git merge bar baz --no-edit --no-ff --strategy=octopus
";
var path = MethodBase.GetCurrentMethod().GetTestDirectory(minMajorMinor);
await EnsureEmptyRepository(path);
foreach (var item in historicalCommands
.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Select((command, index) => new { Command = command, Index = $"{index}" }))
{
if (item.Command.StartsWith("git commit", StringComparison.Ordinal))
{
// Sometimes git seems to treat bar and baz as a single branch if the commits are empty.
// This probably occurs during the octopus merge.
// So let's add a file before each commit to ensure that doesn't happen.
await File.WriteAllTextAsync(Path.Combine(path, item.Index), item.Index);
_ = await ReadAsync("git", $"add {item.Index}", path);
// if not enough delay is given between commits,
// the order of parallel commits on different branches seems to be non-deterministic
await Task.Delay(1100);
}
var nameAndArgs = item.Command.Split(" ", 2);
_ = await ReadAsync(nameAndArgs[0], nameAndArgs[1], path);
}
var log = new TestLogger();
// act
_ = Versioner.GetVersion(path, "", minMajorMinor, "", default, "", log);
public SevenChord(NoteLetter key, MajorMinor majorMinor) : base(key, majorMinor)
{
if (_majorMinor == MajorMinor.Major)
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 11), AddHalfSteps(key, 14), AddHalfSteps(key, 17)
};
}
else
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 11), AddHalfSteps(key, 15), AddHalfSteps(key, 18)
};
}
}
public SixChord(NoteLetter key, MajorMinor majorMinor) : base(key, majorMinor)
{
if (_majorMinor == MajorMinor.Major)
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 9), AddHalfSteps(key, 12), AddHalfSteps(key, 16)
};
}
else
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 9), AddHalfSteps(key, 13), AddHalfSteps(key, 16)
};
}
}
public ThreeChord(NoteLetter key, MajorMinor majorMinor) : base(key, majorMinor)
{
if (_majorMinor == MajorMinor.Major)
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 4), AddHalfSteps(key, 7), AddHalfSteps(key, 11)
};
}
else
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 4), AddHalfSteps(key, 8), AddHalfSteps(key, 11)
};
}
}
public TwoChord(NoteLetter key, MajorMinor majorMinor) : base(key, majorMinor)
{
if (_majorMinor == MajorMinor.Major)
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 2), AddHalfSteps(key, 5), AddHalfSteps(key, 9)
};
}
else
{
_baseNotes = new List <NoteLetter>(3)
{
AddHalfSteps(key, 2), AddHalfSteps(key, 5), AddHalfSteps(key, 8)
};
}
}
public static Version GetVersion(string repoOrWorkDir, string tagPrefix, MajorMinor minMajorMinor, string buildMeta, ILogger log)
{
var version = GetVersion(repoOrWorkDir, tagPrefix, log).AddBuildMetadata(buildMeta);
var calculatedVersion = version.Satisfying(minMajorMinor);
if (calculatedVersion != version)
{
log.Info($"Bumping version to {calculatedVersion} to satisfy minimum major minor {minMajorMinor}.");
}
else
{
if (minMajorMinor != default)
{
log.Debug($"The calculated version {calculatedVersion} satisfies the minimum major minor {minMajorMinor}.");
}
}
log.Info($"Calculated version {calculatedVersion}.");
return(calculatedVersion);
}
public static bool TryParse(string value, out MajorMinor majorMinor)
{
majorMinor = null;
if (string.IsNullOrWhiteSpace(value))
{
return(false);
}
var numbers = value.Split('.');
var minor = 0;
if (numbers.Length > 2 ||
!int.TryParse(numbers[0], out var major) ||
(numbers.Length > 1 && !int.TryParse(numbers[1], out minor)))
{
return(false);
}
majorMinor = new MajorMinor(major, minor);
return(true);
}
public static bool TryParseEnvVars(out Options options)
{
options = new Options();
var autoIncrementEnvVar = GetEnvVar("MinVerAutoIncrement");
if (!string.IsNullOrEmpty(autoIncrementEnvVar))
{
if (!Enum.TryParse <VersionPart>(autoIncrementEnvVar, true, out var autoIncrement))
{
Logger.ErrorInvalidEnvVar("MinVerAutoIncrement", autoIncrementEnvVar, VersionPartEx.ValidValues);
return(false);
}
options.AutoIncrement = autoIncrement;
}
options.BuildMeta = GetEnvVar("MinVerBuildMetadata");
options.DefaultPreReleasePhase = GetEnvVar("MinVerDefaultPreReleasePhase");
var minMajorMinorEnvVar = GetEnvVar("MinVerMinimumMajorMinor");
if (!string.IsNullOrEmpty(minMajorMinorEnvVar))
{
if (!MajorMinor.TryParse(minMajorMinorEnvVar, out var minMajorMinor))
{
Logger.ErrorInvalidEnvVar("MinVerMinimumMajorMinor", minMajorMinorEnvVar, MajorMinor.ValidValues);
return(false);
}
options.MinMajorMinor = minMajorMinor;
}
options.TagPrefix = GetEnvVar("MinVerTagPrefix");
var verbosityEnvVar = GetEnvVar("MinVerVerbosity");
if (!string.IsNullOrEmpty(verbosityEnvVar))
{
if (!VerbosityMap.TryMap(verbosityEnvVar, out var verbosity))
{
Logger.ErrorInvalidEnvVar("MinVerVerbosity", verbosityEnvVar, VerbosityMap.ValidValues);
return(false);
}
options.Verbosity = verbosity;
}
var versionOverrideEnvVar = GetEnvVar("MinVerVersionOverride");
if (!string.IsNullOrEmpty(versionOverrideEnvVar))
{
if (!Lib.Version.TryParse(versionOverrideEnvVar, out var versionOverride))
{
Logger.ErrorInvalidEnvVar("MinVerVersionOverride", versionOverrideEnvVar, null);
return(false);
}
options.VersionOverride = versionOverride;
}
return(true);
}
public static bool TryParse(
string autoIncrementOption,
string buildMetaOption,
string defaultPreReleasePhaseOption,
string minMajorMinorOption,
string tagPrefixOption,
string verbosityOption,
#if MINVER
string versionOverrideOption,
#endif
out Options options)
{
options = new Options();
if (!string.IsNullOrEmpty(autoIncrementOption))
{
if (!Enum.TryParse <VersionPart>(autoIncrementOption, true, out var autoIncrement))
{
Logger.ErrorInvalidAutoIncrement(autoIncrementOption);
return(false);
}
options.AutoIncrement = autoIncrement;
}
options.BuildMeta = buildMetaOption;
options.DefaultPreReleasePhase = defaultPreReleasePhaseOption;
if (!string.IsNullOrEmpty(minMajorMinorOption))
{
if (!MajorMinor.TryParse(minMajorMinorOption, out var minMajorMinor))
{
Logger.ErrorInvalidMinMajorMinor(minMajorMinorOption);
return(false);
}
options.MinMajorMinor = minMajorMinor;
}
options.TagPrefix = tagPrefixOption;
if (!string.IsNullOrEmpty(verbosityOption))
{
if (!VerbosityMap.TryMap(verbosityOption, out var verbosity))
{
Logger.ErrorInvalidVerbosity(verbosityOption);
return(false);
}
options.Verbosity = verbosity;
}
#if MINVER
if (!string.IsNullOrEmpty(versionOverrideOption))
{
if (!Lib.Version.TryParse(versionOverrideOption, out var versionOverride))
{
Logger.ErrorInvalidVersionOverride(versionOverrideOption);
return(false);
}
options.VersionOverride = versionOverride;
}
#endif
return(true);
}
