private static void Process(FileInfo file, string id, VersionRange version) { Console.WriteLine(file.FullName); var json = JObject.Parse(File.ReadAllText(file.FullName)); var found = false; foreach (var dependency in SpecUtility.GetDependencies(json)) { var packageDependency = SpecUtility.GetDependency(dependency); if (packageDependency.Id.Equals(id, StringComparison.OrdinalIgnoreCase)) { var orig = dependency.Value.ToString(); if (orig != version.OriginalString) { Console.WriteLine($"{dependency.Value.ToString()} -> {version.OriginalString}"); dependency.Value = version.OriginalString; found = true; } } } if (found) { File.WriteAllText(file.FullName, json.ToString(), Encoding.UTF8); } }
public async Task <IEnumerable <NuGetVersion> > DownloadPackagesAsync( IEnumerable <string> sources, IEnumerable <string> ids, NuGetVersionRange versionRange, SourceCacheContext sourceCacheContext, ILogger log, CancellationToken token) { var versions = await GetAvailableVersionsAsync(sources, ids, log, token); var limitedVersions = versions .Where(x => versionRange.Satisfies(x)); var identities = ids .SelectMany(id => limitedVersions.Select(version => new PackageIdentity(id, version))); await _packageRangeDownloader.DownloadPackagesAsync( sources, identities, sourceCacheContext, log, token); return(versions); }
/// <summary> /// Retrieve dependency info for a single package. /// </summary> /// <param name="package">package id and version</param> /// <param name="projectFramework">project target framework. This is used for finding the dependency group</param> /// <param name="token">cancellation token</param> /// <returns> /// Returns dependency info for the given package if it exists. If the package is not found null is /// returned. /// </returns> public override async Task<SourcePackageDependencyInfo> ResolvePackage(PackageIdentity package, NuGetFramework projectFramework, CancellationToken token) { try { SourcePackageDependencyInfo result = null; // Construct the registration index url var uri = _regResource.GetUri(package.Id); // Retrieve the registration blob var singleVersion = new VersionRange(minVersion: package.Version, includeMinVersion: true, maxVersion: package.Version, includeMaxVersion: true); var regInfo = await ResolverMetadataClient.GetRegistrationInfo(_client, uri, singleVersion, projectFramework, token); // regInfo is null if the server returns a 404 for the package to indicate that it does not exist if (regInfo != null) { // Parse package and dependeny info from the blob result = GetPackagesFromRegistration(regInfo, token).FirstOrDefault(); } return result; } catch (Exception ex) { // Wrap exceptions coming from the server with a user friendly message var error = String.Format(CultureInfo.CurrentUICulture, Strings.Protocol_PackageMetadataError, package, _source); throw new NuGetProtocolException(error, ex); } }
/// <summary> /// Retrieve the <see cref="RemoteSourceDependencyInfo" /> for a registration. /// </summary> /// <returns>Returns an empty sequence if the package does not exist.</returns> public static async Task<IEnumerable<RemoteSourceDependencyInfo>> GetDependencies( HttpClient httpClient, Uri registrationUri, VersionRange range, CancellationToken token) { var ranges = await Utils.LoadRanges(httpClient, registrationUri, range, token); var results = new HashSet<RemoteSourceDependencyInfo>(); foreach (var rangeObj in ranges) { if (rangeObj == null) { throw new InvalidDataException(registrationUri.AbsoluteUri); } foreach (JObject packageObj in rangeObj["items"]) { var catalogEntry = (JObject)packageObj["catalogEntry"]; var version = NuGetVersion.Parse(catalogEntry["version"].ToString()); if (range.Satisfies(version)) { results.Add(ProcessPackageVersion(packageObj, version, range.IncludePrerelease)); } } } return results; }
public void VersionRange_Exact() { // Act var versionInfo = new VersionRange(new NuGetVersion(4, 3, 0), true, new NuGetVersion(4, 3, 0), true, false); // Assert Assert.True(versionInfo.Satisfies(NuGetVersion.Parse("4.3.0"))); }
public void ParseVersionRangeNoPrerelease() { // Act var versionInfo = new VersionRange(minVersion: new NuGetVersion("1.2-Alpha"), includePrerelease: false); // Assert Assert.False(versionInfo.IncludePrerelease); }
public string GetBestLockFilePath(string packageId, VersionRange versionRange, NuGetFramework framework) { var availableToolVersions = GetAvailableToolVersions(packageId); var bestVersion = versionRange.FindBestMatch(availableToolVersions); return GetLockFilePath(packageId, bestVersion, framework); }
public static string RenderVersion(VersionRange range) { if (range == null) { return null; } if (range.MinVersion == range.MaxVersion && (range.Float == null || range.Float.FloatBehavior == NuGetVersionFloatBehavior.None)) { return range.MinVersion.ToNormalizedString(); } var sb = new StringBuilder(); sb.Append(">= "); switch (range?.Float?.FloatBehavior) { case null: case NuGetVersionFloatBehavior.None: sb.Append(range.MinVersion.ToNormalizedString()); break; case NuGetVersionFloatBehavior.Prerelease: // Work around nuget bug: https://github.com/NuGet/Home/issues/1598 // sb.AppendFormat("{0}-*", range.MinVersion); sb.Append($"{range.MinVersion.Version.Major}.{range.MinVersion.Version.Minor}.{range.MinVersion.Version.Build}"); if (string.IsNullOrEmpty(range.MinVersion.Release) || string.Equals("-", range.MinVersion.Release)) { sb.Append($"-*"); } else { sb.Append($"-{range.MinVersion.Release}*"); } break; case NuGetVersionFloatBehavior.Revision: sb.Append($"{range.MinVersion.Version.Major}.{range.MinVersion.Version.Minor}.{range.MinVersion.Version.Build}.*"); break; case NuGetVersionFloatBehavior.Patch: sb.Append($"{range.MinVersion.Version.Major}.{range.MinVersion.Version.Minor}.*"); break; case NuGetVersionFloatBehavior.Minor: sb.AppendFormat($"{range.MinVersion.Version.Major}.*"); break; case NuGetVersionFloatBehavior.Major: sb.AppendFormat("*"); break; default: break; } if (range.MaxVersion != null) { sb.Append(range.IsMaxInclusive ? " <= " : " < "); sb.Append(range.MaxVersion); } return sb.ToString(); }
/// <summary> /// Creates a new packages config entry /// </summary> /// <param name="identity">Package id and version</param> /// <param name="targetFramework">Package target framework installed to the project</param> /// <param name="userInstalled">True if the user installed this package directly</param> /// <param name="developmentDependency">True if the package is a development dependency</param> /// <param name="requireReinstallation">True if this package needs to be reinstalled</param> /// <param name="allowedVersions">Restrict package versions to the allowedVersions range</param> public PackageReference(PackageIdentity identity, NuGetFramework targetFramework, bool userInstalled, bool developmentDependency, bool requireReinstallation, VersionRange allowedVersions) { _identity = identity; _allowedVersions = allowedVersions; _targetFramework = targetFramework; _developmentDependency = developmentDependency; _userInstalled = userInstalled; _requireReinstallation = requireReinstallation; }
public void ParseVersionRangeParts(NuGetVersion min, NuGetVersion max, bool minInc, bool maxInc) { // Act var versionInfo = new VersionRange(min, minInc, max, maxInc); // Assert Assert.Equal(min, versionInfo.MinVersion, VersionComparer.Default); Assert.Equal(max, versionInfo.MaxVersion, VersionComparer.Default); Assert.Equal(minInc, versionInfo.IsMinInclusive); Assert.Equal(maxInc, versionInfo.IsMaxInclusive); }
/// <summary> /// Initialise a new insatnce of <see cref="ReadSnippetError"/>. /// </summary> public ReadSnippetError(VersionRange version, string key, int line, string file, string message) { Guard.AgainstNegativeAndZero(line, "line"); Guard.AgainstNullAndEmpty(key, "key"); Guard.AgainstNullAndEmpty(message, "message"); Version = version; Key = key; Line = line; File = file; Message = message; }
public void ParseVersionRangeToStringReParse(NuGetVersion min, NuGetVersion max, bool minInc, bool maxInc) { // Act var original = new VersionRange(min, minInc, max, maxInc); var versionInfo = VersionRange.Parse(original.ToString()); // Assert Assert.Equal(min, versionInfo.MinVersion, VersionComparer.Default); Assert.Equal(max, versionInfo.MaxVersion, VersionComparer.Default); Assert.Equal(minInc, versionInfo.IsMinInclusive); Assert.Equal(maxInc, versionInfo.IsMaxInclusive); }
public void AddPackageReference (string id, string version, VersionRange versionRange = null) { var packageId = new PackageIdentity (id, new NuGetVersion (version)); var packageReference = new PackageReference ( packageId, new NuGetFramework ("net45"), true, false, false, versionRange ); InstalledPackages.Add (packageReference); }
internal static IVersionSpec SafeToVerSpec(VersionRange versionRange) { if (versionRange == null) { return null; } return new VersionSpec() { IsMaxInclusive = versionRange.IsMaxInclusive, IsMinInclusive = versionRange.IsMinInclusive, MaxVersion = SafeToSemanticVersion(versionRange.MaxVersion), MinVersion = SafeToSemanticVersion(versionRange.MinVersion) }; }
/// <summary> /// Retrieves all the package and all dependant packages /// </summary> public override async Task<IEnumerable<PackageDependencyInfo>> ResolvePackages(IEnumerable<PackageIdentity> packages, NuGetFramework projectFramework, bool includePrerelease, CancellationToken token) { // compare results based on the id/version HashSet<PackageDependencyInfo> results = new HashSet<PackageDependencyInfo>(PackageIdentity.Comparer); foreach (var package in packages) { var range = new VersionRange(package.Version, true, package.Version, true); foreach (var result in await GetPackagesFromRegistration(package.Id, range, projectFramework, token)) { results.Add(result); } } return results.Where(e => includePrerelease || !e.Version.IsPrerelease); }
/// <summary> /// Initialise a new insatnce of <see cref="ReadSnippet"/>. /// </summary> public ReadSnippet(int startLine, int endLine, string value, string key, string language, string file, VersionRange version) { Guard.AgainstNullAndEmpty(key, "key"); Guard.AgainstUpperCase(key, "key"); Guard.AgainstNull(language, "language"); Guard.AgainstUpperCase(language, "language"); Guard.AgainstNegativeAndZero(startLine, "startLine"); Guard.AgainstNegativeAndZero(endLine, "endLine"); StartLine = startLine; EndLine = endLine; Value = value; ValueHash = value.RemoveWhitespace().GetHashCode(); Key = key; Language = language; File = file; Version = version; }
public override async Task<IEnumerable<UIPackageMetadata>> GetMetadata(IEnumerable<PackageIdentity> packages, CancellationToken token) { var results = new List<UIPackageMetadata>(); // group by id to optimize foreach (var group in packages.GroupBy(e => e.Id, StringComparer.OrdinalIgnoreCase)) { var versions = group.OrderBy(e => e.Version, VersionComparer.VersionRelease); // find the range of versions we need var range = new VersionRange(versions.First().Version, true, versions.Last().Version, true, true); var metadataList = await _regResource.GetPackageMetadata(group.Key, range, true, true, token); results.AddRange(metadataList.Select(item => ParseMetadata(item))); } return results; }
public async static Task<IEnumerable<JObject>> LoadRanges( HttpClient httpClient, Uri registrationUri, VersionRange range, CancellationToken token) { var index = await LoadResource(httpClient, registrationUri, token); if (index == null) { // The server returned a 404, the package does not exist return Enumerable.Empty<JObject>(); } var preFilterRange = Utils.SetIncludePrerelease(range, true); IList<Task<JObject>> rangeTasks = new List<Task<JObject>>(); foreach (JObject item in index["items"]) { var lower = NuGetVersion.Parse(item["lower"].ToString()); var upper = NuGetVersion.Parse(item["upper"].ToString()); if (IsItemRangeRequired(preFilterRange, lower, upper)) { JToken items; if (!item.TryGetValue("items", out items)) { var rangeUri = item["@id"].ToObject<Uri>(); rangeTasks.Add(LoadResource(httpClient, rangeUri, token)); } else { rangeTasks.Add(Task.FromResult(item)); } } } await Task.WhenAll(rangeTasks.ToArray()); return rangeTasks.Select((t) => t.Result); }
/// <summary> /// Returns inlined catalog entry items for each registration blob /// </summary> /// <remarks>The inlined entries are potentially going away soon</remarks> public virtual async Task<IEnumerable<JObject>> GetPackageMetadata(string packageId, VersionRange range, bool includePrerelease, bool includeUnlisted, CancellationToken token) { var results = new List<JObject>(); var registrationUri = GetUri(packageId); var ranges = await Utils.LoadRanges(_client, registrationUri, range, token); foreach (var rangeObj in ranges) { if (rangeObj == null) { throw new InvalidDataException(registrationUri.AbsoluteUri); } foreach (JObject packageObj in rangeObj["items"]) { var catalogEntry = (JObject)packageObj["catalogEntry"]; var version = NuGetVersion.Parse(catalogEntry["version"].ToString()); var listedToken = catalogEntry["listed"]; var listed = (listedToken != null) ? listedToken.Value<bool>() : true; if (range.Satisfies(version) && (includePrerelease || !version.IsPrerelease) && (includeUnlisted || listed)) { // add in the download url if (packageObj["packageContent"] != null) { catalogEntry["packageContent"] = packageObj["packageContent"]; } results.Add(catalogEntry); } } } return results; }
public static bool TryParseVersion(string stringVersion, out VersionRange parsedVersion) { if (stringVersion == "all") { parsedVersion = VersionRange.All; return true; } int intversion; if (int.TryParse(stringVersion, out intversion)) { var semanticVersion = new NuGetVersion(intversion, 0, 0); parsedVersion = new VersionRange( minVersion: semanticVersion, includeMinVersion: true, maxVersion: new NuGetVersion(intversion + 1, 0, 0), includeMaxVersion: false ); return true; } return VersionRange.TryParse(stringVersion, out parsedVersion); }
private static async Task DownloadAsync( List <string> sources, AlignedVersionsDownloader alignedVersionDownloader, SourceCacheContext sourceCacheContext, ILogger log) { await alignedVersionDownloader.DownloadPackagesAsync( sources, ToolsFactory.PackageIds2x, VersionRange.Parse("[2.5.0, )", allowFloating: false), sourceCacheContext, log, CancellationToken.None); await alignedVersionDownloader.DownloadPackagesAsync( sources, ToolsFactory.PackageIds3x, VersionRange.All, sourceCacheContext, log, CancellationToken.None); }
public string GetBestLockFilePath(string packageId, VersionRange versionRange, NuGetFramework framework) { if (versionRange == null) { throw new ArgumentNullException(nameof(versionRange)); } if (framework == null) { throw new ArgumentNullException(nameof(framework)); } var availableToolVersions = GetAvailableToolVersions(packageId); var bestVersion = versionRange.FindBestMatch(availableToolVersions); if (bestVersion == null) { throw new GracefulException($"Version for package `{packageId}` could not be resolved."); } return GetLockFilePath(packageId, bestVersion, framework); }
private static string Format(char c, VersionRange range) { string s = null; switch (c) { case 'P': s = PrettyPrint(range); break; case 'L': s = range.HasLowerBound ? String.Format(new VersionFormatter(), "{0:N}", range.MinVersion) : string.Empty; break; case 'U': s = range.HasUpperBound ? String.Format(new VersionFormatter(), "{0:N}", range.MaxVersion) : string.Empty; break; case 'N': s = GetToString(range); break; } return s; }
public async Task DependencyInfo_XunitRetrieveDependencies() { // Arrange var repo = Repository.Factory.GetCoreV2("https://www.nuget.org/api/v2/"); var resource = await repo.GetResourceAsync<DependencyInfoResource>(); var package = new PackageIdentity("xunit", NuGetVersion.Parse("2.1.0-beta1-build2945")); // filter to keep this test consistent var filterRange = new VersionRange(NuGetVersion.Parse("2.0.0-rc4-build2924"), true, NuGetVersion.Parse("2.1.0-beta1-build2945"), true); // Act var results = await resource.ResolvePackages("xunit", NuGetFramework.Parse("net45"), CancellationToken.None); var filtered = results.Where(result => filterRange.Satisfies(result.Version)); var target = filtered.Single(p => PackageIdentity.Comparer.Equals(p, package)); // Assert Assert.Equal(3, filtered.Count()); Assert.Equal(2, target.Dependencies.Count()); Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.core").VersionRange.ToNormalizedString()); Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.assert").VersionRange.ToNormalizedString()); }
public DisplayVersion( VersionRange range, string additionalInfo) { Range = range; _additionalInfo = additionalInfo; Version = range.MinVersion; // Display a single version if the range is locked if (range.HasLowerAndUpperBounds && range.MinVersion == range.MaxVersion) { _toString = string.IsNullOrEmpty(_additionalInfo) ? Version.ToNormalizedString() : _additionalInfo + " " + Version.ToNormalizedString(); } else { // Display the range, use the original value for floating ranges _toString = string.IsNullOrEmpty(_additionalInfo) ? Range.OriginalString : _additionalInfo + " " + Range.OriginalString; } }
/// <summary> /// A pretty print representation of the VersionRange. /// </summary> private string PrettyPrint(VersionRange range) { StringBuilder sb = new StringBuilder("("); // no upper if (range.HasLowerBound && !range.HasUpperBound) { sb.Append(GreaterThanOrEqualTo); sb.AppendFormat(_versionFormatter, " {0:N}", range.MinVersion); } // single version else if (range.HasLowerAndUpperBounds && range.MaxVersion.Equals(range.MinVersion) && range.IsMinInclusive && range.IsMaxInclusive) { sb.AppendFormat(_versionFormatter, "= {0:N}", range.MinVersion); } else // normal range { if (range.HasLowerBound) { if (range.IsMinInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", GreaterThanOrEqualTo); } else { sb.Append("> "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MinVersion); } if (range.HasLowerAndUpperBounds) { sb.Append(" && "); } if (range.HasUpperBound) { if (range.IsMaxInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", LessThanOrEqualTo); } else { sb.Append("< "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MaxVersion); } } sb.Append(")"); // avoid () if (sb.Length == 2) { sb.Clear(); } return(sb.ToString()); }
/// <summary> /// Returns the smallest range that includes all given ranges. /// </summary> public static VersionRange Combine(IEnumerable <VersionRange> ranges, IVersionComparer comparer) { if (ranges == null) { throw new ArgumentNullException(nameof(ranges)); } if (comparer == null) { throw new ArgumentNullException(nameof(comparer)); } // Default to None for empty lists var result = None; // Remove zero width ranges. Ex: (1.0.0, 1.0.0) // This includes VersionRange.None and any other ranges that satisfy zero versions ranges = ranges.Where(range => HasValidRange(range)); if (ranges.Any()) { var rangeComparer = new VersionRangeComparer(comparer); // start with the first range in the list var first = ranges.First(); var lowest = first.MinVersion; var highest = first.MaxVersion; // To keep things consistent set min/max inclusive to false when there is no boundary // It is possible to denote an inclusive range with no bounds, but it has no useful meaning for combine var includeLowest = first.IsMinInclusive && first.HasLowerBound; var includeHighest = first.IsMaxInclusive && first.HasUpperBound; // expand the range to inclue all other ranges foreach (var range in ranges.Skip(1)) { // once we have an unbounded lower we can stop checking if (lowest != null) { if (range.HasLowerBound) { var lowerCompare = comparer.Compare(range.MinVersion, lowest); if (lowerCompare < 0) { // A new lowest was found lowest = range.MinVersion; includeLowest = range.IsMinInclusive; } else if (lowerCompare == 0) { // The lower ends are identical, update the inclusiveness includeLowest |= range.IsMinInclusive; } // lowerCompare > 0 falls into the current range, this is a no-op } else { // No lower bound lowest = null; includeLowest = false; } } // null is the highest we can get, stop checking once it is hit if (highest != null) { if (range.HasUpperBound) { var higherCompare = comparer.Compare(range.MaxVersion, highest); if (higherCompare > 0) { // A new highest was found highest = range.MaxVersion; includeHighest = range.IsMaxInclusive; } else if (higherCompare == 0) { // The higher ends are identical, update the inclusiveness includeHighest |= range.IsMaxInclusive; } // higherCompare < 0 falls into the current range, this is a no-op } else { // No higher bound highest = null; includeHighest = false; } } } // Create the new range using the maximums found result = new VersionRange(lowest, includeLowest, highest, includeHighest); } return(result); }
/// <summary> /// Helper for finding all versions of a package and all dependencies. /// </summary> private async Task<IEnumerable<PackageDependencyInfo>> GetPackagesFromRegistration(string packageId, VersionRange range, NuGetFramework projectFramework, CancellationToken cancellationToken) { HashSet<PackageDependencyInfo> results = new HashSet<PackageDependencyInfo>(PackageIdentity.Comparer); Uri uri = _regResource.GetUri(packageId); try { var regInfo = await ResolverMetadataClient.GetRegistrationInfo(_client, uri, range, projectFramework, _cache); var result = await ResolverMetadataClient.GetTree(_client, regInfo, projectFramework, _cache); foreach (var currentPackage in GetPackagesFromRegistration(result, cancellationToken)) { results.Add(currentPackage); } } catch (ArgumentException) { // ignore missing packages // TODO: add an exception type for missing packages to be thrown in the metadata client } return results; }
public async Task GetUpdatedPackages_OnePackageReferencedWithConstraintAndUpdatesAvailable_LatestVersionReturnedBasedOnConstraint () { CreateUpdatedPackagesInWorkspace (); FakeNuGetProject project = AddNuGetProjectToSolution (); var versionRange = new VersionRange ( minVersion: new NuGetVersion ("1.0"), includeMinVersion: true, maxVersion: new NuGetVersion ("2.0"), includeMaxVersion: true); project.AddPackageReference ("Test", "1.0", versionRange); var package = packageMetadataResource.AddPackageMetadata ("Test", "2.0").Identity; packageMetadataResource.AddPackageMetadata ("Test", "3.0"); var expectedPackages = new [] { package }; await CheckForUpdates (); var updatedPackages = updatedPackagesInWorkspace.GetUpdatedPackages (dotNetProject); CollectionAssert.AreEqual (expectedPackages, updatedPackages.GetPackages ()); }
/// <summary> /// Parses a VersionRange from its string representation. /// </summary> public static bool TryParse(string value, out VersionRange versionRange) { return(TryParse(value, true, out versionRange)); }
public PackageDependencyMetadata(string id, VersionRange range) { Id = id; Range = range; }
/// <summary> /// Parses a VersionRange from its string representation. /// </summary> public static bool TryParse(string value, bool allowFloating, out VersionRange versionRange) { if (value == null) { throw new ArgumentNullException(nameof(value)); } versionRange = null; var trimmedValue = value.Trim(); var charArray = trimmedValue.ToCharArray(); // * is the only range below 3 chars if (allowFloating && charArray.Length == 1 && charArray[0] == '*') { versionRange = new VersionRange(null, true, null, true, new FloatRange(NuGetVersionFloatBehavior.Major), originalString: value); return(true); } // Fail early if the string is too short to be valid if (charArray.Length < 3) { return(false); } string minVersionString = null; string maxVersionString = null; var isMinInclusive = false; var isMaxInclusive = false; NuGetVersion minVersion = null; NuGetVersion maxVersion = null; FloatRange floatRange = null; if (charArray[0] == '(' || charArray[0] == '[') { // The first character must be [ to ( switch (charArray[0]) { case '[': isMinInclusive = true; break; case '(': isMinInclusive = false; break; default: return(false); } // The last character must be ] ot ) switch (charArray[charArray.Length - 1]) { case ']': isMaxInclusive = true; break; case ')': isMaxInclusive = false; break; default: return(false); } // Get rid of the two brackets trimmedValue = trimmedValue.Substring(1, trimmedValue.Length - 2); // Split by comma, and make sure we don't get more than two pieces var parts = trimmedValue.Split(','); if (parts.Length > 2) { return(false); } else { var allEmpty = true; for (int i = 0; i < parts.Length; i++) { if (!string.IsNullOrEmpty(parts[i])) { allEmpty = false; break; } } // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,] if (allEmpty) { return(false); } } // If there is only one piece, we use it for both min and max minVersionString = parts[0]; maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; } else { // default to min inclusive when there are no braces isMinInclusive = true; // use the entire value as the version minVersionString = trimmedValue; } if (!String.IsNullOrWhiteSpace(minVersionString)) { // parse the min version string if (allowFloating && minVersionString.Contains("*")) { // single floating version if (FloatRange.TryParse(minVersionString, out floatRange) && floatRange.HasMinVersion) { minVersion = floatRange.MinVersion; } else { // invalid float return(false); } } else { // single non-floating version if (!NuGetVersion.TryParse(minVersionString, out minVersion)) { // invalid version return(false); } } } // parse the max version string, the max cannot float if (!String.IsNullOrWhiteSpace(maxVersionString)) { if (!NuGetVersion.TryParse(maxVersionString, out maxVersion)) { // invalid version return(false); } } // Successful parse! versionRange = new VersionRange( minVersion: minVersion, includeMinVersion: isMinInclusive, maxVersion: maxVersion, includeMaxVersion: isMaxInclusive, floatRange: floatRange, originalString: value); return(true); }
/// <summary> /// Clones a version range and applies a new float range. /// </summary> public VersionRange(VersionRange range, FloatRange floatRange) : this(range.MinVersion, range.IsMinInclusive, range.MaxVersion, range.IsMaxInclusive, floatRange) { }
/// <summary> /// Find the version that best matches the VersionRange and the floating behavior. /// </summary> public static INuGetVersionable FindBestMatch(this IEnumerable <INuGetVersionable> items, VersionRange ideal) { return(FindBestMatch <INuGetVersionable>(items, ideal, (e => e.Version))); }
public static async Task<IPackageSearchMetadata> GetLatestPackageMetadataAsync( this SourceRepository sourceRepository, string packageId, bool includePrerelease, CancellationToken cancellationToken, VersionRange allowedVersions) { var metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>(cancellationToken); var packages = await metadataResource?.GetMetadataAsync( packageId, includePrerelease, false, Common.NullLogger.Instance, cancellationToken); // filter packages based on allowed versions var updatedPackages = packages.Where(p => allowedVersions.Satisfies(p.Identity.Version)); var highest = updatedPackages .OrderByDescending(e => e.Identity.Version, VersionComparer.VersionRelease) .FirstOrDefault(); return highest?.WithVersions(ToVersionInfo(packages, includePrerelease)); }
private static VersionRange AggregateVersions(VersionRange aggregate, VersionRange next) { var versionRange = new VersionRange(); SetMinVersion(ref versionRange, aggregate); SetMinVersion(ref versionRange, next); SetMaxVersion(ref versionRange, aggregate); SetMaxVersion(ref versionRange, next); if (versionRange.MinVersion == null && versionRange.MaxVersion == null) { versionRange = null; } return versionRange; }
/// <summary> /// Parses a VersionRange from its string representation. /// </summary> public static bool TryParse(string value, bool allowFloating, out VersionRange versionRange) { versionRange = null; var trimmedValue = value?.Trim(); if (string.IsNullOrEmpty(trimmedValue)) { return(false); } var charArray = trimmedValue.ToCharArray(); // * is the only 1 char range if (allowFloating && charArray.Length == 1 && charArray[0] == '*') { versionRange = new VersionRange(new NuGetVersion(0, 0, 0), true, null, true, FloatRange.Parse(trimmedValue), originalString: value); return(true); } string minVersionString = null; string maxVersionString = null; var isMinInclusive = false; var isMaxInclusive = false; NuGetVersion minVersion = null; NuGetVersion maxVersion = null; FloatRange floatRange = null; if (charArray[0] == '(' || charArray[0] == '[') { // The first character must be [ to ( switch (charArray[0]) { case '[': isMinInclusive = true; break; case '(': isMinInclusive = false; break; default: return(false); } // The last character must be ] ot ) switch (charArray[charArray.Length - 1]) { case ']': isMaxInclusive = true; break; case ')': isMaxInclusive = false; break; default: return(false); } // Get rid of the two brackets trimmedValue = trimmedValue.Substring(1, trimmedValue.Length - 2); // Split by comma, and make sure we don't get more than two pieces var parts = trimmedValue.Split(','); if (parts.Length > 2) { return(false); } else { var allEmpty = true; for (int i = 0; i < parts.Length; i++) { if (!string.IsNullOrEmpty(parts[i])) { allEmpty = false; break; } } // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,] if (allEmpty) { return(false); } } // (1.0.0] and [1.0.0),(1.0.0) are invalid. if (parts.Length == 1 && !(isMinInclusive && isMaxInclusive)) { return(false); } // If there is only one piece, we use it for both min and max minVersionString = parts[0]; maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; } else { // default to min inclusive when there are no braces isMinInclusive = true; // use the entire value as the version minVersionString = trimmedValue; } if (!string.IsNullOrWhiteSpace(minVersionString)) { // parse the min version string if (allowFloating && minVersionString.Contains("*")) { // single floating version if (FloatRange.TryParse(minVersionString, out floatRange) && floatRange.HasMinVersion) { minVersion = floatRange.MinVersion; } else { // invalid float return(false); } } else { // single non-floating version if (!NuGetVersion.TryParse(minVersionString, out minVersion)) { // invalid version return(false); } } } // parse the max version string, the max cannot float if (!string.IsNullOrWhiteSpace(maxVersionString)) { if (!NuGetVersion.TryParse(maxVersionString, out maxVersion)) { // invalid version return(false); } } if (minVersion != null && maxVersion != null) { int result = minVersion.CompareTo(maxVersion); // minVersion > maxVersion if (result > 0) { return(false); } // minVersion is equal to maxVersion (1.0.0, 1.0.0], [1.0.0, 1.0.0) if (result == 0 && (isMinInclusive ^ isMaxInclusive)) { return(false); } } // Successful parse! versionRange = new VersionRange( minVersion: minVersion, includeMinVersion: isMinInclusive, maxVersion: maxVersion, includeMaxVersion: isMaxInclusive, floatRange: floatRange, originalString: value); return(true); }
private static void SetMaxVersion(ref VersionRange target, VersionRange source) { if (source == null || source.MaxVersion == null) { return; } bool update = false; NuGetVersion maxVersion = target.MaxVersion; bool includeMaxVersion = target.IsMaxInclusive; if (target.MaxVersion == null) { update = true; maxVersion = source.MaxVersion; includeMaxVersion = source.IsMaxInclusive; } if (target.MaxVersion > source.MaxVersion) { update = true; maxVersion = source.MaxVersion; includeMaxVersion = source.IsMaxInclusive; } if (target.MaxVersion == source.MaxVersion) { update = true; includeMaxVersion = target.IsMaxInclusive && source.IsMaxInclusive; } if (update) { target = new VersionRange(target.MinVersion, target.IsMinInclusive, maxVersion, includeMaxVersion, target.IncludePrerelease, target.Float, target.OriginalString); } }
private string GetVersionRangeNormalizedString(string input) { return(NuGetVersionRange.Parse(input).ToNormalizedString()); }
public static void PopulateDependencies(ProjectContext context, PackageBuilder packageBuilder) { var dependencies = new List<PackageDependency>(); var project = context.RootProject; foreach (var dependency in project.Dependencies) { if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency)) { continue; } // TODO: Efficiency var dependencyDescription = context.LibraryManager.GetLibraries().First(l => l.RequestedRanges.Contains(dependency)); // REVIEW: Can we get this far with unresolved dependencies if (dependencyDescription == null || !dependencyDescription.Resolved) { continue; } if (dependencyDescription.Identity.Type == LibraryType.Project && ((ProjectDescription)dependencyDescription).Project.EmbedInteropTypes) { continue; } if (dependency.Target == LibraryType.ReferenceAssembly) { packageBuilder.FrameworkAssemblies.Add(new FrameworkAssemblyReference(dependency.Name, new[] { context.TargetFramework })); Reporter.Verbose.WriteLine($"Adding framework assembly {dependency.Name.Yellow()}"); } else { VersionRange dependencyVersion = null; if (dependency.VersionRange == null || dependency.VersionRange.IsFloating) { dependencyVersion = new VersionRange(dependencyDescription.Identity.Version); } else { dependencyVersion = dependency.VersionRange; } Reporter.Verbose.WriteLine($"Adding dependency {dependency.Name.Yellow()} {VersionUtility.RenderVersion(dependencyVersion).Yellow()}"); dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion)); } } packageBuilder.DependencySets.Add(new PackageDependencySet(context.TargetFramework, dependencies)); }