public AppVersion(int Major, int Minor, int Revision, int Build, ReleaseLevel level)
{
major = Major;
minor = Minor;
revision = Revision;
build = Build;
releaseLevel = level;
}
public void SetChoice(ReleaseLevel level, CSVersion version)
{
if (HasChoice)
{
throw new InvalidOperationException(nameof(HasChoice));
}
if (IsCanceled)
{
throw new InvalidOperationException(nameof(IsCanceled));
}
if (!PossibleVersions[level].Contains(version))
{
throw new ArgumentException("Not a version for level.", nameof(version));
}
FinalLevel = level;
FinalVersion = version;
}
/// <summary>
/// Returns a new <see cref="ReleaseInfo"/> with a combined level that can never decrease.
/// </summary>
/// <param name="level">The level to set.</param>
/// <returns>This info if <paramref name="level"/> is lower than or equal to this <see cref=Level"/> or a new ReleaseInfo.</returns>
public ReleaseInfo WithLevel(ReleaseLevel level)
{
if (level <= Level)
{
return(this);
}
var c = Constraint;
if (level == ReleaseLevel.BreakingChange)
{
c |= ReleaseConstraint.HasBreakingChanges;
}
else if (level == ReleaseLevel.Feature)
{
c |= ReleaseConstraint.HasFeatures;
}
return(new ReleaseInfo(level, c, Version));
}
/// <summary>
/// This method must choose between possible versions. It may return null to cancel the process.
/// </summary>
/// <param name="m">The monitor to use.</param>
/// <param name="c">The context.</param>
public void ChooseFinalVersion(IActivityMonitor m, IReleaseVersionSelectorContext c)
{
Console.WriteLine("=========");
Console.Write($"======== {c.Solution.Solution.Name} ");
if (c.PreviousVersionCommitSha != null)
{
Console.Write($" last release: {c.PreviousVersion}");
var diffResult = c.GetProjectsDiff(m);
if (diffResult == null)
{
c.Cancel();
return;
}
if (diffResult.Diffs.All(d => d.DiffType == DiffRootResultType.None) && diffResult.Others.DiffType == DiffRootResultType.None)
{
Console.WriteLine($" (No change in {c.Solution.Solution.GeneratedArtifacts.Select( p => p.Artifact.Name ).Concatenate()})");
}
else
{
Console.WriteLine(", changes:");
}
Console.WriteLine(diffResult.ToString());
}
else
{
Console.WriteLine("(No previous released version)");
}
var projExRefNotRelease = c.Solution.Solution.Projects
.Where(p => p.IsPublished && p.PackageReferences.Any(q => q.Kind == ArtifactDependencyKind.Transitive))
.Select(p =>
{
List <PackageReference> pcks = p.PackageReferences
.Where(q => q.Kind == ArtifactDependencyKind.Transitive)
.Where(
q => !c.Solution.ImportedLocalPackages
.Any(s => s.Package.Artifact == q.Target.Artifact)
)
.ToList();
if (pcks.Any())
{
PackageQuality worstQuality = pcks.Select(q => q.Target.Version.PackageQuality).Min();
return(p, pcks.Where(q => q.Target.Version.PackageQuality == worstQuality));
}
p = null;
return(p, Array.Empty <PackageReference>());
}) //There should be at least one package reference
.Where(x => x.p != null)
.GroupBy(p => p.Item2.First().Target.Version.PackageQuality).ToList(); //ugliest LINQ i ever wrote, should take 3 lines.
var min = projExRefNotRelease.Any() ? projExRefNotRelease.Min(q => q.Key) : PackageQuality.None;
var worst = min != PackageQuality.None
? projExRefNotRelease.SingleOrDefault(p => p.Key == min)
: null;
if (worst == null || worst.Key == PackageQuality.Release)
{
Console.WriteLine("Nothing prevent to choose the Release quality.");
}
else
{
var prev = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Best quality is {worst.Key} because of projects:");
foreach (var proj in worst)
{
Console.WriteLine(" => " + proj.p.Name + " caused by packages references " +
string.Join(", ", proj.Item2.Select(p => p.ToString()).ToArray()));
}
Console.ForegroundColor = prev;
}
foreach (var kv in c.PossibleVersions)
{
Console.Write($"= {(int)kv.Key} - {kv.Key} => ");
for (int i = 0; i < kv.Value.Count; i++)
{
CSVersion version = kv.Value[i];
var prev = Console.ForegroundColor;
Console.ForegroundColor = kv.Key != ReleaseLevel.None
? version.PackageQuality > (worst?.Key ?? PackageQuality.Release) ? ConsoleColor.Red : ConsoleColor.Green
: ConsoleColor.White;
Console.Write(version.NormalizedText);
if (i < kv.Value.Count - 1)
{
Console.Write(", ");
}
Console.ForegroundColor = prev;
}
Console.WriteLine();
}
if (c.CanUsePreviouslyResolvedInfo)
{
Console.WriteLine($"= A - Already selected Level and Version: {c.PreviouslyResolvedInfo.Level} - {c.PreviouslyResolvedInfo.Version}");
}
Console.WriteLine("= X - Cancel.");
ReleaseLevel level = ReleaseLevel.None;
char a;
do
{
while ("0123AX".IndexOf((a = Console.ReadKey().KeyChar)) < 0)
{
Console.Write('\b');
}
if (a == 'X')
{
c.Cancel();
}
if (a == 'A')
{
c.SetChoice(c.PreviouslyResolvedInfo.Level, c.PreviouslyResolvedInfo.Version);
}
else
{
level = (ReleaseLevel)(a - '0');
}
}while(!c.IsAnswered && c.PossibleVersions[level].Count == 0);
if (!c.IsAnswered)
{
Console.WriteLine($"= Selected: {level}, now choose a version:");
var possibleVersions = c.PossibleVersions[level];
for (int i = 0; i < possibleVersions.Count; ++i)
{
Console.WriteLine($"= {i} - {possibleVersions[i]}");
}
Console.WriteLine($"= X - Cancel.");
while (!c.IsAnswered)
{
Console.Write($"= (Enter the final release number and press enter)> ");
string line = Console.ReadLine();
if (line == "X")
{
c.Cancel();
}
else if (Int32.TryParse(line, out var num) && num >= 0 && num < possibleVersions.Count)
{
c.SetChoice(level, possibleVersions[num]);
}
Console.WriteLine();
}
}
}
ReleaseInfo(ReleaseLevel l, ReleaseConstraint c, CSVersion v)
{
Level = l;
Constraint = c;
Version = v;
}
/// <summary>
/// Tests whether this <see cref="ReleaseInfo"/> is compatible with a given <see cref="ReleaseLevel"/>
/// and <see cref="ReleaseConstraint"/>.
/// </summary>
/// <param name="l">The minimal level.</param>
/// <param name="c">Constraints that must be satisfied.</param>
/// <returns>True if this ReleaseInfo can be used with this level and constraint.</returns>
public bool IsCompatibleWith(ReleaseLevel l, ReleaseConstraint c)
{
return(Level >= l && (Constraint & c) == c);
}
public bool TryGetValue(ReleaseLevel key, out IReadOnlyList <CSVersion> value)
{
value = _versionList[(int)key];
return(true);
}
public bool ContainsKey(ReleaseLevel key) => true;
public IReadOnlyList <CSVersion> this[ReleaseLevel key] => _versionList[(int)key];
