public static IPackage Latest(this IEnumerable<IPackage> values, IVersionSpec spec) { var candidates = values.ToArray(); var candidate = candidates.FirstOrDefault(x => x.IsAbsoluteLatestVersion) ?? candidates.FirstOrDefault(x => x.IsLatestVersion); if (candidate == null) { // If both absolute and latest are false, then we order in descending order (by version) and take the top var ordered = candidates .OrderByDescending(x => x.Version) .ToArray(); if (spec == null) { candidate = ordered.FirstOrDefault(); } else { Func<IPackage, bool> predicate; if (spec.IsMaxInclusive) { predicate = x => x.Version <= spec.MaxVersion; } else { predicate = x => x.Version < spec.MaxVersion; } candidate = ordered.FirstOrDefault(predicate); } } return candidate; }
public void GetPackage(string packageId, IVersionSpec version) { /* if (repositoryRemote == null) { //var repositoryRemote = PackageRepositoryFactory.Default.CreateRepository("https://nuget.org/api/v2"); repositoryRemote = PackageRepositoryFactory.Default.CreateRepository(@"C:\Dev\Tools\NuGetFeed"); } if (repositoryLocal == null) { repositoryLocal = GetLocalRepository(); } */ var packageInfo = FindPackage(packageId, version, false, false); if (packageInfo == null) throw new NotImplementedException(); var localRepository = _repositories[0]; if (localRepository != packageInfo.Item1) { localRepository.AddPackage(packageInfo.Item2); } foreach (var deps in packageInfo.Item2.DependencySets) { foreach (var dep in deps.Dependencies) { GetPackage(dep.Id, dep.VersionSpec); } } }
public static bool Matches(IVersionSpec versionSpec, SemanticVersion version) { if (versionSpec == null) return true; // I CAN'T DEAL WITH THIS bool minVersion; if (versionSpec.MinVersion == null) { minVersion = true; // no preconditon? LET'S DO IT } else if (versionSpec.IsMinInclusive) { minVersion = version >= versionSpec.MinVersion; } else { minVersion = version > versionSpec.MinVersion; } bool maxVersion; if (versionSpec.MaxVersion == null) { maxVersion = true; // no preconditon? LET'S DO IT } else if (versionSpec.IsMaxInclusive) { maxVersion = version <= versionSpec.MaxVersion; } else { maxVersion = version < versionSpec.MaxVersion; } return maxVersion && minVersion; }
public DependencyInfo(FullPackageName fullName, IVersionSpec versionSpec) { FullName = fullName; // Default to the simple version (which means min-version) VersionSpec = versionSpec ?? VersionUtility.ParseVersionSpec(FullName.Version.ToString()); }
public PackageDependency(string id, IVersionSpec versionSpec) { if (String.IsNullOrEmpty(id)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "id"); } Id = id; VersionSpec = versionSpec; }
public PackageDependency(string id, IVersionSpec versionSpec) { if (String.IsNullOrEmpty(id)) { throw new ArgumentNullException("id"); } Id = id; VersionSpec = versionSpec; }
internal static VersionRange SafeToVerRange(IVersionSpec spec) { if(spec == null) { return null; } return new VersionRange( SafeToNuGetVer(spec.MinVersion), spec.IsMinInclusive, SafeToNuGetVer(spec.MaxVersion), spec.IsMaxInclusive); }
// The version string is either a simple version or an arithmetic range // e.g. // 1.0 --> 1.0 ≤ x // (,1.0] --> x ≤ 1.0 // (,1.0) --> x < 1.0 // [1.0] --> x == 1.0 // (1.0,) --> 1.0 < x // (1.0, 2.0) --> 1.0 < x < 2.0 // [1.0, 2.0] --> 1.0 ≤ x ≤ 2.0 public Package(string packageId, string versionSpec = null, bool allowPrereleaseVersions = false, bool allowUnlisted = false) { if (packageId == null) { throw new ArgumentNullException("packageId"); } if (string.IsNullOrWhiteSpace(packageId)) { throw new ArgumentException("packageId"); } _packageId = packageId; _versionSpec = string.IsNullOrWhiteSpace(versionSpec) ? null : VersionUtility.ParseVersionSpec(versionSpec); _allowPrereleaseVersions = allowPrereleaseVersions; _allowUnlisted = allowUnlisted; }
public Dependency(string name, IVersionSpec versionSpec) : this(name) { if (versionSpec.MinVersion != null && versionSpec.MaxVersion != null && versionSpec.MinVersion == versionSpec.MaxVersion) { Mode = UpdateMode.Fixed; Version = versionSpec.MinVersion.Version.ToString(); } else { Mode = UpdateMode.Float; } _versionSpec = versionSpec; }
public AzureVersionSpec(IVersionSpec version) { this.IsMaxInclusive = version.IsMaxInclusive; this.IsMinInclusive = version.IsMinInclusive; if (version.MaxVersion != null) { this.MaxVersionSpecial = version.MaxVersion.SpecialVersion; this.MaxVersionVersion = version.MaxVersion.Version.ToString(); } if (version.MinVersion != null) { this.MinVersionSpecial = version.MinVersion.SpecialVersion; this.MinVersionVersion = version.MinVersion.Version.ToString(); } }
/// <summary> /// Enumerates the required package requests. /// </summary> /// <param name="packageId"> /// The package id. /// </param> /// <param name="version"> /// The version. /// </param> /// <returns> /// An enumeration of package requests. /// </returns> public IEnumerable<SolutionPackageRequest> EnumPackageRequests(string packageId, IVersionSpec version) { if (packageId.EndsWith(Constants.SolutionPackagePostFix, StringComparison.CurrentCultureIgnoreCase)) { var packageRequest = SolutionPackageRequestFactory.CreatePackageRequest(packageId, version); if (packageRequest != null) { yield return packageRequest; foreach (var dependencySet in packageRequest.Package.DependencySets) { foreach (var dependency in dependencySet.Dependencies) { foreach (var request in this.EnumPackageRequests(dependency.Id, dependency.VersionSpec)) { yield return request; } } } } } }
internal IEnumerable <PackageItem> GetPackageByIdAndVersionSpec(string name, IVersionSpec versionSpec, bool allowUnlisted = false) { if (String.IsNullOrEmpty(name)) { return(Enumerable.Empty <PackageItem>()); } return(SelectedSources.AsParallel().WithMergeOptions(ParallelMergeOptions.NotBuffered).SelectMany(source => { var pkgs = source.Repository.FindPackages(name, versionSpec, AllowPrereleaseVersions, allowUnlisted); /* * // necessary? * pkgs = from p in pkgs where p.IsLatestVersion select p; */ var pkgs2 = pkgs.ToArray(); return pkgs2.Select(pkg => new PackageItem { Package = pkg, PackageSource = source, FastPath = MakeFastPath(source, pkg.Id, pkg.Version.ToString()) }); }).OrderByDescending(each => each.Package.Version)); }
private static void SetMaxVersion(VersionSpec target, IVersionSpec source) { if (source == null || source.MaxVersion == null) { return; } if (target.MaxVersion == null) { target.MaxVersion = source.MaxVersion; target.IsMaxInclusive = source.IsMaxInclusive; } if (target.MaxVersion > source.MaxVersion) { target.MaxVersion = source.MaxVersion; target.IsMaxInclusive = source.IsMaxInclusive; } if (target.MaxVersion == source.MaxVersion) { target.IsMaxInclusive = target.IsMaxInclusive && source.IsMaxInclusive; } }
public static Func <T, bool> ToDelegate <T>(this IVersionSpec versionInfo, Func <T, SemanticVersion> extractor) { if (versionInfo == null) { throw new ArgumentNullException("versionInfo"); } if (extractor == null) { throw new ArgumentNullException("extractor"); } return(delegate(T p) { SemanticVersion version = extractor(p); bool flag = true; if (versionInfo.MinVersion != null) { flag = !versionInfo.IsMinInclusive ? (flag && (version > versionInfo.MinVersion)) : (flag && (version >= versionInfo.MinVersion)); } if (versionInfo.MaxVersion != null) { flag = !versionInfo.IsMaxInclusive ? (flag && (version < versionInfo.MaxVersion)) : (flag && (version <= versionInfo.MaxVersion)); } return flag; }); }
public static bool TryParseVersionSpec(string value, out IVersionSpec result) { if (value == null) { throw new ArgumentNullException("value"); } var versionSpec = new VersionSpec(); value = value.Trim(); // First, try to parse it as a plain version string SemanticVersion version; if (SemanticVersion.TryParse(value, out version)) { // A plain version is treated as an inclusive minimum range result = new VersionSpec { MinVersion = version, IsMinInclusive = true }; return(true); } // It's not a plain version, so it must be using the bracket arithmetic range syntax result = null; // Fail early if the string is too short to be valid if (value.Length < 3) { return(false); } // The first character must be [ ot ( switch (value.First()) { case '[': versionSpec.IsMinInclusive = true; break; case '(': versionSpec.IsMinInclusive = false; break; default: return(false); } // The last character must be ] ot ) switch (value.Last()) { case ']': versionSpec.IsMaxInclusive = true; break; case ')': versionSpec.IsMaxInclusive = false; break; default: return(false); } // Get rid of the two brackets value = value.Substring(1, value.Length - 2); // Split by comma, and make sure we don't get more than two pieces string[] parts = value.Split(','); if (parts.Length > 2) { return(false); } else if (parts.All(String.IsNullOrEmpty)) { // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,] return(false); } // If there is only one piece, we use it for both min and max string minVersionString = parts[0]; string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; // Only parse the min version if it's non-empty if (!String.IsNullOrWhiteSpace(minVersionString)) { if (!TryParseVersion(minVersionString, out version)) { return(false); } versionSpec.MinVersion = version; } // Same deal for max if (!String.IsNullOrWhiteSpace(maxVersionString)) { if (!TryParseVersion(maxVersionString, out version)) { return(false); } versionSpec.MaxVersion = version; } // Successful parse! result = versionSpec; return(true); }
/// <summary> /// Stolen from NuGet codebase. /// </summary> /// <param name="versionInfo"></param> /// <returns></returns> public static Func <IPackage, bool> ToDelegate(this IVersionSpec versionInfo) { return(versionInfo.ToDelegate <IPackage>(p => p.Version)); }
public virtual async Task <IHttpActionResult> GetUpdates( ODataQueryOptions <ODataPackage> options, [FromODataUri] string packageIds, [FromODataUri] string versions, [FromODataUri] bool includePrerelease, [FromODataUri] bool includeAllVersions, [FromODataUri] string targetFrameworks = "", [FromODataUri] string versionConstraints = "", [FromUri] string semVerLevel = "", CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(packageIds) || string.IsNullOrEmpty(versions)) { return(Ok(Enumerable.Empty <ODataPackage>().AsQueryable())); } // Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client. // Can probably eventually be retired (when nobody uses 2.1 anymore...) // Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because // space characters are never acepted as valid by VersionUtility.ParseFrameworkName. if (!string.IsNullOrEmpty(targetFrameworks)) { targetFrameworks = targetFrameworks.Replace(' ', '+'); } var idValues = packageIds.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var versionValues = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks) ? null : targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList(); var versionConstraintValues = (String.IsNullOrEmpty(versionConstraints) ? new string[idValues.Length] : versionConstraints.Split('|')).ToList(); if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Count) { // Exit early if the request looks invalid return(Ok(Enumerable.Empty <ODataPackage>().AsQueryable())); } var packagesToUpdate = new List <IPackageMetadata>(); for (var i = 0; i < idValues.Length; i++) { if (SemanticVersion.TryParse(versionValues[i], out var semVersion)) { packagesToUpdate.Add(new PackageBuilder { Id = idValues[i], Version = semVersion }); } else { versionConstraintValues.RemoveAt(i); } } var versionConstraintsList = new IVersionSpec[versionConstraintValues.Count]; for (var i = 0; i < versionConstraintsList.Length; i++) { if (!String.IsNullOrEmpty(versionConstraintValues[i])) { VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraintsList[i]); } } var clientCompatibility = ClientCompatibilityFactory.FromProperties(semVerLevel); var sourceQuery = await _serverRepository.GetUpdatesAsync( packagesToUpdate, includePrerelease, includeAllVersions, targetFrameworkValues, versionConstraintsList, clientCompatibility, token); return(TransformToQueryResult(options, sourceQuery, clientCompatibility)); }
public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool allowUnlisted) { IEnumerable <IPackage> packages = repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted); if (constraintProvider != null) { packages = DependencyResolveUtility.FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions); } return(packages.FirstOrDefault <IPackage>()); }
/// <summary> /// Attempts to parse a string with a version spec in NuGet format. /// See http://docs.nuget.org/docs/reference/versioning /// </summary> /// <param name="s"> /// String to parse. /// </param> /// <param name="result"> /// The version spec, or null if the input string does not contain a valid NuGet version spec. /// </param> /// <returns> /// True if the input string contains a valid version spec. False otherwise. /// </returns> public static bool TryParseNuGet(string s, out IVersionSpec result) { if (s == null) { throw new ArgumentNullException("value"); } var versionSpec = new VersionSpec(); s = s.Trim(); // First, try to parse it as a plain version string SemanticVersion version; if (SemanticVersion.TryParseNuGet(s, out version)) { // A plain version is treated as an inclusive minimum range result = new VersionSpec { MinVersion = version, IsMinInclusive = true }; return true; } // It's not a plain version, so it must be using the bracket arithmetic range syntax result = null; // Fail early if the string is too short to be valid if (s.Length < 3) { return false; } // The first character must be [ ot ( if (s.StartsWith("[")) { versionSpec.IsMinInclusive = true; } else if (s.StartsWith("(")) { versionSpec.IsMinInclusive = false; } else { return false; } // The last character must be ] ot ) if (s.EndsWith("]")) { versionSpec.IsMaxInclusive = true; } else if (s.EndsWith(")")) { versionSpec.IsMaxInclusive = false; } else { return false; } // Get rid of the two brackets s = s.Substring(1, s.Length - 2); // Split by comma, and make sure we don't get more than two pieces string[] parts = s.Split(','); if (parts.Length > 2) { return false; } else if (parts.All(p=>String.IsNullOrEmpty(p))) { // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,] return false; } // If there is only one piece, we use it for both min and max string minVersionString = parts[0]; string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; // Only parse the min version if it's non-empty if (!String.IsNullOrWhiteSpace(minVersionString)) { if (!SemanticVersion.TryParseNuGet(minVersionString, out version)) { return false; } versionSpec.MinVersion = version; } // Same deal for max if (!String.IsNullOrWhiteSpace(maxVersionString)) { if (!SemanticVersion.TryParseNuGet(maxVersionString, out version)) { return false; } versionSpec.MaxVersion = version; } // Successful parse! result = versionSpec; return true; }
public IQueryable <V2FeedPackage> GetUpdates( string packageIds, string versions, bool includePrerelease, bool includeAllVersions, string targetFrameworks, string versionConstraints) { if (String.IsNullOrEmpty(packageIds) || String.IsNullOrEmpty(versions)) { return(Enumerable.Empty <V2FeedPackage>().AsQueryable()); } // Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client. Can probably eventually be retired (when nobody uses 2.1 anymore...) // Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because // space characters are never acepted as valid by VersionUtility.ParseFrameworkName. if (!string.IsNullOrEmpty(targetFrameworks)) { targetFrameworks = targetFrameworks.Replace(' ', '+'); } var idValues = packageIds.Trim().ToLowerInvariant().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var versionValues = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks) ? null : targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList(); var versionConstraintValues = String.IsNullOrEmpty(versionConstraints) ? new string[idValues.Length] : versionConstraints.Split('|'); if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length) { // Exit early if the request looks invalid return(Enumerable.Empty <V2FeedPackage>().AsQueryable()); } var versionLookup = idValues.Select((id, i) => { SemanticVersion currentVersion = null; if (SemanticVersion.TryParse(versionValues[i], out currentVersion)) { IVersionSpec versionConstraint = null; if (versionConstraintValues[i] != null) { if (!VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraint)) { versionConstraint = null; } } return(Tuple.Create(id, Tuple.Create(currentVersion, versionConstraint))); } return(null); }) .Where(t => t != null) .ToLookup(t => t.Item1, t => t.Item2, StringComparer.OrdinalIgnoreCase); var packages = PackageRepository.GetAll() .Include(p => p.PackageRegistration) .Include(p => p.SupportedFrameworks) .Where(p => p.Listed && (includePrerelease || !p.IsPrerelease) && idValues.Contains(p.PackageRegistration.Id.ToLower())) .OrderBy(p => p.PackageRegistration.Id); return(GetUpdates(packages, versionLookup, targetFrameworkValues, includeAllVersions).AsQueryable() .ToV2FeedPackageQuery(GetSiteRoot(), Configuration.Features.FriendlyLicenses)); }
IPackage matchPackage(IPackageRepository packageRepository, string id, IVersionSpec version) { return packageRepository.FindPackagesById(id).FirstOrDefault(x => VersionComparer.Matches(version, x.Version)); }
private void UpdatePackageReference(IProjectManager projectManager, string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions) { RunProjectAction(projectManager, () => projectManager.UpdatePackageReference(packageId, versionSpec, updateDependencies, allowPrereleaseVersions)); }
private List <NuGetPackageInfo> ResolveDependencies(string packageId, IVersionSpec packageVersionSpec, IEnumerable <IPackageRepository> packageRepositories) { Log.Debug("Resolving dependencies for package '{0}'", packageId); var packagesToRetrieve = new List <NuGetPackageInfo>(); IPackage packageToInstall = null; foreach (var packageRepository in packageRepositories) { try { var query = packageRepository.GetPackages().Where(x => x.Id.Equals(packageId, StringComparison.CurrentCultureIgnoreCase)); // TODO: optimize performance here //if (packageVersionSpec.MinVersion != null) //{ // foreach (var version in x.Version.Get) // query = query.Where(x => x.Version.GetComparableVersionStrings() >= packageVersionSpec.MinVersion.V); //} //if (packageVersionSpec.MaxVersion != null) //{ // query = query.Where(x => x.Version <= packageVersionSpec.MaxVersion); //} // Note: FirstOrDefault not supported on GetPackages() var possiblePackages = query.ToList().OrderBy(x => x.Version); packageToInstall = (from possiblePackage in possiblePackages where (packageVersionSpec.MinVersion == null || possiblePackage.Version >= packageVersionSpec.MinVersion) && (packageVersionSpec.MaxVersion == null || possiblePackage.Version <= packageVersionSpec.MaxVersion) select possiblePackage).FirstOrDefault(); if (packageToInstall != null) { packagesToRetrieve.Add(new NuGetPackageInfo(packageToInstall, packageRepository)); break; } } catch (Exception ex) { Log.Warning(ex, "Failed to check if package '{0}' is available on package repository '{1}'", packageId, packageRepository.Source); } } if (packageToInstall == null) { Log.ErrorAndThrowException <NotSupportedException>("Package '{0}' is not found in any of the sources, cannot install package", packageId); return(packagesToRetrieve); } if (IgnoreDependencies) { Log.Debug("Dependencies are ignored, only returning list of requested packages"); return(packagesToRetrieve); } foreach (var dependencySet in packageToInstall.DependencySets) { // TODO: check framework name //if (dependencySet.TargetFramework == new FrameworkName() ) foreach (var dependency in dependencySet.Dependencies) { var resolvedDependencies = ResolveDependencies(dependency.Id, dependency.VersionSpec, packageRepositories); for (var i = resolvedDependencies.Count - 1; i >= 0; i--) { var resolvedDependency = resolvedDependencies[i]; if (!packagesToRetrieve.Any(x => x.Package.Id.Equals(resolvedDependency.Package.Id, StringComparison.CurrentCultureIgnoreCase))) { packagesToRetrieve.Insert(0, resolvedDependency); } } } } return(packagesToRetrieve); }
public void AddConstraint (string packageId, IVersionSpec versionSpec) { constraintProvider.AddConstraint (packageId, versionSpec); }
public void AddConstraint(string packageId, IVersionSpec versionSpec) { _constraints[packageId] = versionSpec; }
public void AddConstraint(string packageId, IVersionSpec versionSpec) { this._constraints[packageId] = versionSpec; }
public static async Task <IEnumerable <IServerPackage> > GetUpdatesAsync( this IServerPackageRepository repository, IEnumerable <IPackageName> packages, bool includePrerelease, bool includeAllVersions, IEnumerable <FrameworkName> targetFramework, IEnumerable <IVersionSpec> versionConstraints, ClientCompatibility compatibility, CancellationToken token) { List <IPackageName> packageList = packages.ToList(); if (!packageList.Any()) { return(Enumerable.Empty <IServerPackage>()); } IList <IVersionSpec> versionConstraintList; if (versionConstraints == null) { versionConstraintList = new IVersionSpec[packageList.Count]; } else { versionConstraintList = versionConstraints.ToList(); } if (packageList.Count != versionConstraintList.Count) { throw new ArgumentException(Strings.GetUpdatesParameterMismatch); } // These are the packages that we need to look at for potential updates. var candidates = await GetUpdateCandidatesAsync( repository, packageList, includePrerelease, compatibility, token); ILookup <string, IServerPackage> sourcePackages = candidates .ToList() .ToLookup(package => package.Id, StringComparer.OrdinalIgnoreCase); var results = new List <IServerPackage>(); for (int i = 0; i < packageList.Count; i++) { var package = packageList[i]; var constraint = versionConstraintList[i]; var updates = from candidate in sourcePackages[package.Id] where (candidate.Version > package.Version) && SupportsTargetFrameworks(targetFramework, candidate) && (constraint == null || constraint.Satisfies(candidate.Version)) select candidate; results.AddRange(updates); } if (!includeAllVersions) { return(CollapseById(results)); } return(results); }
private static bool IsPrereleaseDependency(PackageDependency dependency) { IVersionSpec versionSpec = dependency.VersionSpec; return((versionSpec != null) && (((versionSpec.MinVersion == null) || string.IsNullOrEmpty(dependency.VersionSpec.MinVersion.SpecialVersion)) ? ((versionSpec.MaxVersion != null) && !string.IsNullOrEmpty(dependency.VersionSpec.MaxVersion.SpecialVersion)) : true)); }
public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies) { throw new NotImplementedException(); }
private List<NuGetPackageInfo> ResolveDependencies(string packageId, IVersionSpec packageVersionSpec, IEnumerable<IPackageRepository> packageRepositories) { Log.Debug("Resolving dependencies for package '{0}'", packageId); var packagesToRetrieve = new List<NuGetPackageInfo>(); IPackage packageToInstall = null; foreach (var packageRepository in packageRepositories) { try { var query = packageRepository.GetPackages().Where(x => x.Id.Equals(packageId, StringComparison.CurrentCultureIgnoreCase)); // TODO: optimize performance here //if (packageVersionSpec.MinVersion != null) //{ // foreach (var version in x.Version.Get) // query = query.Where(x => x.Version.GetComparableVersionStrings() >= packageVersionSpec.MinVersion.V); //} //if (packageVersionSpec.MaxVersion != null) //{ // query = query.Where(x => x.Version <= packageVersionSpec.MaxVersion); //} // Note: FirstOrDefault not supported on GetPackages() var possiblePackages = query.ToList().OrderBy(x => x.Version); packageToInstall = (from possiblePackage in possiblePackages where (packageVersionSpec.MinVersion == null || possiblePackage.Version >= packageVersionSpec.MinVersion) && (packageVersionSpec.MaxVersion == null || possiblePackage.Version <= packageVersionSpec.MaxVersion) select possiblePackage).FirstOrDefault(); if (packageToInstall != null) { packagesToRetrieve.Add(new NuGetPackageInfo(packageToInstall, packageRepository)); break; } } catch (Exception ex) { Log.Warning(ex, "Failed to check if package '{0}' is available on package repository '{1}'", packageId, packageRepository.Source); } } if (packageToInstall == null) { throw Log.ErrorAndCreateException<NotSupportedException>("Package '{0}' is not found in any of the sources, cannot install package", packageId); } if (IgnoreDependencies) { Log.Debug("Dependencies are ignored, only returning list of requested packages"); return packagesToRetrieve; } foreach (var dependencySet in packageToInstall.DependencySets) { // TODO: check framework name //if (dependencySet.TargetFramework == new FrameworkName() ) foreach (var dependency in dependencySet.Dependencies) { var resolvedDependencies = ResolveDependencies(dependency.Id, dependency.VersionSpec, packageRepositories); for (var i = resolvedDependencies.Count - 1; i >= 0; i--) { var resolvedDependency = resolvedDependencies[i]; if (!packagesToRetrieve.Any(x => x.Package.Id.Equals(resolvedDependency.Package.Id, StringComparison.CurrentCultureIgnoreCase))) { packagesToRetrieve.Insert(0, resolvedDependency); } } } } return packagesToRetrieve; }
public NuspecDependency(string name, IVersionSpec spec) { Name = name; VersionSpec = spec; }
/// <summary> /// Adds a package that has been resolved as the latest within a constraint. Saves doing the math and resolution again. /// </summary> /// <param name="package"></param> /// <param name="constraint"></param> /// <returns></returns> public bool AddCacheEntryByConstraint(IPackage package, IVersionSpec constraint) { if (!_latestPackageConstraintCache.ContainsKey(package.Id)) _latestPackageConstraintCache.Add(package.Id, new Dictionary<IVersionSpec, IPackage>()); if (!_latestPackageConstraintCache[package.Id].ContainsKey(constraint)) { _latestPackageConstraintCache[package.Id].Add(constraint, package); return true; } return false; }
IPackage findPackageFromName(string id, IVersionSpec versionSpec, string packagesRootDir = null, IQueryable<IPackage> machineCache = null) { machineCache = machineCache ?? Enumerable.Empty<IPackage>().AsQueryable(); if (packagesRootDir != null && localPackageCache == null) { localPackageCache = Utility.GetAllFilePathsRecursively(packagesRootDir) .Where(PackageHelper.IsPackageFile) .Select(x => new ZipPackage(x)) .ToArray(); } return findPackageFromNameInList(id, versionSpec, localPackageCache ?? Enumerable.Empty<IPackage>()) ?? findPackageFromNameInList(id, versionSpec, machineCache); }
public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions) { UpdatePackage(packageId, () => SourceRepository.FindPackage(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted: false), updateDependencies, allowPrereleaseVersions); }
private static IVersionSpec StripPatchLevel(IVersionSpec dependencyVersionSpec) { // Given a curatedFeedVersion of 8.0, make [8.0.1] work. Semver says the patch // level should be backwards compatible, so this should be safe var spec = new VersionSpec { IsMinInclusive = true, MinVersion = new SemanticVersion(dependencyVersionSpec.MinVersion.Version.Major, dependencyVersionSpec.MinVersion.Version.Minor, 0, 0), IsMaxInclusive = dependencyVersionSpec.IsMaxInclusive, MaxVersion = dependencyVersionSpec.MaxVersion }; return spec; }
public IQueryable <ODataPackage> GetUpdates( string packageIds, string versions, bool includePrerelease, bool includeAllVersions, string targetFrameworks, string versionConstraints, string semVerLevel) { if (String.IsNullOrEmpty(packageIds) || String.IsNullOrEmpty(versions)) { return(Enumerable.Empty <ODataPackage>().AsQueryable()); } var idValues = packageIds.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var versionValues = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks) ? null : targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList(); var versionConstraintValues = String.IsNullOrEmpty(versionConstraints) ? new string[idValues.Length] : versionConstraints.Split('|'); if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length) { // Exit early if the request looks invalid return(Enumerable.Empty <ODataPackage>().AsQueryable()); } var packagesToUpdate = new List <IPackageMetadata>(); for (var i = 0; i < idValues.Length; i++) { packagesToUpdate.Add(new PackageBuilder { Id = idValues[i], Version = new SemanticVersion(versionValues[i]) }); } var versionConstraintsList = new IVersionSpec[versionConstraintValues.Length]; for (var i = 0; i < versionConstraintsList.Length; i++) { if (!String.IsNullOrEmpty(versionConstraintValues[i])) { VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraintsList[i]); } } var clientCompatibility = ClientCompatibilityFactory.FromProperties(semVerLevel); return(Repository .GetUpdatesCore( packagesToUpdate, includePrerelease, includeAllVersions, targetFrameworkValues, versionConstraintsList, clientCompatibility) .Select(package => package.AsODataPackage(clientCompatibility)) .AsQueryable() .InterceptWith(new NormalizeVersionInterceptor())); }
public static IRemoteNuget LatestNuget(this IEnumerable<IPackage> candidates, IVersionSpec spec = null) { var candidate = candidates.Latest(spec); return candidate == null ? null : new RemoteNuget(candidate); }
public void PopulateDependencies(PackageBuilder packageBuilder) { var dependencies = new List <PackageDependency>(); var project = _libraryManager.GetLibraryDescription(_project.Name); foreach (var dependency in project.Dependencies) { if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency)) { continue; } var dependencyDescription = _libraryManager.GetLibraryDescription(dependency.Name); // REVIEW: Can we get this far with unresolved dependencies if (dependencyDescription == null || !dependencyDescription.Resolved) { continue; } if (dependencyDescription.Type == LibraryTypes.Project && ((ProjectDescription)dependencyDescription).Project.EmbedInteropTypes) { continue; } if (dependency.LibraryRange.IsGacOrFrameworkReference) { packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.LibraryRange.GetReferenceAssemblyName(), new[] { _targetFramework })); } else { IVersionSpec dependencyVersion = null; if (dependency.LibraryRange.VersionRange == null || dependency.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None) { dependencyVersion = new VersionSpec { IsMinInclusive = true, MinVersion = dependencyDescription.Identity.Version }; } else { var versionRange = dependency.LibraryRange.VersionRange; dependencyVersion = new VersionSpec { IsMinInclusive = true, MinVersion = versionRange.MinVersion, MaxVersion = versionRange.MaxVersion, IsMaxInclusive = versionRange.IsMaxInclusive }; } dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion)); } } packageBuilder.DependencySets.Add(new PackageDependencySet(_targetFramework, dependencies)); }
public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec, bool allowPrereleaseVersions, bool allowUnlisted) => repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted).FirstOrDefault <IPackage>();
/// <summary> /// Copyright 2010 Outercurve Foundation /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// http://www.apache.org/licenses/LICENSE-2.0 /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// </summary> /// <param name="value"></param> /// <param name="result"></param> /// <returns></returns> public static bool TryParseVersionSpec(string value, out IVersionSpec result) { if (value == null) { throw new ArgumentNullException("value"); } var versionSpec = new VersionSpec(); value = value.Trim(); // First, try to parse it as a plain version string Version version; if (Version.TryParse(value, out version)) { // A plain version is treated as an inclusive minimum range result = new VersionSpec { MinVersion = version, IsMinInclusive = true }; return true; } // It's not a plain version, so it must be using the bracket arithmetic range syntax result = null; // Fail early if the string is too short to be valid if (value.Length < 3) { return false; } // The first character must be [ ot ( switch (value.First()) { case '[': versionSpec.IsMinInclusive = true; break; case '(': versionSpec.IsMinInclusive = false; break; default: return false; } // The last character must be ] ot ) switch (value.Last()) { case ']': versionSpec.IsMaxInclusive = true; break; case ')': versionSpec.IsMaxInclusive = false; break; default: return false; } // Get rid of the two brackets value = value.Substring(1, value.Length - 2); // Split by comma, and make sure we don't get more than two pieces string[] parts = value.Split(','); if (parts.Length > 2) { return false; } // If there is only one piece, we use it for both min and max string minVersionString = parts[0]; string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; // Only parse the min version if it's non-empty if (!String.IsNullOrWhiteSpace(minVersionString)) { if (!Version.TryParse(minVersionString, out version)) { return false; } versionSpec.MinVersion = version; } // Same deal for max if (!String.IsNullOrWhiteSpace(maxVersionString)) { if (!Version.TryParse(maxVersionString, out version)) { return false; } versionSpec.MaxVersion = version; } // Successful parse! result = versionSpec; return true; }
public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool allowUnlisted) { var packages = repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted); if (constraintProvider != null) { packages = FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions); } return(packages.FirstOrDefault()); }
IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IQueryable<IPackage> packageList) { // Apply a VersionSpec to a specific Version (this code is nicked // from NuGet) return packageList.Where(x => x.Id == id).ToArray().FirstOrDefault(x => { if (((versionSpec != null) && (versionSpec.MinVersion != null)) && (versionSpec.MaxVersion != null)) { if ((!versionSpec.IsMaxInclusive || !versionSpec.IsMinInclusive) && (versionSpec.MaxVersion == versionSpec.MinVersion)) { return false; } if (versionSpec.MaxVersion < versionSpec.MinVersion) { return false; } } return true; }); }
public void UpdatePackageReference (string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions) { throw new NotImplementedException (); }
private static bool SpecifiedMinVersion(IVersionSpec requestVersionsRange) { return(requestVersionsRange.MinVersion != null && !requestVersionsRange.MinVersion.Equals(new SemanticVersion("0.0"))); }
IPackage matchPackage(IPackageRepository packageRepository, string id, IVersionSpec version) { return(packageRepository.FindPackagesById(id).FirstOrDefault(x => VersionComparer.Matches(version, x.Version))); }
public void PopulateDependencies(PackageBuilder packageBuilder) { var dependencies = new List <PackageDependency>(); var projectReferenceByName = _applicationHostContext.ProjectDepencyProvider .Dependencies .ToDictionary(r => r.Identity.Name); LibraryDescription description; if (!projectReferenceByName.TryGetValue(_project.Name, out description)) { return; } foreach (var dependency in description.Dependencies) { if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency)) { continue; } Runtime.Project dependencyProject; if (projectReferenceByName.ContainsKey(dependency.Name) && _applicationHostContext.ProjectResolver.TryResolveProject(dependency.Name, out dependencyProject) && dependencyProject.EmbedInteropTypes) { continue; } if (dependency.LibraryRange.IsGacOrFrameworkReference) { packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new[] { _targetFramework })); } else { IVersionSpec dependencyVersion = null; if (dependency.LibraryRange.VersionRange == null || dependency.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None) { var actual = _applicationHostContext.DependencyWalker.Libraries .Where(pkg => string.Equals(pkg.Identity.Name, _project.Name, StringComparison.OrdinalIgnoreCase)) .SelectMany(pkg => pkg.Dependencies) .SingleOrDefault(dep => string.Equals(dep.Name, dependency.Name, StringComparison.OrdinalIgnoreCase)); if (actual != null) { dependencyVersion = new VersionSpec { IsMinInclusive = true, MinVersion = actual.Library.Version }; } } else { var versionRange = dependency.LibraryRange.VersionRange; dependencyVersion = new VersionSpec { IsMinInclusive = true, MinVersion = versionRange.MinVersion, MaxVersion = versionRange.MaxVersion, IsMaxInclusive = versionRange.IsMaxInclusive }; } dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion)); } } if (dependencies.Count > 0) { packageBuilder.DependencySets.Add(new PackageDependencySet(_targetFramework, dependencies)); } }
public void UpdatePackageReference(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions) { throw new NotImplementedException(); }
public static IEnumerable<IPackage> FindByVersion(this IEnumerable<IPackage> source, IVersionSpec versionSpec) { if (versionSpec == null) { throw new ArgumentNullException("versionSpec"); } return source.Where(versionSpec.ToDelegate()); }
static IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IEnumerable<IPackage> packageList) { return packageList.Where(x => x.Id == id).ToArray() .FirstOrDefault(x => VersionComparer.Matches(versionSpec, x.Version)); }
private void ProcessDependencies(PackageBuilder builder) { string packagesConfig = GetPackagesConfig(); // No packages config then bail out if (String.IsNullOrEmpty(packagesConfig)) { return; } Logger.Log(MessageLevel.Info, NuGetResources.UsingPackagesConfigForDependencies); var file = new PackageReferenceFile(packagesConfig); // Get the solution repository IPackageRepository repository = GetPackagesRepository(); // Collect all packages var packages = new List <IPackage>(); IDictionary <Tuple <string, SemanticVersion>, PackageReference> packageReferences = file.GetPackageReferences() .ToDictionary(r => Tuple.Create(r.Id, r.Version)); foreach (PackageReference reference in packageReferences.Values) { if (repository != null) { IPackage package = repository.FindPackage(reference.Id, reference.Version); if (package != null) { packages.Add(package); } } } // Add the transform file to the package builder ProcessTransformFiles(builder, packages.SelectMany(GetTransformFiles)); var dependencies = builder.GetCompatiblePackageDependencies(targetFramework: null) .ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase); // Reduce the set of packages we want to include as dependencies to the minimal set. // Normally, packages.config has the full closure included, we only add top level // packages, i.e. packages with in-degree 0 foreach (var package in GetMinimumSet(packages)) { // Don't add duplicate dependencies if (dependencies.ContainsKey(package.Id)) { continue; } IVersionSpec spec = GetVersionConstraint(packageReferences, package); var dependency = new PackageDependency(package.Id, spec); dependencies[dependency.Id] = dependency; } // TO FIX: when we persist the target framework into packages.config file, // we need to pull that info into building the PackageDependencySet object builder.DependencySets.Clear(); builder.DependencySets.Add(new PackageDependencySet(null, dependencies.Values)); }
public static bool TryParseVersionSpec(string value, out IVersionSpec result) { SemanticVersion version; if (value == null) { throw new ArgumentNullException("value"); } VersionSpec spec = new VersionSpec(); value = value.Trim(); if (SemanticVersion.TryParse(value, out version)) { VersionSpec spec1 = new VersionSpec(); spec1.MinVersion = version; spec1.IsMinInclusive = true; result = spec1; return(true); } result = null; if (value.Length < 3) { return(false); } char ch = value.First <char>(); if (ch == '(') { spec.IsMinInclusive = false; } else { if (ch != '[') { return(false); } spec.IsMinInclusive = true; } ch = value.Last <char>(); if (ch == ')') { spec.IsMaxInclusive = false; } else { if (ch != ']') { return(false); } spec.IsMaxInclusive = true; } value = value.Substring(1, value.Length - 2); char[] separator = new char[] { ',' }; string[] strArray = value.Split(separator); if (strArray.Length > 2) { return(false); } if (Enumerable.All <string>(strArray, new Func <string, bool>(string.IsNullOrEmpty))) { return(false); } string str = strArray[0]; string str2 = (strArray.Length == 2) ? strArray[1] : strArray[0]; if (!string.IsNullOrWhiteSpace(str)) { if (!TryParseVersion(str, out version)) { return(false); } spec.MinVersion = version; } if (!string.IsNullOrWhiteSpace(str2)) { if (!TryParseVersion(str2, out version)) { return(false); } spec.MaxVersion = version; } result = spec; return(true); }
public static IRemoteNuget LatestNuget(this IEnumerable <IPackage> candidates, IVersionSpec spec = null) { var candidate = candidates.Latest(spec); return(candidate == null ? null : new RemoteNuget(candidate)); }
public void UpdatePackage (string packageId, IVersionSpec versionSpec, bool updateDependencies) { throw new NotImplementedException (); }
static IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IEnumerable<IPackage> packageList) { return packageList.Where(x => String.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase)).ToArray() .FirstOrDefault(x => VersionComparer.Matches(versionSpec, x.Version)); }
IPackage findPackageFromName(string id, IVersionSpec versionSpec, string packagesRootDir = null, IQueryable<IPackage> machineCache = null) { var localPackages = Enumerable.Empty<IPackage>().AsQueryable(); machineCache = machineCache ?? Enumerable.Empty<IPackage>().AsQueryable(); if (packagesRootDir != null) { localPackages = new DirectoryInfo(packagesRootDir).GetAllFilesRecursively() .Where(x => x.Name.ToLowerInvariant().EndsWith("nupkg")) .Select(x => new ZipPackage(x.FullName)) .ToArray().AsQueryable(); } return findPackageFromNameInList(id, versionSpec, localPackages) ?? findPackageFromNameInList(id, versionSpec, machineCache); }
public async Task <PackageBase> Resolve(ObservableCollection <PackageBase> packages, string packageId, int depth, CancellationToken token, FrameworkName targetFramework = null, IVersionSpec versionSpec = null) { var result = await DoResolve(packages, packageId, depth, token, targetFramework, versionSpec); TryToFixMissingPackages(packages, depth + 1); return(result); }
private void AssertSafeVersion(IVersionSpec versionSpec, SemanticVersion minVer, SemanticVersion maxVer) { Assert.True(versionSpec.IsMinInclusive); Assert.False(versionSpec.IsMaxInclusive); Assert.Equal(versionSpec.MinVersion, minVer); Assert.Equal(versionSpec.MaxVersion, maxVer); }
protected abstract Task <PackageBase> DoResolve(ObservableCollection <PackageBase> packages, string packageId, int depth, CancellationToken token, FrameworkName targetFramework, IVersionSpec versionSpec);