function BaseDependencyCommand::doExecute

Execute the command.

Parameters

bool $inverted Whether to invert matching process (why-not vs why behaviour):

Return value

int Exit code of the operation.

4 calls to BaseDependencyCommand::doExecute()

DependsCommand::execute in vendor/composer/composer/src/Composer/Command/DependsCommand.php

Executes the current command.

DependsCommand::execute in vendor/composer/composer/src/Composer/Command/DependsCommand.php

Executes the current command.

ProhibitsCommand::execute in vendor/composer/composer/src/Composer/Command/ProhibitsCommand.php

Executes the current command.

ProhibitsCommand::execute in vendor/composer/composer/src/Composer/Command/ProhibitsCommand.php

Executes the current command.

File

vendor/composer/composer/src/Composer/Command/BaseDependencyCommand.php, line 58

Class

BaseDependencyCommand

Base implementation for commands mapping dependency relationships.

Namespace

Composer\Command

Code

protected function doExecute(InputInterface $input, OutputInterface $output, bool $inverted = false) : int {
    // Emit command event on startup
    $composer = $this->requireComposer();
    $commandEvent = new CommandEvent(PluginEvents::COMMAND, $this->getName(), $input, $output);
    $composer->getEventDispatcher()
        ->dispatch($commandEvent->getName(), $commandEvent);
    $repos = [];
    $repos[] = new RootPackageRepository(clone $composer->getPackage());
    if ($input->getOption('locked')) {
        $locker = $composer->getLocker();
        if (!$locker->isLocked()) {
            throw new \UnexpectedValueException('A valid composer.lock file is required to run this command with --locked');
        }
        $repos[] = $locker->getLockedRepository(true);
        $repos[] = new PlatformRepository([], $locker->getPlatformOverrides());
    }
    else {
        $localRepo = $composer->getRepositoryManager()
            ->getLocalRepository();
        $rootPkg = $composer->getPackage();
        if (count($localRepo->getPackages()) === 0 && (count($rootPkg->getRequires()) > 0 || count($rootPkg->getDevRequires()) > 0)) {
            $output->writeln('<warning>No dependencies installed. Try running composer install or update, or use --locked.</warning>');
            return 1;
        }
        $repos[] = $localRepo;
        $platformOverrides = $composer->getConfig()
            ->get('platform') ?: [];
        $repos[] = new PlatformRepository([], $platformOverrides);
    }
    $installedRepo = new InstalledRepository($repos);
    // Parse package name and constraint
    $needle = $input->getArgument(self::ARGUMENT_PACKAGE);
    $textConstraint = $input->hasArgument(self::ARGUMENT_CONSTRAINT) ? $input->getArgument(self::ARGUMENT_CONSTRAINT) : '*';
    // Find packages that are or provide the requested package first
    $packages = $installedRepo->findPackagesWithReplacersAndProviders($needle);
    if (empty($packages)) {
        throw new \InvalidArgumentException(sprintf('Could not find package "%s" in your project', $needle));
    }
    // If the version we ask for is not installed then we need to locate it in remote repos and add it.
    // This is needed for why-not to resolve conflicts from an uninstalled version against installed packages.
    $matchedPackage = $installedRepo->findPackage($needle, $textConstraint);
    if (!$matchedPackage) {
        $defaultRepos = new CompositeRepository(RepositoryFactory::defaultRepos($this->getIO(), $composer->getConfig(), $composer->getRepositoryManager()));
        if ($match = $defaultRepos->findPackage($needle, $textConstraint)) {
            $installedRepo->addRepository(new InstalledArrayRepository([
                clone $match,
            ]));
        }
        elseif (PlatformRepository::isPlatformPackage($needle)) {
            $parser = new VersionParser();
            $constraint = $parser->parseConstraints($textConstraint);
            if ($constraint->getLowerBound() !== Bound::zero()) {
                $tempPlatformPkg = new Package($needle, $constraint->getLowerBound()
                    ->getVersion(), $constraint->getLowerBound()
                    ->getVersion());
                $installedRepo->addRepository(new InstalledArrayRepository([
                    $tempPlatformPkg,
                ]));
            }
        }
        else {
            $this->getIO()
                ->writeError('<error>Package "' . $needle . '" could not be found with constraint "' . $textConstraint . '", results below will most likely be incomplete.</error>');
        }
    }
    elseif (PlatformRepository::isPlatformPackage($needle)) {
        $extraNotice = '';
        if (($matchedPackage->getExtra()['config.platform'] ?? false) === true) {
            $extraNotice = ' (version provided by config.platform)';
        }
        $this->getIO()
            ->writeError('<info>Package "' . $needle . ' ' . $textConstraint . '" found in version "' . $matchedPackage->getPrettyVersion() . '"' . $extraNotice . '.</info>');
    }
    // Include replaced packages for inverted lookups as they are then the actual starting point to consider
    $needles = [
        $needle,
    ];
    if ($inverted) {
        foreach ($packages as $package) {
            $needles = array_merge($needles, array_map(static function (Link $link) : string {
                return $link->getTarget();
            }, $package->getReplaces()));
        }
    }
    // Parse constraint if one was supplied
    if ('*' !== $textConstraint) {
        $versionParser = new VersionParser();
        $constraint = $versionParser->parseConstraints($textConstraint);
    }
    else {
        $constraint = null;
    }
    // Parse rendering options
    $renderTree = $input->getOption(self::OPTION_TREE);
    $recursive = $renderTree || $input->getOption(self::OPTION_RECURSIVE);
    $return = $inverted ? 1 : 0;
    // Resolve dependencies
    $results = $installedRepo->getDependents($needles, $constraint, $inverted, $recursive);
    if (empty($results)) {
        $extra = null !== $constraint ? sprintf(' in versions %smatching %s', $inverted ? 'not ' : '', $textConstraint) : '';
        $this->getIO()
            ->writeError(sprintf('<info>There is no installed package depending on "%s"%s</info>', $needle, $extra));
        $return = $inverted ? 0 : 1;
    }
    elseif ($renderTree) {
        $this->initStyles($output);
        $root = $packages[0];
        $this->getIO()
            ->write(sprintf('<info>%s</info> %s %s', $root->getPrettyName(), $root->getPrettyVersion(), $root instanceof CompletePackageInterface ? $root->getDescription() : ''));
        $this->printTree($results);
    }
    else {
        $this->printTable($output, $results);
    }
    if ($inverted && $input->hasArgument(self::ARGUMENT_CONSTRAINT) && !PlatformRepository::isPlatformPackage($needle)) {
        $composerCommand = 'update';
        foreach ($composer->getPackage()
            ->getRequires() as $rootRequirement) {
            if ($rootRequirement->getTarget() === $needle) {
                $composerCommand = 'require';
                break;
            }
        }
        foreach ($composer->getPackage()
            ->getDevRequires() as $rootRequirement) {
            if ($rootRequirement->getTarget() === $needle) {
                $composerCommand = 'require --dev';
                break;
            }
        }
        $this->getIO()
            ->writeError('Not finding what you were looking for? Try calling `composer ' . $composerCommand . ' "' . $needle . ':' . $textConstraint . '" --dry-run` to get another view on the problem.');
    }
    return $return;
}