public async Task <ArtifactAvailableInstances> GetVersionsAsync(IActivityMonitor m, string artifactName)
{
if (_registry == null)
{
_registry = _registryFactory();
}
var v = new ArtifactAvailableInstances(this, artifactName);
var result = await _registry.View(m, artifactName);
if (result.exist)
{
JObject body = JObject.Parse(result.viewJson);
var versions = (JObject)body["versions"];
foreach (var vK in versions)
{
var sV = SVersion.TryParse(vK.Key);
if (!sV.IsValid)
{
m.Warn($"Unable to parse version '{vK.Key}' for '{artifactName}': {sV.ErrorMessage}");
}
else
{
v = v.WithVersion(sV);
}
}
}
return(v);
}
public void WithBuildMetaData_works_on_SVersion_and_CSVersion()
{
SVersion sv = SVersion.TryParse("1.0.0-not.a.CSemVer.Version");
SVersion svc = SVersion.TryParse("1.0.0-alpha");
SVersion svnc = SVersion.TryParse("1.0.0-pre", handleCSVersion: false);
Assert.That(sv, Is.Not.AssignableTo <CSVersion>());
Assert.That(sv.AsCSVersion, Is.Null);
Assert.That(svc, Is.AssignableTo <CSVersion>());
Assert.That(svc.AsCSVersion, Is.SameAs(svc));
Assert.That(svnc, Is.Not.AssignableTo <CSVersion>());
Assert.That(svnc.AsCSVersion, Is.Not.Null);
SVersion svB = sv.WithBuildMetaData("Test");
Assert.That(svB, Is.Not.AssignableTo <CSVersion>());
Assert.That(svB.AsCSVersion, Is.Null);
Assert.That(svB.NormalizedTextWithBuildMetaData, Is.EqualTo("1.0.0-not.a.CSemVer.Version+Test"));
SVersion svcB = svc.WithBuildMetaData("Test");
Assert.That(svcB, Is.AssignableTo <CSVersion>());
Assert.That(svcB.AsCSVersion, Is.SameAs(svcB));
Assert.That(svcB.NormalizedTextWithBuildMetaData, Is.EqualTo("1.0.0-alpha+Test"));
SVersion svncB = svnc.WithBuildMetaData("Test");
Assert.That(svncB, Is.Not.AssignableTo <CSVersion>());
Assert.That(svncB.AsCSVersion, Is.Not.Null);
Assert.That(svncB.NormalizedTextWithBuildMetaData, Is.EqualTo("1.0.0-pre+Test"));
Assert.That(svncB.AsCSVersion.NormalizedTextWithBuildMetaData, Is.EqualTo("1.0.0-prerelease+Test"));
}
public void CSemVerSafeCompare_in_action(string left, char op, string right)
{
SVersion vL = left != null?SVersion.TryParse(left) : null;
SVersion vR = right != null?SVersion.TryParse(right) : null;
switch (op)
{
case '>':
SVersion.CSemVerSafeCompare(vL, vR).Should().BePositive();
SVersion.CSemVerSafeCompare(vR, vL).Should().BeNegative();
break;
case '<':
SVersion.CSemVerSafeCompare(vL, vR).Should().BeNegative();
SVersion.CSemVerSafeCompare(vR, vL).Should().BePositive();
break;
case '=':
SVersion.CSemVerSafeCompare(vL, vR).Should().Be(0);
SVersion.CSemVerSafeCompare(vR, vL).Should().Be(0);
break;
default: throw new ArgumentException(nameof(op));
}
}
public void the_Zero_SVersion_is_lower_than_any_other_syntaxically_valid_SVersion(string version)
{
var v = SVersion.TryParse(version);
Assert.That(v.IsValid);
Assert.That(v > SVersion.ZeroVersion);
Assert.That(v != SVersion.ZeroVersion);
}
public CheckRepositoryInfo(SimpleRepositoryInfo gitInfo, IEnumerable <SolutionProject> projectsToPublish)
{
GitInfo = gitInfo;
Version = SVersion.TryParse(gitInfo.SafeNuGetVersion);
if (Version.IsValid)
{
NuGetPackagesToPublish = projectsToPublish.Select(p => new SimplePackageId(p.Name, Version)).ToList();
}
}
public void Syntaxically_invalid_SVersion_are_greater_than_null_and_lower_than_the_Zero_one(string invalid)
{
SVersion notV = SVersion.TryParse(invalid);
Assert.That(!notV.IsValid);
Assert.That(notV != SVersion.ZeroVersion);
Assert.That(SVersion.ZeroVersion > notV);
Assert.That(SVersion.ZeroVersion >= notV);
}
public void parsing_works_on_prefix_and_ParsedText_covers_the_version(string t, string parsedText)
{
var head = t.AsSpan();
var v = SVersion.TryParse(ref head);
v.IsValid.Should().BeTrue();
v.ErrorMessage.Should().BeNull();
v.ParsedText.Should().Be(parsedText);
t.Should().StartWith(v.ParsedText);
}
/// <summary>
/// Simple parse of the "Type:Name/Version" format that may return an invalid
/// instance (see <see cref="IsValid"/>).
/// This never throws.
/// </summary>
/// <param name="instanceName">The string to parse.</param>
/// <returns>The resulting instance that may be invalid.</returns>
public static ArtifactInstance TryParse(string instanceName)
{
int idx = instanceName.LastIndexOf('/');
if (idx > 0 &&
idx < instanceName.Length - 3 &&
SVersion.TryParse(instanceName.Substring(idx + 1), out var version) &&
Core.Artifact.TryParse(instanceName.Substring(0, idx), out var artifact))
{
return(new ArtifactInstance(artifact, version));
}
return(new ArtifactInstance());
}
static SVersion SafeParse(IActivityMonitor m, string path)
{
SVersion v = null;
int idx = path.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
if (idx < 0)
{
m.Error($"Invalid path '{path}' for package.");
}
else if (!(v = SVersion.TryParse(path.Substring(idx))).IsValid)
{
m.Error($"Invalid SemVer in '{path}' for package.");
}
return(v);
}
/// <summary>
/// Simple parse of the "Name/Version" format that may return an invalid
/// instance (see <see cref="IsValid"/>).
/// This never throws.
/// </summary>
/// <param name="instanceName">The string to parse.</param>
/// <returns>The resulting instance that may be invalid.</returns>
public static VFeature TryParse(string instanceName)
{
int idx = instanceName?.LastIndexOf('/') ?? 0;
if (idx > 0 &&
idx < instanceName !.Length - 3 &&
SVersion.TryParse(instanceName.Substring(idx + 1), out var version))
{
var n = instanceName.Substring(0, idx);
if (!String.IsNullOrWhiteSpace(n))
{
return(new VFeature(n, version));
}
}
return(new VFeature());
}
async Task <ArtifactAvailableInstances> GetAvailable(MetadataResource meta, NuGetLoggerAdapter logger, string name)
{
var v = new ArtifactAvailableInstances(this, name);
var latest = await meta.GetVersions(name, true, false, _feed.Client.SourceCache, logger, CancellationToken.None);
foreach (var nugetVersion in latest)
{
var vText = nugetVersion.ToNormalizedString();
var sV = SVersion.TryParse(vText);
if (!sV.IsValid)
{
logger.Monitor.Warn($"Unable to parse version '{vText}' for '{name}': {sV.ErrorMessage}");
}
else
{
v = v.WithVersion(sV);
}
}
return(v);
}
public static (bool Locked, SVersion Version) TryParseSimpleRange(IActivityMonitor m, string r)
{
SVersion v = SVersion.TryParse(r);
if (!v.IsValid &&
r != null && r.Length > 3)
{
if (r[0] == '[' && r[r.Length - 1] == ']')
{
return(true, SVersion.TryParse(r.Substring(1, r.Length - 2)));
}
string[] numbers = r.Split('.');
if (numbers.Length == 4)
{
m.Warn($"Old Version in format X.Y.Z.A :'{r}', removing last number to parse it, new version:'{numbers[0]}.{numbers[1]}.{numbers[2]}'");
v = SVersion.Create(int.Parse(numbers[0]), int.Parse(numbers[1]), int.Parse(numbers[2]));
}
}
return(false, v);
}
internal static SVersion GetVersionOutOfTarballPath(string path, string packageName)
{
path = Path.GetFileNameWithoutExtension(path);
path = path.Remove(packageName.Length + 1); //remove the package name
return(SVersion.TryParse(path));
}
public void version_to_quality_mapping(string version, PackageQuality q)
{
SVersion.TryParse(version).PackageQuality.Should().Be(q);
}
