RunOpenCode\AbstractBuilder\Command\GenerateBuilderCommand

Complexity

Total Complexity

28

Size/Duplication

Total Lines	275
Duplicated Lines	2.18 %

Coupling/Cohesion

Components	1
Dependencies	16

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	14	1
B	execute()	0	35	3
B	getBuildingClass()	3	32	6
C	getBuilderClass()	3	45	8
B	generateBuilder()	0	27	4
B	getMethodsToGenerate()	0	44	6

<?php
/*
 * This file is part of the Abstract builder package, an RunOpenCode project.
 *
 * (c) 2017 RunOpenCode
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace RunOpenCode\AbstractBuilder\Command;

use RunOpenCode\AbstractBuilder\AbstractBuilder;
use RunOpenCode\AbstractBuilder\Ast\Metadata\ClassMetadata;
use RunOpenCode\AbstractBuilder\Ast\MetadataLoader;
use RunOpenCode\AbstractBuilder\Command\Question\ClassChoice;
use RunOpenCode\AbstractBuilder\Command\Question\GetterMethodChoice;
use RunOpenCode\AbstractBuilder\Command\Question\MethodChoice;
use RunOpenCode\AbstractBuilder\Command\Question\SetterMethodChoice;
use RunOpenCode\AbstractBuilder\Command\Style\RunOpenCodeStyle;
use RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException;
use RunOpenCode\AbstractBuilder\Exception\RuntimeException;
use RunOpenCode\AbstractBuilder\Generator\BuilderGenerator;
use RunOpenCode\AbstractBuilder\ReflectiveAbstractBuilder;
use RunOpenCode\AbstractBuilder\Utils\ClassUtils;
use Symfony\Component\Console\Command\Command;
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\ChoiceQuestion;
use Symfony\Component\Console\Question\Question;

/**
 * Class GenerateBuilderCommand
 *
 * @package RunOpenCode\AbstractBuilder\Command
 */
class GenerateBuilderCommand extends Command
{
    /**
     * @var RunOpenCodeStyle
     */
    private $style;

    /**
     * @var InputInterface
     */
    private $input;

    /**
     * @var OutputInterface
     */
    private $output;

    /**
     * @var MetadataLoader
     */
    private $loader;

    /**
     * @var BuilderGenerator
     */
    private $generator;

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
            ->setName('runopencode:generate:builder')
            ->setDescription('Generates builder class skeleton for provided class.')
            ->addArgument('class', InputArgument::OPTIONAL, 'Full qualified class name of building object that can be autoloaded, or path to file with class definition.')
            ->addArgument('builder', InputArgument::OPTIONAL, 'Full qualified class name of builder class can be autoloaded, or it will be autoloaded, or path to file with class definition.')
            ->addArgument('location', InputArgument::OPTIONAL, 'Path to location of file where builder class will be saved.')
            ->addOption('all', '-a', InputOption::VALUE_NONE, 'Generate all methods by default.')
            ->addOption('withReturnTypes', '-r', InputOption::VALUE_NONE, 'Generate methods with return types declarations.');

        $this->loader = new MetadataLoader();
        $this->generator = new BuilderGenerator();
    }

    /**
     * {@inheritdoc}
     */
    public function execute(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->output = $output;
        $this->style = new RunOpenCodeStyle($input, $output);

        $this->style->displayLogo();

        $this->style->title('Generate builder class');

        try {
            /**
             * @var ClassChoice $buildingClassChoice
             */
            $buildingClassChoice = $this->getBuildingClass();
            $this->style->info(sprintf('Builder class for class "%s" will be generated.', $buildingClassChoice->getClass()->getName()));

            /**
             * @var ClassChoice $builderClassChoice
             */
            $builderClassChoice = $this->getBuilderClass($buildingClassChoice);
            $this->style->info(sprintf('Full qualified namespace for builder class is "%s".', $builderClassChoice->getClass()->getName()));
            $this->style->info(sprintf('Path to file where builder class will be saved is "%s".', $builderClassChoice->getFile()->getFilename()));
            $builderClassChoice->getClass()->isAutoloadable() ? $this->style->info('Existing builder class will be updated.') : $this->style->info('New builder class will be created.');

            $methods = $this->getMethodsToGenerate($buildingClassChoice, $builderClassChoice);

$buildingClassChoice is of type object<RunOpenCode\AbstractBuilder\Command\Question\ClassChoice>, but the function expects a object<RunOpenCode\AbstractBuilder\Ast\Metadata\ClassMetadata>.

$builderClassChoice is of type object<RunOpenCode\AbstractBuilder\Command\Question\ClassChoice>, but the function expects a object<RunOpenCode\AbstractBuilder\Ast\Metadata\ClassMetadata>.

            $this->style->info('Methods to generate are:');
            $this->style->ul($methods);

        } catch (\Exception $e) {
            $this->style->error($e->getMessage());
            return 0;
        }

    }

    /**
     * Get class name for which skeleton should be built.
     *
     * @return ClassChoice
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
     * @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
     */
    private function getBuildingClass()
    {
        $class = $this->input->getArgument('class');

        if (null === $class) {
            $helper = $this->getHelper('question');
            $question = new Question('Enter full qualified class name, or path to file with class, for which you want to generate builder class: ', null);

            $class = $helper->ask($this->input, $this->output, $question);
        }

        $fileMetadata = $this->loader->load($class);
        $classMetadata = null;

        if (class_exists($class)) {
            $classMetadata = $fileMetadata->getClass($class);
        }

        if (1 === count($fileMetadata->getClasses())) {
            $classMetadata = array_values($fileMetadata->getClasses())[0];
        }

        if (null === $classMetadata) {

This code seems to be duplicated across your project.

            throw new RuntimeException(sprintf('It is not possible to extract single class metadata from "%s", found %s definition(s).', $class, count($fileMetadata->getClasses())));
        }

        if (!ClassUtils::isBuildable($classMetadata)) {
            throw new InvalidArgumentException(sprintf('Builder class can not be generated for "%s", class has to have constructor with some parameters.', $classMetadata->getName()));
        }

        return new ClassChoice($fileMetadata, $classMetadata);
    }

    /**
     * Get class name for builder class.
     *
     * @param ClassChoice $buildingClass
     *
     * @return ClassChoice
     * @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
     */
    private function getBuilderClass(ClassChoice $buildingClass)
    {
        $class = $this->input->getArgument('builder');

        if (null === $class) {
            $default = sprintf('%sBuilder', $buildingClass->getClass()->getShortName());
            $helper = $this->getHelper('question');
            $question = new Question(sprintf('Enter full qualified class name of your builder class (default: "%s"): ', $default), $default);

            $class = $helper->ask($this->input, $this->output, $question);
        }

        $classChoice = null;

        if (class_exists($class, true)) {
            $fileMetadata = $this->loader->load($class);
            $classMetadata = $fileMetadata->getClass($class);
            $classChoice = new ClassChoice($fileMetadata, $classMetadata);

            if (null !== $this->input->getArgument('location')) {
                throw new InvalidArgumentException('Builder class already exists and its location can not be changed.');
            }
        }

        if (file_exists($class)) {
            $fileMetadata = $this->loader->load($class);

            if (1 !== count($fileMetadata->getClasses())) {

This code seems to be duplicated across your project.

                throw new RuntimeException(sprintf('It is not possible to extract single class metadata from "%s", found %s definition(s).', $class, count($fileMetadata->getClasses())));
            }

            $classMetadata = array_values($fileMetadata->getClasses())[0];
            $classChoice = new ClassChoice($fileMetadata, $classMetadata);
        }

        if (null === $classChoice) {
            $classChoice = $this->generateBuilder($buildingClass, $class);
        }

        if (!ClassUtils::isBuilder($classChoice->getClass())) {
            throw new RuntimeException(sprintf('Builder class must implement either "%s" or "%s", none of those detected for "%s".', ReflectiveAbstractBuilder::class, AbstractBuilder::class, $classChoice->getClass()->getName()));
        }

        return $classChoice;
    }

    /**
     * Generate new builder class.
     *
     * @param ClassChoice $buildingClass
     * @param string $builderClassName
     *
     * @return ClassChoice
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
     * @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
     */
    private function generateBuilder(ClassChoice $buildingClass, $builderClassName)
    {
        $location = $this->input->getArgument('location');

        if (null === $location) {
            $helper = $this->getHelper('question');
            $question = new Question('Enter path to directory where you want to store builder class: ', null);

            $path = str_replace('\\', '/', ltrim($helper->ask($this->input, $this->output, $question), '/'));

            if (!is_dir($path)) {
                throw new RuntimeException(sprintf('Provided path "%s" is not path to directory.', $path));
            }

            if (!is_writable($path)) {
                throw new RuntimeException(sprintf('Directory on path "%s" is not writeable.', $path));
            }

            $parts = explode('/', $builderClassName);
            $location = $path.'/'.end($parts).'.php';
        }

        $fileMetadata = $this->generator->create($buildingClass, $location, $builderClassName);
        $classMetadata = array_values($fileMetadata->getClasses())[0];

        return new ClassChoice($fileMetadata, $classMetadata);
    }

    /**
     * Get methods which ought to be generated.
     *
     * @param ClassMetadata $buildingClass
     * @param ClassMetadata $builderClass
     *
     * @return MethodChoice[]
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
     */
    private function getMethodsToGenerate(ClassMetadata $buildingClass, ClassMetadata $builderClass)
    {
        $methods = [];

        $parameters = $buildingClass->getPublicMethod('__construct')->getParameters();

        foreach ($parameters as $parameter) {
            $getter = new GetterMethodChoice($parameter);
            $setter = new SetterMethodChoice($parameter);

            if (!$builderClass->hasPublicMethod($getter->getMethodName())) {
                $methods[] = $getter;
            }

            if (!$builderClass->hasPublicMethod($setter->getMethodName())) {
                $methods[] = $setter;
            }
        }

        if (true !== $this->input->getOption('all')) {

            $helper = $this->getHelper('question');

            $question = new ChoiceQuestion(
                'Choose which methods you want to generate for your builder class (separate choices with coma, enter none for all choices):',
                $methods,
                implode(',', array_keys($methods))
            );

            $question->setMultiselect(true);

            $selected = $helper->ask($this->input, $this->output, $question);

            $methods = array_filter($methods, function(MethodChoice $choice) use ($selected) {
                return in_array((string) $choice, $selected, true);
            });
        }

        if (0 === count($methods)) {
            throw new RuntimeException('There is no method to generate.');
        }

        return $methods;
    }
}