function Plugin::getMissingRequires

1 call to Plugin::getMissingRequires()

Plugin::postUpdate in vendor/php-http/discovery/src/Composer/Plugin.php

File

vendor/php-http/discovery/src/Composer/Plugin.php, line 243

Class

Plugin

Auto-installs missing implementations.

Namespace

Http\Discovery\Composer

Code

public function getMissingRequires(InstalledRepositoryInterface $repo, array $requires, bool $isProject, array $pinnedAbstractions) : array {
    $allPackages = [];
    $devPackages = method_exists($repo, 'getDevPackageNames') ? array_fill_keys($repo->getDevPackageNames(), true) : [];
    // One must require "php-http/discovery"
    // to opt-in for auto-installation of virtual package implementations
    if (!isset($requires[0]['php-http/discovery'])) {
        $requires = [
            [],
            [],
        ];
    }
    foreach ($repo->getPackages() as $package) {
        $allPackages[$package->getName()] = true;
        if (1 < \count($names = $package->getNames(false))) {
            $allPackages += array_fill_keys($names, false);
            if (isset($devPackages[$package->getName()])) {
                $devPackages += $names;
            }
        }
        if (isset($package->getRequires()['php-http/discovery'])) {
            $requires[(int) isset($devPackages[$package->getName()])] += $package->getRequires();
        }
    }
    $missingRequires = [
        [],
        [],
        [],
    ];
    $versionParser = new VersionParser();
    if (ClassDiscovery::safeClassExists(\Phalcon\Http\Message\RequestFactory::class, false)) {
        $missingRequires[0]['psr/http-factory-implementation'] = [];
        $missingRequires[1]['psr/http-factory-implementation'] = [];
    }
    foreach ($requires as $dev => $rules) {
        $abstractions = [];
        $rules = array_intersect_key(self::PROVIDE_RULES, $rules);
        while ($rules) {
            $abstraction = key($rules);
            if (isset($pinnedAbstractions[$abstraction])) {
                unset($rules[$abstraction]);
                continue;
            }
            $abstractions[] = $abstraction;
            foreach (array_shift($rules) as $candidate => $deps) {
                [
                    $candidate,
                    $version,
                ] = explode(':', $candidate, 2) + [
                    1 => null,
                ];
                if (!isset($allPackages[$candidate])) {
                    continue;
                }
                if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
                    continue;
                }
                if ($isProject && !$dev && isset($devPackages[$candidate])) {
                    $missingRequires[0][$abstraction] = [
                        $candidate,
                    ];
                    $missingRequires[2][$abstraction] = [
                        $candidate,
                    ];
                }
                else {
                    $missingRequires[$dev][$abstraction] = [];
                }
                foreach ($deps as $dep) {
                    if (isset(self::PROVIDE_RULES[$dep])) {
                        $rules[$dep] = self::PROVIDE_RULES[$dep];
                    }
                    elseif (!isset($allPackages[$dep])) {
                        $missingRequires[$dev][$abstraction][] = $dep;
                    }
                    elseif ($isProject && !$dev && isset($devPackages[$dep])) {
                        $missingRequires[0][$abstraction][] = $dep;
                        $missingRequires[2][$abstraction][] = $dep;
                    }
                }
                break;
            }
        }
        while ($abstractions) {
            $abstraction = array_shift($abstractions);
            if (isset($missingRequires[$dev][$abstraction])) {
                continue;
            }
            $candidates = self::PROVIDE_RULES[$abstraction];
            foreach ($candidates as $candidate => $deps) {
                [
                    $candidate,
                    $version,
                ] = explode(':', $candidate, 2) + [
                    1 => null,
                ];
                if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
                    continue;
                }
                if (isset($allPackages[$candidate]) && (!$isProject || $dev || !isset($devPackages[$candidate]))) {
                    continue 2;
                }
            }
            foreach (array_intersect_key(self::STICKYNESS_RULES, $candidates) as $candidate => $stickyRule) {
                [
                    $stickyName,
                    $stickyVersion,
                ] = explode(':', $stickyRule, 2) + [
                    1 => null,
                ];
                if (!isset($allPackages[$stickyName]) || $isProject && !$dev && isset($devPackages[$stickyName])) {
                    continue;
                }
                if (null !== $stickyVersion && !$repo->findPackage($stickyName, $versionParser->parseConstraints($stickyVersion))) {
                    continue;
                }
                $candidates = [
                    $candidate => $candidates[$candidate],
                ];
                break;
            }
            $dep = key($candidates);
            [
                $dep,
            ] = explode(':', $dep, 2);
            $missingRequires[$dev][$abstraction] = [
                $dep,
            ];
            if ($isProject && !$dev && isset($devPackages[$dep])) {
                $missingRequires[2][$abstraction][] = $dep;
            }
        }
    }
    $missingRequires[1] = array_diff_key($missingRequires[1], $missingRequires[0]);
    return $missingRequires;
}