public static List <PackageSearchMedatadata> VersionsFor(VersionChange change) { switch (change) { case VersionChange.Major: return(NewMajorVersion() .Concat(MinorVersions()) .Concat(PatchVersions()) .ToList()); case VersionChange.Minor: return(MinorVersions() .Concat(PatchVersions()) .ToList()); case VersionChange.Patch: return(PatchVersions()); case VersionChange.None: return(CurrentVersionOnly()); default: throw new Exception($"Invalid version change {change}"); } }
public async Task <PackageLookupResult> FindVersionUpdate( PackageIdentity package, VersionChange allowedChange) { var foundVersions = await _packageVersionsLookup.Lookup(package.Id); return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange)); }
public async Task <IDictionary <string, PackageLookupResult> > FindVersionUpdates( IEnumerable <PackageIdentity> packages, NuGetSources sources, VersionChange allowedChange, UsePrerelease usePrerelease) { var latestOfEach = packages .GroupBy(pi => pi.Id.ToUpperInvariant()) .Select(HighestVersion); var lookupTasks = latestOfEach .Select(id => _packageLookup.FindVersionUpdate(id, sources, allowedChange, usePrerelease)) .ToList(); await Task.WhenAll(lookupTasks); var result = new Dictionary <string, PackageLookupResult>(StringComparer.OrdinalIgnoreCase); foreach (var lookupTask in lookupTasks) { var serverVersions = lookupTask.Result; ProcessLookupResult(serverVersions, result); } return(result); }
public async Task WhenFromPrereleaseIsAlwaysAllowedAndCurrentVersionIsPrerelease( bool latestPackageIsPrerelease, VersionChange dataRange, int expectedMajor, int expectedMinor, int expectedPatch, string expectedReleaseLabel) { var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch, expectedReleaseLabel); var resultPackages = PackageVersionTestData.VersionsFor(dataRange); if (latestPackageIsPrerelease) { // Only grab updated prerelease packages for this test - otherwise we'll upgrade to 2.3.4 instead of 2.3.4-prerelease resultPackages = resultPackages.Where(x => x.Identity.Version.IsPrerelease).ToList(); } var allVersionsLookup = MockVersionLookup(resultPackages); IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup); var updates = await lookup.FindVersionUpdate( CurrentVersion123Prerelease("TestPackage"), NuGetSources.GlobalFeed, VersionChange.Major, UsePrerelease.Always); AssertPackagesIdentityIs(updates, "TestPackage"); Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate)); Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages))); }
private static PackageSearchMetadata FirstMatch( IList <PackageSearchMetadata> candidates, NuGetVersion current, VersionChange allowedChange) { return(candidates.FirstOrDefault(p => Filter(current, p.Identity.Version, allowedChange))); }
public async Task <IDictionary <PackageIdentity, PackageLookupResult> > FindVersionUpdates( IEnumerable <PackageIdentity> packages, NuGetSources sources, VersionChange allowedChange, UsePrerelease usePrerelease ) { var lookupTasks = packages .Distinct() .GroupBy(pi => (pi.Id, MaxVersion: GetMaxVersion(pi, allowedChange))) .Select(HighestVersion) .Select(id => new { Package = id, Update = _packageLookup.FindVersionUpdate(id, sources, allowedChange, usePrerelease) }) .ToList(); await Task.WhenAll(lookupTasks.Select(l => l.Update)); var result = new Dictionary <PackageIdentity, PackageLookupResult>(); foreach (var lookupTask in lookupTasks) { ProcessLookupResult(lookupTask.Package, lookupTask.Update.Result, result); } return(result); }
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindUpdatesForPackages( IReadOnlyCollection <PackageInProject> packages, NuGetSources sources, VersionChange allowedChange) { var packageIds = packages .Select(p => p.Identity) .Distinct(); var latestVersions = await _bulkPackageLookup.FindVersionUpdates( packageIds, sources, allowedChange); var results = new List <PackageUpdateSet>(); foreach (var packageId in latestVersions.Keys) { var latestPackage = latestVersions[packageId]; var matchVersion = latestPackage.Selected().Identity.Version; var updatesForThisPackage = packages .Where(p => p.Id == packageId && p.Version < matchVersion) .ToList(); if (updatesForThisPackage.Count > 0) { var updateSet = new PackageUpdateSet(latestPackage, updatesForThisPackage); results.Add(updateSet); } } return(results); }
private void SetUpdateText() { VersionHelper helper = new VersionHelper(); VersionChange change = helper.GetChanges(helper.CurrentVersion); this.Text = $"Neuigkeiten zu Version {helper.CurrentVersion}"; lbNews.Text = change.GetChanges(); }
private static string GetMaxVersion(PackageIdentity pi, VersionChange allowedChange) { return(allowedChange switch { VersionChange.Major => "X.X.X", VersionChange.Minor => $"{pi.Version.Major}.X.X", VersionChange.Patch => $"{pi.Version.Major}.{pi.Version.Minor}.X", VersionChange.None => $"{pi.Version.Major}.{pi.Version.Minor}.{pi.Version.Patch}", _ => throw new ArgumentOutOfRangeException(nameof(allowedChange)), });
public async Task <PackageLookupResult> FindVersionUpdate( PackageIdentity package, NuGetSources sources, VersionChange allowedChange) { var allowBetas = package.Version.IsPrerelease; var foundVersions = await _packageVersionsLookup.Lookup(package.Id, allowBetas, sources); return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange)); }
private async Task<IReadOnlyCollection<PackageUpdateSet>> GetSortedUpdates( IFolder folder, NuGetSources sources, VersionChange allowedChange) { var updates = await _updateFinder.FindPackageUpdateSets( folder, sources, allowedChange); return _sorter.Sort(updates) .ToList(); }
public PackageLookupResult( VersionChange allowedChange, PackageSearchMetadata major, PackageSearchMetadata minor, PackageSearchMetadata patch) { AllowedChange = allowedChange; Major = major; Minor = minor; Patch = patch; }
public async Task <PackageLookupResult> FindVersionUpdate( PackageIdentity package, NuGetSources sources, VersionChange allowedChange, UsePrerelease usePrerelease) { var includePrerelease = ShouldAllowPrerelease(package, usePrerelease); var foundVersions = await _packageVersionsLookup.Lookup(package.Id, includePrerelease, sources); return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange)); }
private async Task <IReadOnlyCollection <PackageUpdateSet> > GetSortedUpdates( IFolder folder, NuGetSources sources, VersionChange allowedChange, UsePrerelease usePrerelease, Regex includes, Regex excludes) { var updates = await _updateFinder.FindPackageUpdateSets( folder, sources, allowedChange, usePrerelease, includes, excludes); return(_sorter.Sort(updates) .ToList()); }
public static PackageLookupResult MakeVersions( NuGetVersion current, IEnumerable <PackageSearchMetadata> candidateVersions, VersionChange allowedChange) { var orderedCandidates = candidateVersions .OrderByDescending(p => p.Identity.Version) .ToList(); var major = FirstMatch(orderedCandidates, current, VersionChange.Major); var minor = FirstMatch(orderedCandidates, current, VersionChange.Minor); var patch = FirstMatch(orderedCandidates, current, VersionChange.Patch); return(new PackageLookupResult(allowedChange, major, minor, patch)); }
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets( IFolder workingFolder, NuGetSources sources, VersionChange allowedChange) { var packages = FindPackages(workingFolder); _logger.Log(PackagesFoundLogger.Log(packages)); // look for updates to these packages var updates = await _packageUpdatesLookup.FindUpdatesForPackages( packages, sources, allowedChange); _logger.Log(UpdatesLogger.Log(updates)); return(updates); }
public async Task WhenPatchVersionChangesAreAllowed(VersionChange dataRange, int expectedMajor, int expectedMinor, int expectedPatch) { var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch); var resultPackages = PackageVersionTestData.VersionsFor(dataRange); var allVersionsLookup = MockVersionLookup(resultPackages); IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup); var updates = await lookup.FindVersionUpdate(CurrentVersion123("TestPackage"), VersionChange.Patch); AssertPackagesIdentityIs(updates, "TestPackage"); Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate)); Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages))); }
private static PackageLookupResult GetPackageLookupResult( PackageIdentity package, VersionChange versionChange ) { var packageName = package.Id; var major = package.Version.Major; var minor = package.Version.Minor; var patch = package.Version.Patch; return(new PackageLookupResult( versionChange, MakePackageSearchMetadata(packageName, $"{major + 1}.0.0"), MakePackageSearchMetadata(packageName, $"{major}.{minor+1}.0"), MakePackageSearchMetadata(packageName, $"{major}.{minor}.{patch+1}") )); }
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets( IFolder workingFolder, NuGetSources sources, VersionChange allowedChange) { // scan for nuget packages var packages = _repositoryScanner.FindAllNuGetPackages(workingFolder) .ToList(); _logger.Log(PackagesFoundLogger.Log(packages)); // look for updates to these packages var updates = await _packageUpdatesLookup.FindUpdatesForPackages( packages, sources, allowedChange); _logger.Log(UpdatesLogger.Log(updates)); return(updates); }
private static bool Filter(NuGetVersion v1, NuGetVersion v2, VersionChange allowedChange) { switch (allowedChange) { case VersionChange.Major: return(true); case VersionChange.Minor: return(v1.Major == v2.Major); case VersionChange.Patch: return((v1.Major == v2.Major) && (v1.Minor == v2.Minor)); case VersionChange.None: return(v1 == v2); default: throw new NuKeeperException($"Unknown version change {allowedChange}"); } }
public async Task WhenFromPrereleaseIsNeverAllowedAndCurrentVersionIsStable( VersionChange dataRange, int expectedMajor, int expectedMinor, int expectedPatch, string expectedReleaseLabel) { var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch, expectedReleaseLabel); var resultPackages = PackageVersionTestData.VersionsFor(dataRange); var allVersionsLookup = MockVersionLookup(resultPackages); IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup); var updates = await lookup.FindVersionUpdate( CurrentVersion123("TestPackage"), NuGetSources.GlobalFeed, VersionChange.Major, UsePrerelease.Never); AssertPackagesIdentityIs(updates, "TestPackage"); Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate)); Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages))); }
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets( IFolder workingFolder, NuGetSources sources, VersionChange allowedChange, UsePrerelease usePrerelease, Regex includes = null, Regex excludes = null) { var packages = FindPackages(workingFolder); _logger.Normal($"Found {packages.Count} packages"); var filtered = FilteredByIncludeExclude(packages, includes, excludes); _logger.Log(PackagesFoundLogger.Log(filtered)); // look for updates to these packages var updates = await _packageUpdatesLookup.FindUpdatesForPackages( filtered, sources, allowedChange, usePrerelease); _logger.Log(UpdatesLogger.Log(updates)); return(updates); }
public async Task <Dictionary <string, PackageLookupResult> > FindVersionUpdates( IEnumerable <PackageIdentity> packages, VersionChange allowedChange) { var latestOfEach = packages .GroupBy(pi => pi.Id) .Select(HighestVersion); var lookupTasks = latestOfEach .Select(id => _packageLookup.FindVersionUpdate(id, allowedChange)) .ToList(); await Task.WhenAll(lookupTasks); var result = new Dictionary <string, PackageLookupResult>(); foreach (var lookupTask in lookupTasks) { var serverVersions = lookupTask.Result; ProcessLookupResult(serverVersions, result); } return(result); }
//--- Constructors ---- public VersionDiff(VersionChange change, VersionSeverity severity) { Change = change; Severity = severity; }
//--- Constructors ---- public VersionDiff(VersionChange change, VersionSeverity severity) { Change = change; Severity = severity; }
public PackageUpdatesLookup(IBulkPackageLookup bulkPackageLookup, UserSettings settings) { _bulkPackageLookup = bulkPackageLookup; _allowedChange = settings.AllowedChange; }