SlayerBirden\DFCodeGeneration\Command\AbstractApiCommand

Complexity

Total Complexity

10

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

78.13%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getWriter()	0	6	2
A	configure()	0	4	1
A	setConfigProvider()	0	3	1
A	getConfigProvider()	0	3	1
A	execute()	0	5	1
A	initialize()	0	17	3

<?php
declare(strict_types=1);

namespace SlayerBirden\DFCodeGeneration\Command;

use Doctrine\Common\Annotations\AnnotationRegistry;
use SlayerBirden\DFCodeGeneration\Generator\Config\CurrentConfigProviderInterface;
use SlayerBirden\DFCodeGeneration\Writer\OutputWriter;
use SlayerBirden\DFCodeGeneration\Writer\WriteInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Exception\InvalidArgumentException;
use Symfony\Component\Console\Exception\LogicException;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

abstract class AbstractApiCommand extends Command
{
    /**
     * @var OutputInterface
     */
    protected $output;
    /**
     * @var string
     */
    protected $entityClassName;
    /**
     * @var bool
     */
    protected $force;
    /**
     * @var null|WriteInterface
     */
    protected $writer;
    /**
     * @var null|CurrentConfigProviderInterface
     */
    private $configProvider;

    public function __construct(?string $name = null, ?WriteInterface $writer = null, ?CurrentConfigProviderInterface $configProvider = null)
    {
        parent::__construct($name);
        $this->writer = $writer;
        $this->configProvider = $configProvider;
    }

    protected function configure()
    {
        $this->addArgument('entity', InputArgument::REQUIRED, 'Entity class')
            ->addOption('force', 'f', InputOption::VALUE_NONE, 'Without force flag no writes happen (only output).');
    }

    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        // we need to validate before assigning values
        $input->validate();
        $this->output = $output;
        $this->entityClassName = $input->getArgument('entity');

It seems like $input->getArgument('entity') can also be of type string[]. However, the property $entityClassName is declared as type string. Maybe add an additional type check?

        if (!class_exists($this->entityClassName)) {

It seems like $this->entityClassName can also be of type string[]; however, parameter $class_name of class_exists() does only seem to accept string, maybe add an additional type check?

            throw new InvalidArgumentException('Entity Class does not exist.');
        }
        $this->force = $input->getOption('force');
        // If it's not force mode we're using output writer
        if (!$this->force) {
            $this->writer = new OutputWriter($this->output);
        }

        // we need to register the default Annotation loader
        AnnotationRegistry::registerLoader('class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerLoader() has been deprecated: this method is deprecated and will be removed in doctrine/annotations 2.0 autoloading should be deferred to the globally registered autoloader by then. For now, use @example AnnotationRegistry::registerLoader('class_exists')

    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $output->writeln([
            '<error>IMPORTANT: please check all generated files before committing.</error>',
            '<error># You might want to run something like "php-cs-fixer" to make sure formatting is correct.</error>',
        ]);
    }

    /**
     * @return WriteInterface
     */
    protected function getWriter(): WriteInterface
    {
        if ($this->writer === null) {
            throw new LogicException('Writer is not defined!');
        }
        return $this->writer;
    }

    /**
     * @return CurrentConfigProviderInterface|null
     */
    public function getConfigProvider(): ?CurrentConfigProviderInterface
    {
        return $this->configProvider;
    }

    /**
     * @param CurrentConfigProviderInterface $configProvider
     */
    public function setConfigProvider(CurrentConfigProviderInterface $configProvider): void
    {
        $this->configProvider = $configProvider;
    }
}