Console::configureIO() - Code Metrics - Inspection of "Changes behavior for loading system bootloaders." - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#963)

by butschster
created 2023-08-14 12:48 UTC
Console::configureIO() F

↳ Parent: Console
Complexity

Conditions	20
Paths	180
Size

Total Lines	66
Code Lines	46
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	37
CRAP Score	21.6109
Importance

Changes
Metric	Value
eloc	46
dl	0
loc	66
ccs	37
cts	44
cp	0.8409
rs	3.5
c	0
b	0
f	0
cc	20
nc	180
nop	2
crap	21.6109
How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Spiral\Console;

use Psr\Container\ContainerInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Spiral\Console\Config\ConsoleConfig;
use Spiral\Console\Exception\LocatorException;
use Spiral\Core\Container;
use Spiral\Core\ScopeInterface;
use Spiral\Events\EventDispatcherAwareInterface;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Exception\CommandNotFoundException;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\StreamableInputInterface;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface as SymfonyEventDispatcherInterface;

final class Console
{
    // Undefined response code for command (errors). See below.
    public const CODE_NONE = 102;

    private ?Application $application = null;

    public function __construct(
        private readonly ConsoleConfig $config,
        private readonly ?LocatorInterface $locator = null,
        private readonly ContainerInterface $container = new Container(),
        private readonly ScopeInterface $scope = new Container(),
        private readonly ?EventDispatcherInterface $dispatcher = null
    ) {
    }

    /**
     * Run console application.
     *
     * @throws \Throwable
     */
    public function start(InputInterface $input = new ArgvInput(), OutputInterface $output = new ConsoleOutput()): int
    {
        return $this->scope->runScope(
            [],
            fn () => $this->run(
                $input->getFirstArgument() ?? 'list',
                $input,
                $output
            )->getCode()
        );
    }

    /**
     * Run selected command.
     *
     * @throws \Throwable
     * @throws CommandNotFoundException
     */
    public function run(
        ?string $command,
        array|InputInterface $input = [],
        OutputInterface $output = new BufferedOutput()
    ): CommandOutput {
        $input = \is_array($input) ? new ArrayInput($input) : $input;


        $this->configureIO($input, $output);

        if ($command !== null) {
            $input = new InputProxy($input, ['firstArgument' => $command]);
        }

        $code = $this->scope->runScope([
            InputInterface::class => $input,
            OutputInterface::class => $output,
        ], fn () => $this->getApplication()->doRun($input, $output));

        return new CommandOutput($code ?? self::CODE_NONE, $output);
    }

    /**
     * Get associated Symfony Console Application.
     *
     * @throws LocatorException
     */
    public function getApplication(): Application
    {
        if ($this->application !== null) {
            return $this->application;
        }

        $this->application = new Application($this->config->getName(), $this->config->getVersion());
        $this->application->setCatchExceptions(false);
                            setCatchExceptions(false);
        $this->application->setAutoExit(false);
        if ($this->dispatcher instanceof SymfonyEventDispatcherInterface) {
            $this->application->setDispatcher($this->dispatcher);
        }

        if ($this->locator !== null) {
            $this->addCommands($this->locator->locateCommands());
        }

        // Register user defined commands
        $static = new StaticLocator(
            $this->config->getCommands(),
            $this->config->getInterceptors(),
            $this->container
        );

        $this->addCommands($static->locateCommands());

        return $this->application;
    }

    private function addCommands(iterable $commands): void
    {
        $interceptors = $this->config->getInterceptors();

        foreach ($commands as $command) {
            if ($command instanceof Command) {
                $command->setContainer($this->container);
                $command->setInterceptors($interceptors);
            }

            if ($this->dispatcher !== null && $command instanceof EventDispatcherAwareInterface) {
                $command->setEventDispatcher($this->dispatcher);
            }

            $this->application->add($command);
        }
    }

    /**
     * Extracted in order to manage command lifecycle.
     *
     * @see Application::configureIO()
     */
    private function configureIO(InputInterface $input, OutputInterface $output): void
    {
        if ($input->hasParameterOption(['--ansi'], true)) {
            $output->setDecorated(true);
        } elseif ($input->hasParameterOption(['--no-ansi'], true)) {
            $output->setDecorated(false);
        }

        if ($input->hasParameterOption(['--no-interaction', '-n'], true)) {
            $input->setInteractive(false);
        } elseif (\function_exists('posix_isatty')) {
            $inputStream = null;

            if ($input instanceof StreamableInputInterface) {
                $inputStream = $input->getStream();
            }

            if (!@posix_isatty($inputStream) && false === getenv('SHELL_INTERACTIVE')) {
                $input->setInteractive(false);
            }
        }

        match ($shellVerbosity = (int) getenv('SHELL_VERBOSITY')) {

            -1 => $output->setVerbosity(OutputInterface::VERBOSITY_QUIET),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            1 => $output->setVerbosity(OutputInterface::VERBOSITY_VERBOSE),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            2 => $output->setVerbosity(OutputInterface::VERBOSITY_VERY_VERBOSE),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            3 => $output->setVerbosity(OutputInterface::VERBOSITY_DEBUG),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            default => $shellVerbosity = 0
        };

        if ($input->hasParameterOption(['--quiet', '-q'], true)) {
            $output->setVerbosity(OutputInterface::VERBOSITY_QUIET);
            $shellVerbosity = -1;
        } else {
            if (
                $input->hasParameterOption('-vvv', true)
                || $input->hasParameterOption('--verbose=3', true)
                || 3 === $input->getParameterOption('--verbose', false, true)
            ) {
                $output->setVerbosity(OutputInterface::VERBOSITY_DEBUG);
                $shellVerbosity = 3;
            } elseif (
                $input->hasParameterOption('-vv', true)
                || $input->hasParameterOption('--verbose=2', true)
                || 2 === $input->getParameterOption('--verbose', false, true)
            ) {
                $output->setVerbosity(OutputInterface::VERBOSITY_VERY_VERBOSE);
                $shellVerbosity = 2;
            } elseif (
                $input->hasParameterOption('-v', true)
                || $input->hasParameterOption('--verbose=1', true)
                || $input->hasParameterOption('--verbose', true)
                || $input->getParameterOption('--verbose', false, true)
            ) {
                $output->setVerbosity(OutputInterface::VERBOSITY_VERBOSE);
                $shellVerbosity = 1;
            }
        }

        if (-1 === $shellVerbosity) {
            $input->setInteractive(false);
        }

        \putenv('SHELL_VERBOSITY=' . $shellVerbosity);
        $_ENV['SHELL_VERBOSITY'] = $shellVerbosity;
        $_SERVER['SHELL_VERBOSITY'] = $shellVerbosity;
    }
}

spiral / framework

Pull Request — master (#963)

Console::configureIO() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
