ExceptionGeneratorCommand::execute() - Code Metrics - Inspection of "Added new test cases" - fabiang/exception-generator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — coverage (8ea179)

by Fabian

created 2023-02-13 15:35 UTC

ExceptionGeneratorCommand::execute() C

↳ Parent: ExceptionGeneratorCommand

Complexity

Conditions	11
Paths	24

Size

Total Lines	94
Code Lines	61

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	64
CRAP Score	11.0004

Importance

Changes

Metric	Value
eloc	61
dl	0
loc	94
ccs	64
cts	65
cp	0.9846
rs	6.7042
c	0
b	0
f	0
cc	11
nc	24
nop	2
crap	11.0004

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Fabiang\ExceptionGenerator\Cli\Command;

use Fabiang\ExceptionGenerator\Generator\CreateException;
use Fabiang\ExceptionGenerator\Generator\RecursiveNamespaceResolver;
use Fabiang\ExceptionGenerator\Generator\RecursiveParentExceptionResolver;
use Fabiang\ExceptionGenerator\Generator\TemplateRenderer;
use Fabiang\ExceptionGenerator\Listener\CreateExceptionListener;
use Fabiang\ExceptionGenerator\TemplateResolver\TemplatePathMatcher;
use Fabiang\ExceptionGenerator\TemplateResolver\TemplateResolver;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\EventDispatcher\EventDispatcher;

use function array_reverse;
use function getcwd;
use function is_array;
use function realpath;
use function substr;

class ExceptionGeneratorCommand extends Command
{
    /**
     * {@inheritDoc}
     */
    protected function configure(): void
    {
        $this->setName('exception-generator')
            ->setDescription('Generates Exception Classes for php files in current dir.')
            ->addArgument(
                'path',
                InputArgument::OPTIONAL,
                'Basepath for generating exception class.'
            )
            ->addOption(
                'overwrite',
                'o',
                InputOption::VALUE_NONE,
                'Force overwriting existing exception classes.'
            )
            ->addOption(
                'template-path',
                't',
                InputOption::VALUE_REQUIRED,
                'Set path for templates you want to use.'
            )
            ->addOption(
                'no-parents',
                'p',
                InputOption::VALUE_NONE,
                'Disable searching for parent exceptions.'
            );
    }

    /**
     * {@inheritDoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        if ($input->getArgument('path')) {
            $path = $this->realpath($input->getArgument('path'));
        } else {
            $path = getcwd();
        }

        /** @var QuestionHelper $questionHelper */
        $questionHelper = $this->getHelper('question');

        $eventDispatcher = new EventDispatcher();
        $eventDispatcher->addSubscriber(new CreateExceptionListener($output, $input, $questionHelper));
        $namespaceResolver = new RecursiveNamespaceResolver($eventDispatcher);

        $namespace           = $namespaceResolver->resolveNamespace($path);
        $templatePathMatcher = new TemplatePathMatcher($path, $this->getApplication()->getHome());
        $templatePathMatcher = new TemplatePathMatcher($path, $this->getApplication()->/** @scrutinizer ignore-call */ getHome());

        $templatePath     = $this->realpath($input->getOption('template-path')) ?: null;
        $templateResolver = new TemplateResolver($templatePath, $templatePathMatcher);

        $exceptionTemplate = $templateResolver->resolve('exception.phtml');
        $interfaceTemplate = $templateResolver->resolve('interface.phtml');

        $useParents = $input->getOption('no-parents') ? false : true;

        $output->writeln('Using path for templates: "' . $templatePath . '"', OutputInterface::VERBOSITY_VERY_VERBOSE);
        $output->writeln('Exception-Path: "' . $exceptionTemplate . '"', OutputInterface::VERBOSITY_VERY_VERBOSE);
        $output->writeln('Interface-Path: "' . $interfaceTemplate . '"', OutputInterface::VERBOSITY_VERY_VERBOSE);

        $templateRenderer = new TemplateRenderer();
        $templateRenderer->addPath('exception', $exceptionTemplate);
        $templateRenderer->addPath('interface', $interfaceTemplate);

        $parentExceptionNamespace = null;

        if (false !== $useParents) {
            $parentExceptionResolver = new RecursiveParentExceptionResolver($eventDispatcher);
            $parentExceptionDirs     = $parentExceptionResolver->resolveExceptionDirs($path);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

            if (is_array($parentExceptionDirs)) {

                $parentExceptionDirs = array_reverse($parentExceptionDirs);
                foreach ($parentExceptionDirs as $parentExceptionDir) {
                    $prevParentNamespace      = $parentExceptionNamespace;
                    $parentExceptionNamespace = $namespaceResolver->resolveNamespace($parentExceptionDir);

                    $output->writeln(
                        'BaseExceptionPath: "' . $parentExceptionDir . '"',
                        OutputInterface::VERBOSITY_VERY_VERBOSE
                    );
                    $output->writeln(
                        'BaseExceptionNamespace: "' . $parentExceptionNamespace . '"',
                        OutputInterface::VERBOSITY_VERY_VERBOSE
                    );

                    $parentExceptionCreator = new CreateException(
                        $eventDispatcher,
                        $templateRenderer,
                        false,
                        $output,
                        $input
                    );

                    $parentExceptionCreator->create(
                        $parentExceptionNamespace,
                        $parentExceptionDir,
                        $prevParentNamespace
                    );
                }
            }
        }

        if (
            $parentExceptionNamespace && false === $useParents ||

            ($parentExceptionNamespace && false !== $useParents)

        ) {
            $output->writeln('BaseExceptionPath: not found/used', OutputInterface::VERBOSITY_VERY_VERBOSE);
        }

        $namespaceQuestion = new Question("Is this the correct namespace: [$namespace]?", $namespace);
        $inputNamespace    = $questionHelper->ask($input, $output, $namespaceQuestion);
        $output->writeln('Namespace set to "' . $inputNamespace . '"');

        $exceptionCreator = new CreateException(
            $eventDispatcher,
            $templateRenderer,
            $input->getOption('overwrite'),
            $output,
        $exceptionCreator = /** @scrutinizer ignore-call */ new CreateException(
            $input
        );

        $exceptionCreator->create($inputNamespace, $path . '/Exception', $parentExceptionNamespace);

        return 0;
    }

    /**
     * Realpath.
     */
    private function realpath(?string $path): string|bool
    {
        if (null === $path) {
            return '';
        }

        // extra check for virtual file system since vfsstream can't handle realpath()
        if (substr($path, 0, 6) === 'vfs://') {
            return $path;
        }

        return realpath($path);
    }
}


fabiang / exception-generator

Branch — coverage (8ea179)

ExceptionGeneratorCommand::execute() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like