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); }