protected void when_resolving_packages() { Resolve = new StrategyResolver() .TryResolveDependencies(DependencyDescriptor, new[] { CurrentDirectoryRepository, ProjectRepository, SystemRepository, RemoteRepository }); }
static IEnumerable <PackageAnchoredResult> AnchorPackages(DependencyResolutionResult resolvedPackages, IEnumerable <IPackageRepository> destinationRepositories) { return(from repo in destinationRepositories.OfType <ISupportAnchoring>() from successfulPackage in resolvedPackages.SuccessfulPackages where successfulPackage.IsAnchored let packageInstances = from packageInstance in successfulPackage.Packages where packageInstance != null && packageInstance.Source == repo select packageInstance from anchorResult in repo.AnchorPackages(packageInstances) select anchorResult); }
IEnumerable <PackageOperationResult> CopyPackagesToRepositories(IEnumerable <IPackageRepository> sourceRepositories, DependencyResolutionResult resolvedPackages, IEnumerable <IPackageRepository> destinationRepositories) { var publishingRepos = destinationRepositories.NotNull().OfType <ISupportPublishing>().ToList(); foreach (var destinationRepository in publishingRepos) { using (var publisher = destinationRepository.Publisher()) { foreach (var foundPackage in resolvedPackages.SuccessfulPackages) { if (foundPackage == null) { throw new InvalidOperationException("A null package was selected in the package resolution phase. Something's gone badly wrong."); } var package = foundPackage; var existingUpToDateVersion = GetExistingPackage(destinationRepository, package, x => x == package.Identifier.Version); if (existingUpToDateVersion == null) { var sourcePackage = GetBestSourcePackage(sourceRepositories, package.Packages); _deployer.DeployDependency(sourcePackage, publisher); var existingVersion = GetExistingPackage(destinationRepository, package, x => x != package.Identifier.Version); yield return(existingVersion == null ? new PackageAddedResult(sourcePackage, destinationRepository) : new PackageUpdatedResult(existingVersion, sourcePackage, destinationRepository)); } else { yield return(new PackageUpToDateResult(existingUpToDateVersion, destinationRepository)); } } } } }
/// <summary> /// Runs a full dependency check to check for mods with missing dependencies. /// </summary> public DependencyResolutionResult GetMissingDependencies() { // Get list of all mods. var allMods = Items.ToArray(); var allModIds = new HashSet <string>(allMods.Length); foreach (var mod in allMods) { allModIds.Add(mod.Config.ModId); } var resolutionResult = new DependencyResolutionResult(); foreach (var item in allMods) { var dependencyItem = new DependencyResolutionItem(); dependencyItem.Mod = item.Config; // Get missing dependencies. foreach (var dependency in item.Config.ModDependencies) { if (!allModIds.Contains(dependency)) { dependencyItem.Dependencies.Add(dependency); } } // Add if any missing dependencies. if (dependencyItem.Dependencies.Count > 0) { resolutionResult.Items.Add(dependencyItem); } } return(resolutionResult); }
protected void when_resolving_packages() { Resolve = new PackageManager().TryResolveDependencies(DependencyDescriptor, new[] { ProjectRepository, SystemRepository, RemoteRepository }); }
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(DependencyResolutionResult resolveResult, ExecutionEnvironment exec, bool includeContentOnly) { var packages = resolveResult.SuccessfulPackages.Where(resolvedPackage => includeContentOnly || !resolvedPackage.IsInContentBranch).SelectMany(x => x.Packages); return GetAssemblyReferencesFromPackages(packages, exec); }
protected void when_resolving_packages() { Resolve = new PackageManager().TryResolveDependencies(DependencyDescriptor, LocalRepository, UserRepository, new[] { RemoteRepository }); }
IEnumerable<PackageOperationResult> ReturnError(DependencyResolutionResult resolvedPackages) { return resolvedPackages.DiscardedPackages.Select(PackageConflict) .Concat(resolvedPackages.MissingPackages.Select(PackageMissing)); }
IEnumerable<PackageOperationResult> CopyPackagesToRepositories(IEnumerable<IPackageRepository> sourceRepositories, DependencyResolutionResult resolvedPackages, IEnumerable<IPackageRepository> destinationRepositories) { var publishingRepos = destinationRepositories.NotNull().OfType<ISupportPublishing>().ToList(); foreach (var destinationRepository in publishingRepos) { using (var publisher = destinationRepository.Publisher()) { foreach (var foundPackage in resolvedPackages.SuccessfulPackages) { var existingUpToDateVersion = GetExistingPackage(destinationRepository, foundPackage, x => x >= foundPackage.Identifier.Version); if (existingUpToDateVersion == null) { var sourcePackage = GetBestSourcePackage(sourceRepositories, foundPackage.Packages); _deployer.DeployDependency(sourcePackage, publisher); var existingVersion = GetExistingPackage(destinationRepository, foundPackage, x => x < foundPackage.Identifier.Version); yield return existingVersion == null ? new PackageAddedResult(sourcePackage, destinationRepository) : new PackageUpdatedResult(existingVersion, sourcePackage, destinationRepository); } else { yield return new PackageUpToDateResult(existingUpToDateVersion, destinationRepository); } } } } }
static IEnumerable<PackageAnchoredResult> AnchorPackages(DependencyResolutionResult resolvedPackages, IEnumerable<IPackageRepository> destinationRepositories) { return from repo in destinationRepositories.OfType<ISupportAnchoring>() from successfulPackage in resolvedPackages.SuccessfulPackages where successfulPackage.IsAnchored let packageInstances = from packageInstance in successfulPackage.Packages where packageInstance != null && packageInstance.Source == repo select packageInstance from anchorResult in repo.AnchorPackages(packageInstances) select anchorResult; }
IEnumerable <PackageOperationResult> ReturnError(DependencyResolutionResult resolvedPackages) { return(resolvedPackages.DiscardedPackages.Select(PackageConflict) .Concat(resolvedPackages.MissingPackages.Select(PackageMissing))); }
static IEnumerable <IPackageInfo> GetSelectedPackages(DependencyResolutionResult resolvedPackages) { return(resolvedPackages.SuccessfulPackages.Select(x => x.Packages.First())); }