static PackageDBTests() { T0 = ArtifactType.Register("T0", true); T1 = ArtifactType.Register("T1", true, ';'); T2 = ArtifactType.Register("T2", true, ','); PLevel0V1 = Create(SVersion.Parse("1.0.0")); PLevel0V2 = Create(SVersion.Parse("2.0.0")); PLevel0V3 = Create(SVersion.Parse("3.0.0")); PLevel0V4 = Create(SVersion.Parse("4.0.0")); PLevel0 = new PackageInfo[][] { PLevel0V1, PLevel0V2, PLevel0V3, PLevel0V4 }; PackageInfo[] Create(SVersion v) { var result = new PackageInfo[60]; for (int i = 0; i < result.Length; ++i) { var type = i < (result.Length / 3) ? T0 : i < (2 * result.Length / 3) ? T1 : T2; var p = new PackageInfo(); p.Key = new ArtifactInstance(type, $"P{i}", v); p.FeedNames.Add($"F{i / (result.Length / 10)}"); result[i] = p; } return(result); } }
public void this_is_not_a_csversion(string t) { var v = SVersion.Parse(t); v.AsCSVersion.Should().BeNull(); v.ToNormalizedString().Should().Be(t); }
public void collecting_multiple_versions(string versions, string result) { var v = versions.Split(',').Select(x => SVersion.Parse(x.Trim())).ToArray(); var q = new PackageQualityVersions(v, false); q.ToString().Should().Be(result); }
/// <summary> /// Parses a full path and extracts a <see cref="SVersion"/>. /// </summary> /// <param name="fullPath">The full path of the package.</param> /// <returns>The <see cref="SVersion"/> of the package.</returns> static SVersion ParseVersionFromPackagePath(string fullPath) { var fName = Path.GetFileNameWithoutExtension(fullPath); int idxV = Regex.Match(fName, "\\.\\d").Index; var id = fName.Substring(0, idxV); return(SVersion.Parse(fName.Substring(idxV + 1))); }
/// <summary> /// Parses a full path and extracts a <see cref="LocalNPMPackageFile"/>. /// </summary> /// <param name="fullPath">The full path of the package.</param> /// <returns>The local NPM package file.</returns> public static LocalNPMPackageFile Parse(string fullPath) { var fName = Path.GetFileNameWithoutExtension(fullPath); int idxV = Regex.Match(fName, "-\\d").Index; var id = fName.Substring(0, idxV); var v = SVersion.Parse(fName.Substring(idxV + 1)); return(new LocalNPMPackageFile(fullPath, id, v)); }
public void collecting_best_version(string versions, string result) { var v = versions.Split(',').Select(x => SVersion.Parse(x.Trim())).ToArray(); var q = new PackageQualityVector(v, false); q.ToString().Should().Be(result); q.IsValid.Should().Be(result.Length > 0); q.ActualCount.Should().Be(result.Length > 0 ? 1 : 0); }
/// <summary> /// Adds the <see cref="NPMSolution"/> to the <paramref name="globalInfo"/> /// </summary> /// <param name="this">This global info.</param> /// <param name="solution">The NPM solution.</param> /// <returns>This info.</returns> public static StandardGlobalInfo AddNPM(this StandardGlobalInfo globalInfo, NPMSolution solution) { SVersion minmimalNpmVersionRequired = SVersion.Create(6, 7, 0); string npmVersion = globalInfo.Cake.NpmGetNpmVersion(); if (SVersion.Parse(npmVersion) < minmimalNpmVersionRequired) { globalInfo.Cake.TerminateWithError("Outdated npm. Version older than v6.7.0 are known to fail on publish."); } globalInfo.RegisterSolution(solution); return(globalInfo); }
static IEnumerable <SVersion> GetAllVersionsFromFeed(string path, string packageId) { // Do not use TryParse here: pattern MUST be a version since we remove // .symbols and "sub packages" (like CK.Text.Virtual for CK.Text by filtering only // suffixes that start with a digit. // If an error occurs here it should be an exception since this should never happen. // Note: Max on reference type returns null on empty source. return(System.IO.Directory.EnumerateFiles(path, packageId + ".*.nupkg") .Select(p => System.IO.Path.GetFileName(p)) .Select(n => n.Substring(packageId.Length + 1, n.Length - packageId.Length - 7)) .Where(n => !n.EndsWith(".symbols") && Char.IsDigit(n, 0)) .Select(v => SVersion.Parse(v))); }
public void pre_release_with_standard_names_nugetV2_mappings(string tag, string nuget, bool isPrereleasePatch) { CSVersion fromShortForm = CSVersion.Parse(nuget); CSVersion t = CSVersion.TryParse(tag); Assert.That(t, Is.EqualTo(fromShortForm)); Assert.That(t.IsValid); Assert.That(t.IsPrerelease); Assert.That(t.IsPreReleasePatch, Is.EqualTo(isPrereleasePatch)); Assert.That(t.ToString(CSVersionFormat.LongForm), Is.EqualTo(tag)); Assert.That(t.ToString(CSVersionFormat.Normalized), Is.EqualTo(nuget)); Assert.That(SVersion.Parse(nuget).Prerelease.Length, Is.LessThanOrEqualTo(20)); }
static void DumpVersionInfo(CIBuildDescriptor buildInfo, CSVersion t) { var nugetV2Build = t.ToString(CSVersionFormat.Normalized, buildInfo); int nugetV2BuildSNLen = SVersion.Parse(nugetV2Build).Prerelease.Length; Console.WriteLine("{0}, CI = {1}, NuGet = {2}, NuGet CI = {3}, NugetV2Build.SpecialName.Length = {4}", t, t.ToString(CSVersionFormat.Normalized, buildInfo), t.ToString(CSVersionFormat.Normalized), nugetV2Build, nugetV2BuildSNLen ); Assert.That(nugetV2BuildSNLen, Is.LessThanOrEqualTo(20)); }
internal static CIReleaseInfo Create( Commit commit, CIBranchVersionMode ciVersionMode, string ciBuildName, StringBuilder errors, BasicCommitInfo info) { var actualBaseTag = info?.MaxCommit.ThisTag; CSVersion ciBaseTag = actualBaseTag ?? CSVersion.VeryFirstVersion; SVersion ciBuildVersionNuGet = null, ciBuildVersion = null; // If there is no base release found, we fall back to ZeroTimedBased mode. if (ciVersionMode == CIBranchVersionMode.ZeroTimed || actualBaseTag == null) { DateTime timeRelease = commit.Committer.When.ToUniversalTime().UtcDateTime; string vS = CIBuildDescriptor.CreateSemVerZeroTimed(ciBuildName, timeRelease); string vN = CIBuildDescriptor.CreateShortFormZeroTimed(ciBuildName, timeRelease); if (actualBaseTag != null) { string buildMetaData = "+v" + actualBaseTag; vS += buildMetaData; vN += buildMetaData; } ciBuildVersion = SVersion.Parse(vS); ciBuildVersionNuGet = SVersion.Parse(vN, false); return(new CIReleaseInfo(ciBaseTag, 0, ciBuildVersion, ciBuildVersionNuGet, true)); } Debug.Assert(ciVersionMode == CIBranchVersionMode.LastReleaseBased && actualBaseTag != null); CIBuildDescriptor ci = new CIBuildDescriptor { BranchName = ciBuildName, BuildIndex = info.BelowDepth }; if (!ci.IsValidForShortForm) { errors.AppendLine("Due to ShortForm (NuGet V2 compliance) limitation, the branch name must not be longer than 8 characters. "); errors.Append("Adds a VersionName attribute to the branch element in RepositoryInfo.xml with a shorter name: ") .AppendLine() .Append($@"<Branch Name=""{ci.BranchName}"" VersionName=""{ci.BranchName.Substring( 0, 8 )}"" ... />.") .AppendLine(); } else { ciBuildVersion = SVersion.Parse(actualBaseTag.ToString(CSVersionFormat.Normalized, ci)); ciBuildVersionNuGet = SVersion.Parse(actualBaseTag.ToString(CSVersionFormat.NuGetPackage, ci), false); } Debug.Assert(ciBuildVersion == null || errors.Length == 0); return(ciBuildVersion != null ? new CIReleaseInfo(ciBaseTag, info.BelowDepth, ciBuildVersion, ciBuildVersionNuGet, false) : null); }
public void pre_release_with_standard_names_and_fix_number_nugetV2_mappings(string tag, string nuget) { CSVersion fromShortForm = CSVersion.Parse(nuget); CSVersion t = CSVersion.TryParse(tag); Assert.That(t, Is.EqualTo(fromShortForm)); Assert.That(t.IsValid); Assert.That(t.IsPrerelease); Assert.That(t.IsPreReleasePatch); Assert.That(t.PrereleasePatch, Is.GreaterThan(0)); Assert.That(t.NormalizedText, Is.EqualTo(tag)); Assert.That(t.ToString(CSVersionFormat.NuGetPackage), Is.EqualTo(nuget)); Assert.That(SVersion.Parse(nuget).Prerelease.Length, Is.LessThanOrEqualTo(20)); }
//static int _greatersuccessorCount = 0; CSVersion CheckMapping(long v) { if (v < 0 || v > CSVersion.VeryLastVersion.OrderedVersion) { Assert.Throws <ArgumentException>(() => CSVersion.Create(v)); return(null); } var t = CSVersion.Create(v); Assert.That((v == 0) == !t.IsValid); Assert.That(t.OrderedVersion, Is.EqualTo(v)); var sSemVer = t.NormalizedText; var tSemVer = CSVersion.TryParse(sSemVer); var tNormalized = CSVersion.TryParse(t.ToString(CSVersionFormat.Normalized)); Assert.That(tSemVer.OrderedVersion, Is.EqualTo(v)); Assert.That(tNormalized.OrderedVersion, Is.EqualTo(v)); Assert.That(tNormalized.Equals(t)); Assert.That(tSemVer.Equals(t)); Assert.That(tNormalized.Equals((object)t)); Assert.That(tSemVer.Equals((object)t)); Assert.That(tNormalized.CompareTo(t) == 0); Assert.That(tSemVer == t); Assert.That(tSemVer.ToString(), Is.EqualTo(t.ToString())); Assert.That(tNormalized.ToString(), Is.EqualTo(t.ToString())); // Successors/Predecessors check. var vSemVer = SVersion.Parse(sSemVer); int count = 0; foreach (var succ in t.GetDirectSuccessors(false)) { ++count; Assert.That(succ.IsDirectPredecessor(t)); var vSemVerSucc = SVersion.Parse(succ.NormalizedText); Assert.That(vSemVer < vSemVerSucc, "{0} < {1}", vSemVer, vSemVerSucc); } //if( count > _greatersuccessorCount ) //{ // Console.WriteLine( " -> - found {0} successors for '{1}':", count, t ); // Console.WriteLine( " " + string.Join( ", ", t.GetDirectSuccessors( false ).Select( s => s.ToString() ) ) ); // var closest = t.GetDirectSuccessors( true ).Select( s => s.ToString() ).ToList(); // Console.WriteLine( " - {0} closest successors:", closest.Count, t ); // Console.WriteLine( " " + string.Join( ", ", closest ) ); // _greatersuccessorCount = count; //} return(t); }
public void testing_cibuild_timebased() { var now = DateTime.UtcNow; var more = now.AddSeconds(1); { var sV = CIBuildDescriptor.CreateSemVerZeroTimed("develop", now); var v = SVersion.Parse(sV); v.AsCSVersion.Should().BeNull(); var vMore = SVersion.Parse(CIBuildDescriptor.CreateSemVerZeroTimed("develop", more)); vMore.Should().BeGreaterThan(v); } { var sV = CIBuildDescriptor.CreateShortFormZeroTimed("develop", now); var v = SVersion.Parse(sV); v.AsCSVersion.Should().BeNull(); var vMore = SVersion.Parse(CIBuildDescriptor.CreateShortFormZeroTimed("develop", more)); vMore.Should().BeGreaterThan(v); } }
public int Compare(string x, string y) { var vX = SVersion.Parse(x, handleCSVersion: false); var vY = SVersion.Parse(y, handleCSVersion: false); CheckValid(x); CheckValid(y); Assert.That(vX.Prerelease.Length <= 20, "{0} => PreRelease must not contain more than 20 characters (lenght is {1}).", x, x.Length); Assert.That(vY.Prerelease.Length <= 20, "{0} => PreRelease must not contain more than 20 characters (lenght is {1}).", y, y.Length); int cmp = vX.Major - vY.Major; if (cmp != 0) { return(cmp); } cmp = vX.Minor - vY.Minor; if (cmp != 0) { return(cmp); } cmp = vX.Patch - vY.Patch; if (cmp != 0) { return(cmp); } if (vX.Prerelease.Length == 0 && vY.Prerelease.Length == 0) { return(0); } if (vX.Prerelease.Length == 0) { return(1); } if (vY.Prerelease.Length == 0) { return(-1); } return(StringComparer.InvariantCultureIgnoreCase.Compare(vX.Prerelease, vY.Prerelease)); }
public void pre_release_with_standard_names_and_fix_number_normalized_mappings(string longF, string shortF) { CSVersion tS = CSVersion.Parse(shortF); CSVersion tL = CSVersion.TryParse(longF); Assert.That(tL, Is.EqualTo(tS.ToLongForm())); Assert.That(tS, Is.EqualTo(tL.ToNormalizedForm())); Assert.That(tL.IsValid); Assert.That(tL.IsPrerelease); Assert.That(tL.IsPreReleasePatch); Assert.That(tL.PrereleasePatch, Is.GreaterThan(0)); Assert.That(tL.ToString(CSVersionFormat.Normalized), Is.EqualTo(shortF)); Assert.That(tS.ToString(CSVersionFormat.LongForm), Is.EqualTo(longF)); Assert.That(tS.NormalizedText, Is.EqualTo(shortF)); Assert.That(tL.NormalizedText, Is.EqualTo(longF)); var buildInfo = tS.ToString(CSVersionFormat.Normalized, new CIBuildDescriptor() { BuildIndex = CIBuildDescriptor.MaxBuildIndex, BranchName = "ABCDEFGH" }); Assert.That(SVersion.Parse(buildInfo).Prerelease.Length, Is.LessThanOrEqualTo(20)); }
public void display_versions_and_CI_version(string version, string after) { var buildInfo = new CIBuildDescriptor() { BranchName = "develop", BuildIndex = 15 }; CSVersion v = CSVersion.TryParse(version); string vCI = v.ToString(CSVersionFormat.Normalized, buildInfo); CSVersion vNext = CSVersion.Create(v.OrderedVersion + 1); Console.WriteLine("Version = {0}, CI = {1}, Next = {2}", v, vCI, vNext); var vSemVer = SVersion.Parse(v.ToString(CSVersionFormat.Normalized)); var vCISemVer = SVersion.Parse(vCI); var vNextSemVer = SVersion.Parse(vNext.ToString(CSVersionFormat.Normalized)); Assert.That(vSemVer < vCISemVer, "{0} < {1}", vSemVer, vCISemVer); Assert.That(vCISemVer < vNextSemVer, "{0} < {1}", vCISemVer, vNextSemVer); foreach (var vAfter in after.Split(',').Select(s => SVersion.Parse(s.Trim()))) { Assert.That(vAfter.CompareTo(vCISemVer) > 0, "{0} > {1}", vAfter, vCISemVer); } }
public void CIBuildVersion_LastReleaseBased_are_correctely_ordered(string tag) { var t = CSVersion.TryParse(tag); var v = SVersion.Parse(t.ToString(CSVersionFormat.Normalized)); var tNext = CSVersion.Create(t.OrderedVersion + 1); var vNext = SVersion.Parse(tNext.ToString(CSVersionFormat.Normalized)); var tPrev = CSVersion.Create(t.OrderedVersion - 1); var vPrev = SVersion.Parse(tPrev.ToString(CSVersionFormat.Normalized)); void CheckLower(SVersion v1, SVersion v2) { Assert.That(v1 < v2, "{0} < {1}", v1, v2); Assert.That(v2 > v1, "{0} > {1}", v2, v1); SVersion v1low = SVersion.Parse(v1.ParsedText.ToLowerInvariant()); SVersion v2low = SVersion.Parse(v2.ParsedText.ToLowerInvariant()); Assert.That(v1low < v2low, "{0} < {1} (lowercase)", v1low, v2low); Assert.That(v2low > v1low, "{0} > {1} (lowercase)", v2low, v1low); SVersion v1up = SVersion.Parse(v1.ParsedText.ToUpperInvariant()); SVersion v2up = SVersion.Parse(v2.ParsedText.ToUpperInvariant()); Assert.That(v1up < v2up, "{0} < {1} (uppercase)", v1up, v2up); Assert.That(v2up > v1up, "{0} > {1} (uppercase)", v2up, v1up); } CheckLower(vPrev, v); CheckLower(v, vNext); var sNuGet = t.ToString(CSVersionFormat.NuGetPackage); var sNuGetPrev = tPrev.ToString(CSVersionFormat.NuGetPackage); var sNuGetNext = tNext.ToString(CSVersionFormat.NuGetPackage); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetPrev, sNuGet) < 0, "{0} < {1}", sNuGetPrev, sNuGet); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGet, sNuGetNext) < 0, "{0} < {1}", sNuGet, sNuGetNext); CIBuildDescriptor ci = new CIBuildDescriptor { BranchName = "dev", BuildIndex = 1 }; string sCI = t.ToString(CSVersionFormat.Normalized, ci); SVersion vCi = SVersion.Parse(sCI); CheckLower(v, vCi); CheckLower(vCi, vNext); var sNuGetCI = t.ToString(CSVersionFormat.NuGetPackage, ci); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGet, sNuGetCI) < 0, "{0} < {1}", sNuGet, sNuGetCI); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCI, sNuGetNext) < 0, "{0} < {1}", sNuGetCI, sNuGetNext); string sCiNext = tNext.ToString(CSVersionFormat.Normalized, ci); SVersion vCiNext = SVersion.Parse(sCiNext); CheckLower(vCi, vCiNext); CheckLower(vNext, vCiNext); var sNuGetCINext = tNext.ToString(CSVersionFormat.NuGetPackage, ci); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCINext, sNuGetCI) > 0, "{0} > {1}", sNuGetCINext, sNuGetCI); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCINext, sNuGetNext) > 0, "{0} > {1}", sNuGetCINext, sNuGetNext); string sCiPrev = tPrev.ToString(CSVersionFormat.Normalized, ci); SVersion vCiPrev = SVersion.Parse(sCiPrev); CheckLower(vPrev, vCiPrev); CheckLower(vCiPrev, v); CheckLower(vCiPrev, vCiNext); var sNuGetCIPrev = tPrev.ToString(CSVersionFormat.NuGetPackage, ci); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGetPrev) > 0, "{0} > {1}", sNuGetCIPrev, sNuGetPrev); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGet) < 0, "{0} < {1}", sNuGetCIPrev, sNuGet); Assert.That(NuGetV2StringComparer.DefaultComparer.Compare(sNuGetCIPrev, sNuGetCINext) < 0, "{0} < {1}", sNuGetCIPrev, sNuGetCINext); }
/// <summary> /// Initializes a new <see cref="RepositoryInfo"/> on a <see cref="Repository"/>. /// </summary> /// <param name="r">The rpository (can be invalid and even null).</param> /// <param name="options">Optional options.</param> public RepositoryInfo(Repository r, RepositoryInfoOptions options = null) { Options = options ?? new RepositoryInfoOptions(); CommitDateUtc = InformationalVersion.ZeroCommitDate; if (r == null) { RepositoryError = "No Git repository."; } else { Commit commit; CIBranchVersionMode ciVersionMode; string ciBuildName; RepositoryError = TryFindCommit(options, r, out commit, out ciVersionMode, out ciBuildName); Debug.Assert((ciVersionMode != CIBranchVersionMode.None) == (ciBuildName != null)); if (commit != null) { CommitSha = commit.Sha; CommitDateUtc = commit.Author.When.UtcDateTime; IsDirtyExplanations = ComputeIsDirty(r, commit, options); if (!IsDirty || options.IgnoreDirtyWorkingFolder) { StringBuilder errors = new StringBuilder(); TagCollector collector = new TagCollector(errors, r, options.StartingVersionForCSemVer, options.OverriddenTags, options.SingleMajor); if (errors.Length == 0) { ExistingVersions = collector.ExistingVersions.TagCommits; var info = collector.GetCommitInfo(commit); Debug.Assert(info != null); CommitInfo = info; var rawPossible = info.PossibleVersions; IEnumerable <CSVersion> possibles = rawPossible; if (options.OnlyPatch) { possibles = possibles.Where(v => v.IsPatch); } if (options.SingleMajor.HasValue) { possibles = possibles.Where(v => v.Major == options.SingleMajor.Value); } PossibleVersions = possibles != rawPossible?possibles.ToList() : rawPossible; var rawNextPossible = info.NextPossibleVersions; IEnumerable <CSVersion> nextPossibles = rawNextPossible; if (options.OnlyPatch) { nextPossibles = nextPossibles.Where(v => v.IsPatch); } if (options.SingleMajor.HasValue) { nextPossibles = nextPossibles.Where(v => v.Major == options.SingleMajor.Value); } NextPossibleVersions = nextPossibles != rawNextPossible?nextPossibles.ToList() : rawNextPossible; var thisCommit = info.BasicInfo?.UnfilteredThisCommit; if (info.BasicInfo?.BestCommit?.ThisTag > thisCommit?.ThisTag) { BetterExistingVersion = info.BasicInfo.BestCommit; } if (thisCommit != null) { if (PossibleVersions.Contains(thisCommit.ThisTag)) { ValidReleaseTag = thisCommit.ThisTag; } else { ReleaseTagIsNotPossibleError = true; errors.Append("Release tag '") .Append(thisCommit.ThisTag.ParsedText) .AppendLine("' is not valid here. "); errors.Append("Valid tags are: ") .Append(string.Join(", ", PossibleVersions)) .AppendLine(); if (PossibleVersions != rawPossible && rawPossible.Contains(thisCommit.ThisTag)) { errors.AppendLine("Note: this version is invalid because of <SingleMajor> or <OnlyPatch> setting in RepositoryInfo.xml."); } } } else { // There is no release tag on the commit point. if (ciBuildName != null) { CIRelease = CIReleaseInfo.Create(commit, ciVersionMode, ciBuildName, errors, info.BasicInfo); } } } if (errors.Length > 0) { ReleaseTagError = errors.ToString(); } } // Conclusion: if (CIRelease != null) { //ContentOrFinalNuGetVersion = FinalNuGetVersion = CIRelease.BuildVersionNuGet; FinalSemVersion = CIRelease.BuildVersion; } else if (ValidReleaseTag != null) { FinalNuGetVersion = SVersion.Parse(ValidReleaseTag.ToString(CSVersionFormat.NuGetPackage), false); FinalSemVersion = ValidReleaseTag; } } } // Handles FinalInformationalVersion and SVersion.ZeroVersion for versions if needed. if (FinalSemVersion == null) { FinalSemVersion = SVersion.ZeroVersion; FinalNuGetVersion = SVersion.ZeroVersion; FinalInformationalVersion = InformationalVersion.ZeroInformationalVersion; } else { FinalInformationalVersion = InformationalVersion.BuildInformationalVersion(FinalSemVersion.NormalizedText, FinalNuGetVersion.NormalizedText, CommitSha, CommitDateUtc); } }