protected void when_resolving_packages()
 {
     Resolve = new StrategyResolver()
               .TryResolveDependencies(DependencyDescriptor,
                                       new[]
     {
         CurrentDirectoryRepository,
         ProjectRepository,
         SystemRepository,
         RemoteRepository
     });
 }
 protected void when_resolving_packages()
 {
     Resolve = new StrategyResolver()
             .TryResolveDependencies(DependencyDescriptor,
                                     new[]
                                     {
                                             CurrentDirectoryRepository,
                                             ProjectRepository,
                                             SystemRepository,
                                             RemoteRepository
                                     });
 }
Esempio n. 3
0
 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));
                        }
                    }
                }
            }
        }
Esempio n. 5
0
    /// <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
                                                           });
 }
Esempio n. 7
0
 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;
 }
Esempio n. 12
0
 IEnumerable <PackageOperationResult> ReturnError(DependencyResolutionResult resolvedPackages)
 {
     return(resolvedPackages.DiscardedPackages.Select(PackageConflict)
            .Concat(resolvedPackages.MissingPackages.Select(PackageMissing)));
 }
Esempio n. 13
0
 static IEnumerable <IPackageInfo> GetSelectedPackages(DependencyResolutionResult resolvedPackages)
 {
     return(resolvedPackages.SuccessfulPackages.Select(x => x.Packages.First()));
 }