function PoolBuilder::loadPackage

Parameters

RepositoryInterface[] $repositories:

2 calls to PoolBuilder::loadPackage()

PoolBuilder::buildPool in vendor/composer/composer/src/Composer/DependencyResolver/PoolBuilder.php

PoolBuilder::loadPackagesMarkedForLoading in vendor/composer/composer/src/Composer/DependencyResolver/PoolBuilder.php

File

vendor/composer/composer/src/Composer/DependencyResolver/PoolBuilder.php, line 449

Class

PoolBuilder

@author Nils Adermann <naderman@naderman.de>

Namespace

Composer\DependencyResolver

Code

private function loadPackage(Request $request, array $repositories, BasePackage $package, bool $propagateUpdate) : void {
    $index = $this->indexCounter++;
    $this->packages[$index] = $package;
    if ($package instanceof AliasPackage) {
        $this->aliasMap[spl_object_hash($package->getAliasOf())][$index] = $package;
    }
    $name = $package->getName();
    // we're simply setting the root references on all versions for a name here and rely on the solver to pick the
    // right version. It'd be more work to figure out which versions and which aliases of those versions this may
    // apply to
    if (isset($this->rootReferences[$name])) {
        // do not modify the references on already locked or fixed packages
        if (!$request->isLockedPackage($package) && !$request->isFixedPackage($package)) {
            $package->setSourceDistReferences($this->rootReferences[$name]);
        }
    }
    // if propagateUpdate is false we are loading a fixed or locked package, root aliases do not apply as they are
    // manually loaded as separate packages in this case
    //
    // packages in pathRepoUnlocked however need to also load root aliases, they have propagateUpdate set to
    // false because their deps should not be unlocked, but that is irrelevant for root aliases
    if (($propagateUpdate || isset($this->pathRepoUnlocked[$package->getName()])) && isset($this->rootAliases[$name][$package->getVersion()])) {
        $alias = $this->rootAliases[$name][$package->getVersion()];
        if ($package instanceof AliasPackage) {
            $basePackage = $package->getAliasOf();
        }
        else {
            $basePackage = $package;
        }
        if ($basePackage instanceof CompletePackage) {
            $aliasPackage = new CompleteAliasPackage($basePackage, $alias['alias_normalized'], $alias['alias']);
        }
        else {
            $aliasPackage = new AliasPackage($basePackage, $alias['alias_normalized'], $alias['alias']);
        }
        $aliasPackage->setRootPackageAlias(true);
        $newIndex = $this->indexCounter++;
        $this->packages[$newIndex] = $aliasPackage;
        $this->aliasMap[spl_object_hash($aliasPackage->getAliasOf())][$newIndex] = $aliasPackage;
    }
    foreach ($package->getRequires() as $link) {
        $require = $link->getTarget();
        $linkConstraint = $link->getConstraint();
        // if the required package is loaded as a locked package only and hasn't had its deps analyzed
        if (isset($this->skippedLoad[$require])) {
            // if we're doing a full update or this is a partial update with transitive deps and we're currently
            // looking at a package which needs to be updated we need to unlock the package we now know is a
            // dependency of another package which we are trying to update, and then attempt to load it again
            if ($propagateUpdate && $request->getUpdateAllowTransitiveDependencies()) {
                $skippedRootRequires = $this->getSkippedRootRequires($request, $require);
                if ($request->getUpdateAllowTransitiveRootDependencies() || 0 === \count($skippedRootRequires)) {
                    $this->unlockPackage($request, $repositories, $require);
                    $this->markPackageNameForLoading($request, $require, $linkConstraint);
                }
                else {
                    foreach ($skippedRootRequires as $rootRequire) {
                        if (!isset($this->updateAllowWarned[$rootRequire])) {
                            $this->updateAllowWarned[$rootRequire] = true;
                            $this->io
                                ->writeError('<warning>Dependency ' . $rootRequire . ' is also a root requirement. Package has not been listed as an update argument, so keeping locked at old version. Use --with-all-dependencies (-W) to include root dependencies.</warning>');
                        }
                    }
                }
            }
            elseif (isset($this->pathRepoUnlocked[$require]) && !isset($this->loadedPackages[$require])) {
                // if doing a partial update and a package depends on a path-repo-unlocked package which is not referenced by the root, we need to ensure it gets loaded as it was not loaded by the request's root requirements
                // and would not be loaded above if update propagation is not allowed (which happens if the requirer is itself a path-repo-unlocked package) or if transitive deps are not allowed to be unlocked
                $this->markPackageNameForLoading($request, $require, $linkConstraint);
            }
        }
        else {
            $this->markPackageNameForLoading($request, $require, $linkConstraint);
        }
    }
    // if we're doing a partial update with deps we also need to unlock packages which are being replaced in case
    // they are currently locked and thus prevent this updateable package from being installable/updateable
    if ($propagateUpdate && $request->getUpdateAllowTransitiveDependencies()) {
        foreach ($package->getReplaces() as $link) {
            $replace = $link->getTarget();
            if (isset($this->loadedPackages[$replace], $this->skippedLoad[$replace])) {
                $skippedRootRequires = $this->getSkippedRootRequires($request, $replace);
                if ($request->getUpdateAllowTransitiveRootDependencies() || 0 === \count($skippedRootRequires)) {
                    $this->unlockPackage($request, $repositories, $replace);
                    // the replaced package only needs to be loaded if something else requires it
                    $this->markPackageNameForLoadingIfRequired($request, $replace);
                }
                else {
                    foreach ($skippedRootRequires as $rootRequire) {
                        if (!isset($this->updateAllowWarned[$rootRequire])) {
                            $this->updateAllowWarned[$rootRequire] = true;
                            $this->io
                                ->writeError('<warning>Dependency ' . $rootRequire . ' is also a root requirement. Package has not been listed as an update argument, so keeping locked at old version. Use --with-all-dependencies (-W) to include root dependencies.</warning>');
                        }
                    }
                }
            }
        }
    }
}