private static PackageUpgradeAction DetectUpgradeAction(PackageDependency dependency, IPackage recentPackage)
{
var upgradeType = PackageUpgradeAction.None;
if (recentPackage == null)
{
upgradeType = PackageUpgradeAction.Unknown;
}
else if (dependency.VersionSpec.Satisfies(recentPackage.Version))
{
upgradeType = IsMinVersionUpgradeable(dependency, recentPackage)
? PackageUpgradeAction.MinVersion
: PackageUpgradeAction.None;
}
else
{
var fromRelease = DependsOnReleaseVersion(dependency);
if (recentPackage.IsReleaseVersion())
{
upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToRelease : PackageUpgradeAction.PrereleaseToRelease;
}
else
{
upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToPrerelease : PackageUpgradeAction.PrereleaseToPrerelease;
}
}
return upgradeType;
}
public void GetLinkTo_dependency_should_return_link_with_dependency_name_as_target()
{
var p = new TestPackage { Id = "test-package", Version = new Version("1.2.3") };
var dependency = new PackageDependency("dep", new VersionSpec { MinVersion = new Version("1.2.3") });
Assert.AreEqual("dep (1.2.3)", p.GetLinkTo(dependency).Target);
}
public void GetLinkTo_dependency_should_return_link_with_packge_category()
{
var p = new TestPackage { Id = "test-package", Version = new Version("1.2.3") };
var dependency = new PackageDependency("dep", new VersionSpec { MinVersion = new Version("1.2.3") });
Assert.AreEqual("Package", p.GetLinkTo(dependency).Category1);
}
private static bool IsPrereleaseDependency(PackageDependency pd)
{
if (pd.VersionSpec == null)
{
return false;
}
return IsPreReleasedVersion(pd.VersionSpec.MinVersion) || IsPreReleasedVersion(pd.VersionSpec.MaxVersion);
}
private static PackageIssue CreatePackageIssue(PackageDependency target)
{
return new PackageIssue(
PackageIssueLevel.Error,
"Invalid prerelease dependency",
String.Format(CultureInfo.CurrentCulture,
"A stable release of a package must not have a dependency on a prerelease package, '{0}'.",
target),
String.Format(CultureInfo.CurrentCulture,
"Either modify the version spec of dependency '{0}' or update the version field.", target)
);
}
public void ShowDownloadStatus(PackageDependency dependentPackage)
{
if (uxDownloadStatus.InvokeRequired)
{
uxDownloadStatus.Invoke((Action)(() =>
{
uxDownloadStatus.Text = "Downloading the dependencies\n" + "Downloading " + dependentPackage.Id;
}));
}
else
{
uxDownloadStatus.Text = "Downloading the dependencies\n" + "Downloading " + dependentPackage.Id;
}
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
IVersionSpec spec = ConstraintProvider.GetConstraint(dependency.Id);
string message = String.Empty;
if (spec != null)
{
message = String.Format(CultureInfo.CurrentCulture, NuGetResources.AdditonalConstraintsDefined, dependency.Id, VersionUtility.PrettyPrint(spec), ConstraintProvider.Source);
}
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnableToResolveDependency + message, dependency));
}
public Dependency Map(PackageDependency packageDependency, string packageId, string packageVersion)
{
if (packageDependency == null)
{
throw new ArgumentNullException("packageDependency");
}
string versionSpec = packageDependency.VersionSpec != null ? packageDependency.VersionSpec.ToString() : string.Empty;
return new Dependency
{
Name = packageDependency.Id,
PackageId = !string.IsNullOrWhiteSpace(packageId) ? packageId : string.Empty,
PackageVersion = !string.IsNullOrWhiteSpace(packageVersion) ? packageVersion : string.Empty,
VersionSpec = versionSpec
};
}
public static IPackage FindDependency(this IPackageRepository repository, PackageDependency dependency)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
// When looking for dependencies, order by lowest version
IEnumerable <IPackage> packages = repository.FindPackagesById(dependency.Id)
.ToList();
// If version info was specified then use it
if (dependency.VersionSpec != null)
{
packages = packages.FindByVersion(dependency.VersionSpec);
}
else
{
// BUG 840: If no version info was specified then pick the latest
return(packages.OrderByDescending(p => p.Version)
.FirstOrDefault());
}
if (packages.Any())
{
// We want to take the biggest build and revision number for the smallest
// major and minor combination (we want to make some versioning assumptions that the 3rd number is a non-breaking bug fix). This is so that we get the closest version
// to the dependency, but also get bug fixes without requiring people to manually update the nuspec.
// For example, if A -> B 1.0.0 and the feed has B 1.0.0 and B 1.0.1 then the more correct choice is B 1.0.1.
// If we don't do this, A will always end up getting the 'buggy' 1.0.0,
// unless someone explicitly changes it to ask for 1.0.1, which is very painful if many packages are using B 1.0.0.
var groups = from p in packages
group p by new { p.Version.Major, p.Version.Minor } into g
orderby g.Key.Major, g.Key.Minor
select g;
return((from p in groups.First()
orderby p.Version descending
select p).FirstOrDefault());
}
return(null);
}
private static void ValidateDependencyVersion(PackageDependency dependency)
{
if ((dependency.VersionSpec != null) && ((dependency.VersionSpec.MinVersion != null) && (dependency.VersionSpec.MaxVersion != null)))
{
if ((!dependency.VersionSpec.IsMaxInclusive || !dependency.VersionSpec.IsMinInclusive) && (dependency.VersionSpec.MaxVersion == dependency.VersionSpec.MinVersion))
{
object[] args = new object[] { dependency.Id };
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, args));
}
if (dependency.VersionSpec.MaxVersion < dependency.VersionSpec.MinVersion)
{
object[] args = new object[] { dependency.Id };
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, args));
}
}
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = _repo as IDependencyResolver;
if (dependencyResolver != null)
{
return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
return DependencyResolveUtility.ResolveDependencyCore(
_repo,
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion);
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = _repo as IDependencyResolver;
if (dependencyResolver != null)
{
return(dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
return(DependencyResolveUtility.ResolveDependencyCore(
_repo,
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion));
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
Logger.Log(MessageLevel.Info, NuGetResources.Log_AttemptingToRetrievePackageFromSource, dependency);
// First try to get a local copy of the package
// Bug1638: Include prereleases when resolving locally installed dependencies.
IPackage package = Repository.ResolveDependency(dependency, ConstraintProvider, allowPrereleaseVersions: true, preferListedPackages: false);
if (package != null)
{
return(package);
}
// Next, query the source repo for the same dependency
IPackage sourcePackage = SourceRepository.ResolveDependency(dependency, ConstraintProvider, AllowPrereleaseVersions, preferListedPackages: true);
return(sourcePackage);
}
/// <summary>
/// From the list of packages <paramref name="packages"/>, selects the package that best
/// matches the <paramref name="dependency"/>.
/// </summary>
/// <param name="packages">The list of packages.</param>
/// <param name="dependency">The dependency used to select package from the list.</param>
/// <param name="dependencyVersion">Indicates the method used to select dependency.
/// Applicable only when dependency.VersionSpec is not null.</param>
/// <returns>The selected package.</returns>
private static IPackage ResolveDependencyCore(
IEnumerable <IPackage> packages,
PackageDependency dependency,
DependencyVersion dependencyVersion)
{
// If version info was specified then use it
if (dependency.VersionSpec != null)
{
packages = packages.FindByVersion(dependency.VersionSpec).OrderBy(p => p.Version);
return(packages.SelectDependency(dependencyVersion));
}
else
{
// BUG 840: If no version info was specified then pick the latest
return(packages.OrderByDescending(p => p.Version)
.FirstOrDefault());
}
}
public override void Context()
{
var minVersionSpec = new VersionSpec
{
MinVersion = new SemanticVersion("1.0.0"),
IsMinInclusive = true
};
packageDependencyWithMinVersion = new PackageDependency("fiddler", minVersionSpec);
var minAndMaxVersionSpec = new VersionSpec
{
MinVersion = new SemanticVersion("1.0.0"),
MaxVersion = new SemanticVersion("2.0.0"),
IsMinInclusive = true
};
packageDependencyWithMaxVersion = new PackageDependency("dude", minAndMaxVersionSpec);
guideline = new DependencyWithNoVersionGuideline();
}
public AddInDependency(PackageDependency packageDependency)
{
if (packageDependency != null)
{
IVersionSpec versionSpec = packageDependency.VersionSpec;
Id = packageDependency.Id;
if (versionSpec.MinVersion != null)
{
MinimumVersion = versionSpec.MinVersion.Version;
}
if (versionSpec.MaxVersion != null)
{
MaximumVersion = versionSpec.MaxVersion.Version;
}
IncludeMinimumVersion = packageDependency.VersionSpec.IsMinInclusive;
IncludeMaximumVersion = packageDependency.VersionSpec.IsMaxInclusive;
}
}
private static void ValidateDependencyVersion(PackageDependency dependency)
{
if (dependency.VersionSpec != null)
{
if (dependency.VersionSpec.MinVersion != null &&
dependency.VersionSpec.MaxVersion != null)
{
if ((!dependency.VersionSpec.IsMaxInclusive ||
!dependency.VersionSpec.IsMinInclusive) &&
dependency.VersionSpec.MaxVersion == dependency.VersionSpec.MinVersion)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, dependency.Id));
}
if (dependency.VersionSpec.MaxVersion < dependency.VersionSpec.MinVersion)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, dependency.Id));
}
}
}
}
public static IPackage ResolveDependencyCore(
IPackageRepository repository,
PackageDependency dependency,
IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions,
bool preferListedPackages,
DependencyVersion dependencyVersion)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
IEnumerable <IPackage> packages = repository.FindPackagesById(dependency.Id).ToList();
// Always filter by constraints when looking for dependencies
packages = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions);
IList <IPackage> candidates = packages.ToList();
if (preferListedPackages)
{
// pick among Listed packages first
IPackage listedSelectedPackage = ResolveDependencyCore(
candidates.Where(PackageExtensions.IsListed),
dependency,
dependencyVersion);
if (listedSelectedPackage != null)
{
return(listedSelectedPackage);
}
}
return(ResolveDependencyCore(candidates, dependency, dependencyVersion));
}
internal static void ValidateDependencySets(SemanticVersion version, IEnumerable <PackageDependencySet> dependencies)
{
if (version != null)
{
using (IEnumerator <PackageDependency> enumerator = (from s in dependencies select s.Dependencies).GetEnumerator())
{
while (enumerator.MoveNext())
{
PackageIdValidator.ValidatePackageId(enumerator.Current.Id);
}
}
if (string.IsNullOrEmpty(version.SpecialVersion))
{
PackageDependency dependency = Enumerable.FirstOrDefault <PackageDependency>(from set in dependencies select set.Dependencies, new Func <PackageDependency, bool>(PackageBuilder.IsPrereleaseDependency));
if (dependency != null)
{
object[] args = new object[] { dependency.ToString() };
throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_InvalidPrereleaseDependency, args));
}
}
}
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
Logger.Log(MessageLevel.Verbose, NuGetResources.Log_AttemptingToRetrievePackageFromSource, dependency);
// First try to get a local copy of the package
// Bug1638: Include prereleases when resolving locally installed dependencies.
//Prerelease is included when we try to look at the local repository.
//In case of downgrade, we are going to look only at source repo and not local.
//That way we will downgrade dependencies when parent package is downgraded.
if (!_isDowngrade)
{
IPackage package = Repository.ResolveDependency(dependency, ConstraintProvider, allowPrereleaseVersions: true, preferListedPackages: false, dependencyVersion: DependencyVersion);
if (package != null)
{
return(package);
}
}
// Next, query the source repo for the same dependency
IPackage sourcePackage = SourceRepository.ResolveDependency(dependency, ConstraintProvider, AllowPrereleaseVersions, preferListedPackages: true, dependencyVersion: DependencyVersion);
return(sourcePackage);
}
public static IPackage ResolveDependencyCore(IPackageRepository repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
IEnumerable <IPackage> packages = repository.FindPackagesById(dependency.Id).ToList <IPackage>();
IList <IPackage> list = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions).ToList <IPackage>();
if (preferListedPackages)
{
IPackage package = ResolveDependencyCore(Enumerable.Where <IPackage>(list, new Func <IPackage, bool>(PackageExtensions.IsListed)), dependency, dependencyVersion);
if (package != null)
{
return(package);
}
}
return(ResolveDependencyCore(list, dependency, dependencyVersion));
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
// ignore dependency error
}
private static bool IsPrereleaseDependency(PackageDependency dependency)
{
var versionSpec = dependency.VersionSpec;
if (versionSpec != null)
{
return (versionSpec.MinVersion != null && !String.IsNullOrEmpty(dependency.VersionSpec.MinVersion.SpecialVersion)) ||
(versionSpec.MaxVersion != null && !String.IsNullOrEmpty(dependency.VersionSpec.MaxVersion.SpecialVersion));
}
return false;
}
private static IPackage ResolveDependencyCore(IEnumerable <IPackage> packages, PackageDependency dependency, DependencyVersion dependencyVersion)
{
if (dependency.VersionSpec == null)
{
return((from p in packages
orderby p.Version descending
select p).FirstOrDefault <IPackage>());
}
packages = from p in packages.FindByVersion(dependency.VersionSpec)
orderby p.Version
select p;
return(packages.SelectDependency(dependencyVersion));
}
private static XElement GetXElementFromPackageDependency(XNamespace ns, PackageDependency dependency)
{
return(new XElement(ns + "dependency",
new XAttribute("id", dependency.Id),
dependency.VersionRange != null ? new XAttribute("version", dependency.VersionRange.ToString()) : null));
}
private static bool IsMinVersionUpgradeable(PackageDependency dependency, PackageIdentity recentPackage) => (dependency.VersionRange.MinVersion != null) && (dependency.VersionRange.MinVersion < recentPackage.Version);
private static bool IsMinVersionUpgradeable(PackageDependency dependency, IPackage recentPackage)
{
return (dependency.VersionSpec.MinVersion != null) && (dependency.VersionSpec.MinVersion < recentPackage.Version);
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
return Repository.FindDependency(dependency);
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageUpgrade"/> class.
/// </summary>
/// <param name="packageDependency">The package dependency affected by the upgrade.</param>
/// <param name="action">The upgrade action of the package dependency.</param>
/// <param name="package">The package that can be used to perform the upgrade action on the package dependency.</param>
public PackageUpgrade(PackageDependency packageDependency, PackageUpgradeAction action, PackageIdentity package)
{
PackageDependency = packageDependency;
Action = action;
Package = package;
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
// ignore dependency error
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnableToResolveDependency, dependency));
}
protected override IPackage ResolveDependency(PackageDependency dependency) => DependencyResolveUtility.ResolveDependency(this._repository, dependency, true, false);
protected override void OnDependencyResolveError(PackageDependency dependency)
{
Logger.Log(MessageLevel.Warning, NuGetResources.UnableToLocateDependency, dependency);
}
public static IPackage ResolveDependency(this IPackageRepository repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages)
{
return(ResolveDependency(repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion: DependencyVersion.Lowest));
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
return(_repository.FindDependency(dependency));
}
protected abstract IPackage ResolveDependency(PackageDependency dependency);
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
// Use the primary repository to look up dependencies. Fallback to the aggregate repository only if we can't find a package here.
return(_primaryRepository.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) ??
_dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
private static bool DependsOnReleaseVersion(PackageDependency dependency) => (dependency.VersionRange.MaxVersion != null) && !dependency.VersionRange.MaxVersion.IsPrerelease && dependency.VersionRange.IsMaxInclusive;
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
// Use the primary repository to look up dependencies. Fallback to the aggregate repository only if we can't find a package here.
return _primaryRepository.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) ??
_dependencyResolver.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
private static void ValidateDependencyVersion(PackageDependency dependency)
{
if (dependency.VersionSpec != null)
{
if (dependency.VersionSpec.MinVersion != null &&
dependency.VersionSpec.MaxVersion != null)
{
if ((!dependency.VersionSpec.IsMaxInclusive ||
!dependency.VersionSpec.IsMinInclusive) &&
dependency.VersionSpec.MaxVersion == dependency.VersionSpec.MinVersion)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, dependency.Id));
}
if (dependency.VersionSpec.MaxVersion < dependency.VersionSpec.MinVersion)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.DependencyHasInvalidVersion, dependency.Id));
}
}
}
}
protected virtual void OnDependencyResolveError(PackageDependency dependency)
{
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
IVersionSpec spec = ConstraintProvider.GetConstraint(dependency.Id);
string message = String.Empty;
if (spec != null)
{
message = String.Format(CultureInfo.CurrentCulture, NuGetResources.AdditonalConstraintsDefined, dependency.Id, VersionUtility.PrettyPrint(spec), ConstraintProvider.Source);
}
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnableToResolveDependency + message, dependency));
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, bool allowPrereleaseVersions, bool preferListedPackages)
{
return(ResolveDependency(repository, dependency, constraintProvider: null, allowPrereleaseVersions: allowPrereleaseVersions, preferListedPackages: preferListedPackages, dependencyVersion: DependencyVersion.Lowest));
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver resolver = repository as IDependencyResolver;
return((resolver == null) ? ResolveDependencyCore((IPackageRepository)repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) : resolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
protected virtual void OnDependencyResolveError(PackageDependency dependency)
{
}
protected abstract IPackage ResolveDependency(PackageDependency dependency);
private static bool DependsOnReleaseVersion(PackageDependency dependency)
{
return (dependency.VersionSpec.MaxVersion != null) &&
string.IsNullOrEmpty(dependency.VersionSpec.MaxVersion.SpecialVersion) &&
dependency.VersionSpec.IsMaxInclusive;
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, bool allowPrereleaseVersions, bool preferListedPackages)
{
return ResolveDependency(repository, dependency, constraintProvider: null, allowPrereleaseVersions: allowPrereleaseVersions, preferListedPackages: preferListedPackages, dependencyVersion: DependencyVersion.Lowest);
}
protected override void OnDependencyResolveError(PackageDependency dependency)
{
Logger.Log(MessageLevel.Warning, NuGetResources.UnableToLocateDependency, dependency);
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = repository as IDependencyResolver;
if (dependencyResolver != null)
{
return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
return ResolveDependencyCore((IPackageRepository)repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
return(DependencyResolveUtility.ResolveDependency(_repository, dependency, allowPrereleaseVersions: true, preferListedPackages: false));
}
public static IPackage ResolveDependencyCore(
IPackageRepository repository,
PackageDependency dependency,
IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions,
bool preferListedPackages,
DependencyVersion dependencyVersion)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
IEnumerable<IPackage> packages = repository.FindPackagesById(dependency.Id).ToList();
// Always filter by constraints when looking for dependencies
packages = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions);
IList<IPackage> candidates = packages.ToList();
if (preferListedPackages)
{
// pick among Listed packages first
IPackage listedSelectedPackage = ResolveDependencyCore(
candidates.Where(PackageExtensions.IsListed),
dependency,
dependencyVersion);
if (listedSelectedPackage != null)
{
return listedSelectedPackage;
}
}
return ResolveDependencyCore(candidates, dependency, dependencyVersion);
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
Logger.Log(MessageLevel.Info, NuGetResources.Log_AttemptingToRetrievePackageFromSource, dependency);
// First try to get a local copy of the package
// Bug1638: Include prereleases when resolving locally installed dependencies.
//Prerelease is included when we try to look at the local repository.
//In case of downgrade, we are going to look only at source repo and not local.
//That way we will downgrade dependencies when parent package is downgraded.
if (!_isDowngrade)
{
IPackage package = Repository.ResolveDependency(dependency, ConstraintProvider, allowPrereleaseVersions: true, preferListedPackages: false, dependencyVersion: DependencyVersion);
if (package != null)
{
return package;
}
}
// Next, query the source repo for the same dependency
IPackage sourcePackage = SourceRepository.ResolveDependency(dependency, ConstraintProvider, AllowPrereleaseVersions, preferListedPackages: true, dependencyVersion: DependencyVersion);
return sourcePackage;
}
/// <summary>
/// From the list of packages <paramref name="packages"/>, selects the package that best
/// matches the <paramref name="dependency"/>.
/// </summary>
/// <param name="packages">The list of packages.</param>
/// <param name="dependency">The dependency used to select package from the list.</param>
/// <param name="dependencyVersion">Indicates the method used to select dependency.
/// Applicable only when dependency.VersionSpec is not null.</param>
/// <returns>The selected package.</returns>
private static IPackage ResolveDependencyCore(
IEnumerable<IPackage> packages,
PackageDependency dependency,
DependencyVersion dependencyVersion)
{
// If version info was specified then use it
if (dependency.VersionSpec != null)
{
packages = packages.FindByVersion(dependency.VersionSpec).OrderBy(p => p.Version);
return packages.SelectDependency(dependencyVersion);
}
else
{
// BUG 840: If no version info was specified then pick the latest
return packages.OrderByDescending(p => p.Version)
.FirstOrDefault();
}
}
private string ConvertDependency(PackageDependency packageDependency, FrameworkName targetFramework)
{
if (targetFramework == null)
{
if (packageDependency.VersionSpec == null)
{
return packageDependency.Id;
}
else
{
return String.Format("{0}:{1}", packageDependency.Id, packageDependency.VersionSpec);
}
}
else
{
return String.Format("{0}:{1}:{2}", packageDependency.Id, packageDependency.VersionSpec, VersionUtility.GetShortFrameworkName(targetFramework));
}
}
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));
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
Logger.Log(MessageLevel.Info, NuGetResources.Log_AttemptingToRetrievePackageFromSource, dependency);
// First try to get a local copy of the package
// Bug1638: Include prereleases when resolving locally installed dependencies.
IPackage package = Repository.ResolveDependency(dependency, ConstraintProvider, allowPrereleaseVersions: true, preferListedPackages: false);
// Next, query the source repo for the same dependency
IPackage sourcePackage = SourceRepository.ResolveDependency(dependency, ConstraintProvider, AllowPrereleaseVersions, preferListedPackages: true);
// We didn't find a copy in the local repository
if (package == null)
{
return sourcePackage;
}
// Only use the package from the source repository if it's a newer version (it'll only be newer in bug fixes)
if (sourcePackage != null && package.Version < sourcePackage.Version)
{
return sourcePackage;
}
return package;
}
public void AddDependency (string id, SemanticVersion minVersion, SemanticVersion maxVersion)
{
var versionSpec = new VersionSpec ();
versionSpec.MinVersion = minVersion;
versionSpec.MaxVersion = maxVersion;
var dependency = new PackageDependency (id, versionSpec);
DependenciesList.Add (dependency);
}
protected override IPackage ResolveDependency(PackageDependency dependency)
{
return Repository.ResolveDependency(dependency, allowPrereleaseVersions: true, preferListedPackages: false);
}
private static bool IsPrereleaseDependency(PackageDependency dependency)
{
return(dependency.VersionRange.MinVersion?.IsPrerelease == true ||
dependency.VersionRange.MaxVersion?.IsPrerelease == true);
}
