ComposerRequireChecker\Cli\CheckCommand::execute()

Complexity

Conditions	13
Paths	70

Size

Total Lines	104
Code Lines	64

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	46
CRAP Score	14.4968

Importance

Changes	10
Bugs	1	Features	2

<?php
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        if (!$output->isQuiet()) {
            $output->writeln($this->getApplication()->getLongVersion());
        }

        $composerJson = realpath($input->getArgument('composer-json'));

It seems like $input->getArgument('composer-json') can also be of type string[]; however, parameter $path of realpath() does only seem to accept string, maybe add an additional type check?

        if (false === $composerJson) {
            throw new \InvalidArgumentException('file not found: [' . $input->getArgument('composer-json') . ']');

Are you sure $input->getArgument('composer-json') of type null|string|string[] can be used in concatenation?

        }
        $composerData = $this->getComposerData($composerJson);

        $options = $this->getCheckOptions($input);

        $getPackageSourceFiles = new LocateComposerPackageSourceFiles();
        $getAdditionalSourceFiles = new LocateFilesByGlobPattern();

        $sourcesASTs = $this->getASTFromFilesLocator($input);

        $this->verbose("Collecting used symbols... ", $output);
        $usedSymbols = (new LocateUsedSymbolsFromASTRoots())->__invoke($sourcesASTs(
            (new ComposeGenerators())->__invoke(
                $getPackageSourceFiles($composerData, dirname($composerJson)),
                $getAdditionalSourceFiles($options->getScanFiles(), dirname($composerJson))
            )
        ));
        $this->verbose("found " . count($usedSymbols) . " symbols.", $output, true);


        $this->verbose("Collecting defined extension symbols... ", $output);
        $definedExtensionSymbols = (new LocateDefinedSymbolsFromExtensions())->__invoke(
            (new DefinedExtensionsResolver())->__invoke($composerJson, $options->getPhpCoreExtensions())
        );
        $this->verbose("found " . count($definedExtensionSymbols) . " symbols.", $output, true);

        try {
            $locator = new MakeLocatorForComposerJsonAndInstalledJson();
            $astLocator = (new BetterReflection())->astLocator();
            $composerLocator = $locator(dirname($composerJson), $astLocator);
            $classReflector = new ClassReflector($composerLocator);
            $functionReflector = new FunctionReflector($composerLocator, $classReflector);
            $constantReflector = new ConstantReflector($composerLocator, $classReflector);
        } catch (MissingComposerJson $missingComposerJson) {
            $message = 'The composer dependencies have not been installed, run composer install/update first';
            throw new DependenciesNotInstalledException($message);
        }

        $whiteList = $options->getSymbolWhitelist();
        $unknownSymbols = [];
        foreach ($usedSymbols as $usedSymbol) {
            if (in_array($usedSymbol, $whiteList)) {
                continue;
            }

            if (in_array($usedSymbol, $definedExtensionSymbols)) {
                continue;
            }

            try {
                $classReflector->reflect($usedSymbol);

                continue;
            } catch (IdentifierNotFound $ignore) {
                // void
            }

            try {
                $functionReflector->reflect($usedSymbol);

                continue;
            } catch (IdentifierNotFound $ignore) {
                // void
            }

            try {
                $constantReflector->reflect($usedSymbol);

                continue;
            } catch (IdentifierNotFound $ignore) {
                // void
            }

            $unknownSymbols[] = $usedSymbol;
        }

        if (!$unknownSymbols) {
            $output->writeln("There were no unknown symbols found.");
            return 0;
        }

        $output->writeln("The following unknown symbols were found:");
        $table = new Table($output);
        $table->setHeaders(['unknown symbol', 'guessed dependency']);
        $guesser = new DependencyGuesser($options);
        foreach ($unknownSymbols as $unknownSymbol) {
            $guessedDependencies = [];
            foreach ($guesser($unknownSymbol) as $guessedDependency) {
                $guessedDependencies[] = $guessedDependency;
            }
            $table->addRow([$unknownSymbol, implode("\n", $guessedDependencies)]);
        }
        $table->render();

        return ((int)(bool)$unknownSymbols);
    }