function Installer::createRepositorySet

@phpstan-param list<array{package: string, version: string, alias: string, alias_normalized: string}> $rootAliases

Parameters

array<int, array<string, string>> $rootAliases:

3 calls to Installer::createRepositorySet()

Installer::doInstall in vendor/composer/composer/src/Composer/Installer.php

@phpstan-return self::ERROR_*

Installer::doUpdate in vendor/composer/composer/src/Composer/Installer.php

@phpstan-return self::ERROR_*

Installer::extractDevPackages in vendor/composer/composer/src/Composer/Installer.php

Run the solver a second time on top of the existing update result with only the current result set in the pool and see what packages would get removed if we only had the non-dev packages in the solver request

File

vendor/composer/composer/src/Composer/Installer.php, line 878

Class

Installer

@author Jordi Boggiano <j.boggiano@seld.be> @author Beau Simensen <beau@dflydev.com> @author Konstantin Kudryashov <ever.zet@gmail.com> @author Nils Adermann <naderman@naderman.de>

Namespace

Composer

Code

private function createRepositorySet(bool $forUpdate, PlatformRepository $platformRepo, array $rootAliases = [], ?RepositoryInterface $lockedRepository = null) : RepositorySet {
    if ($forUpdate) {
        $minimumStability = $this->package
            ->getMinimumStability();
        $stabilityFlags = $this->package
            ->getStabilityFlags();
        $requires = array_merge($this->package
            ->getRequires(), $this->package
            ->getDevRequires());
    }
    else {
        $minimumStability = $this->locker
            ->getMinimumStability();
        $stabilityFlags = $this->locker
            ->getStabilityFlags();
        $requires = [];
        foreach ($lockedRepository->getPackages() as $package) {
            $constraint = new Constraint('=', $package->getVersion());
            $constraint->setPrettyString($package->getPrettyVersion());
            $requires[$package->getName()] = $constraint;
        }
    }
    $rootRequires = [];
    foreach ($requires as $req => $constraint) {
        if ($constraint instanceof Link) {
            $constraint = $constraint->getConstraint();
        }
        // skip platform requirements from the root package to avoid filtering out existing platform packages
        if ($this->platformRequirementFilter
            ->isIgnored($req)) {
            continue;
        }
        elseif ($this->platformRequirementFilter instanceof IgnoreListPlatformRequirementFilter) {
            $constraint = $this->platformRequirementFilter
                ->filterConstraint($req, $constraint);
        }
        $rootRequires[$req] = $constraint;
    }
    $this->fixedRootPackage = clone $this->package;
    $this->fixedRootPackage
        ->setRequires([]);
    $this->fixedRootPackage
        ->setDevRequires([]);
    $stabilityFlags[$this->package
        ->getName()] = BasePackage::STABILITIES[VersionParser::parseStability($this->package
        ->getVersion())];
    $repositorySet = new RepositorySet($minimumStability, $stabilityFlags, $rootAliases, $this->package
        ->getReferences(), $rootRequires, $this->temporaryConstraints);
    $repositorySet->addRepository(new RootPackageRepository($this->fixedRootPackage));
    $repositorySet->addRepository($platformRepo);
    if ($this->additionalFixedRepository) {
        // allow using installed repos if needed to avoid warnings about installed repositories being used in the RepositorySet
        // see https://github.com/composer/composer/pull/9574
        $additionalFixedRepositories = $this->additionalFixedRepository;
        if ($additionalFixedRepositories instanceof CompositeRepository) {
            $additionalFixedRepositories = $additionalFixedRepositories->getRepositories();
        }
        else {
            $additionalFixedRepositories = [
                $additionalFixedRepositories,
            ];
        }
        foreach ($additionalFixedRepositories as $additionalFixedRepository) {
            if ($additionalFixedRepository instanceof InstalledRepository || $additionalFixedRepository instanceof InstalledRepositoryInterface) {
                $repositorySet->allowInstalledRepositories();
                break;
            }
        }
        $repositorySet->addRepository($this->additionalFixedRepository);
    }
    return $repositorySet;
}