public IEnumerable <PackageOperation> ResolveOperations(IPackage package) { // The cases when we don't check downgrade is when this object is // called to restore packages, e.g. by nuget.exe restore command. // Otherwise, check downgrade is true, e.g. when user installs a package // inside VS. if (CheckDowngrade) { //Check if the package is installed. This is necessary to know if this is a fresh-install or a downgrade operation IPackage packageUnderInstallation = Repository.FindPackage(package.Id); if (packageUnderInstallation != null && packageUnderInstallation.Version > package.Version) { _isDowngrade = true; } } else { _isDowngrade = false; } _operations.Clear(); Marker.Clear(); _packagesToKeep.Clear(); Walk(package); return(Operations.Reduce()); }
public IEnumerable <PackageOperation> ResolveOperations(IPackage package) { Operations.Clear(); Marker.Clear(); Walk(package); // Log warnings for packages that were forcibly removed foreach (var pair in _forcedRemoved) { Logger.Log(MessageLevel.Warning, NuGetResources.Warning_UninstallingPackageWillBreakDependents, pair.Key, String.Join(", ", pair.Value.Select(p => p.GetFullName()))); } // Log warnings for dependencies that were skipped foreach (var pair in _skippedPackages) { Logger.Log(MessageLevel.Warning, NuGetResources.Warning_PackageSkippedBecauseItIsInUse, pair.Key, String.Join(", ", pair.Value.Select(p => p.GetFullName()))); } return(Operations.Reduce()); }
public IEnumerable <PackageOperation> ResolveOperations(IPackage package) { _operations.Clear(); Marker.Clear(); Walk(package); return(Operations.Reduce()); }
/// <summary> /// Get all packages from the specified repository in the dependency order, /// e.g. if A -> B, then B will come before A. /// </summary> public IEnumerable <IPackage> GetPackagesByDependencyOrder(IPackageRepository repository) { if (repository == null) { throw new ArgumentNullException("repository"); } Marker.Clear(); _repository = repository; _sortedPackages = new List <IPackage>(); foreach (var package in _repository.GetPackages()) { Walk(package); } return(_sortedPackages); }
public IList <PackageOperation> ResolveOperations(IEnumerable <IPackage> packages, out IList <IPackage> packagesByDependencyOrder, bool allowPrereleaseVersionsBasedOnPackage = false) { _packagesByDependencyOrder = new Dictionary <string, IList <IPackage> >(); _operations.Clear(); Marker.Clear(); _packagesToKeep.Clear(); Debug.Assert(Operations is List <PackageOperation>); foreach (var package in packages) { if (!_operations.Contains(package, PackageAction.Install)) { var allowPrereleaseVersions = _allowPrereleaseVersions; try { if (allowPrereleaseVersionsBasedOnPackage) { // Update _allowPrereleaseVersions before walking a package if allowPrereleaseVersionsBasedOnPackage is set to true // This is mainly used when bulk resolving operations for reinstalling packages _allowPrereleaseVersions = _allowPrereleaseVersions || !package.IsReleaseVersion(); } Walk(package); } finally { _allowPrereleaseVersions = allowPrereleaseVersions; } } } // Flatten the dictionary to create a list of all the packages. Only this item the packages visited first during the walk will appear on the list. Also, only retain distinct elements IEnumerable <IPackage> allPackagesByDependencyOrder = _packagesByDependencyOrder.SelectMany(p => p.Value).Distinct(); // Only retain the packages for which the operations are being resolved for packagesByDependencyOrder = allPackagesByDependencyOrder.Where(p => packages.Any(q => p.Id == q.Id && p.Version == q.Version)).ToList(); Debug.Assert(packagesByDependencyOrder.Count == packages.Count()); _packagesByDependencyOrder.Clear(); _packagesByDependencyOrder = null; return(Operations.Reduce()); }