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); }