GenerateBuilderCommand::getBuildingClass() - Code Metrics - Inspection of "Working on class loader and types..." - RunOpenCode/abstract-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ed922a...ce73d9 )

by Nikola

created 2017-06-24 14:52 UTC

GenerateBuilderCommand::getBuildingClass() B

↳ Parent: GenerateBuilderCommand

Complexity

Conditions	4
Paths	6

Size

Total Lines	23
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	23
ccs	0
cts	17
cp	0
rs	8.7972
c	1
b	0
f	0
cc	4
eloc	12
nc	6
nop	0
crap	20

<?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\Ast\ClassLoader;
use RunOpenCode\AbstractBuilder\Ast\ClassMetadata;
use RunOpenCode\AbstractBuilder\Ast\MethodMetadata;
use RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException;
use RunOpenCode\AbstractBuilder\Exception\RuntimeException;
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 Style
     */
    private $style;

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

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

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

    /**
     * {@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 ClassLoader();
    }

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

        $this->style->displayLogo();

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

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

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

            $methods = $this->getMethods($buildingClass, $builderClass);
            $this->style->info(sprintf('Methods to generate are: "%s".', implode('", "', $methods)));

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

    }

    /**
     * Get class name for which skeleton should be built.
     *
     * @return ClassMetadata
     *
     * @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);
        }

        $metadata = $this->loader->load($class);

        if (null === ($constructor = $metadata->getConstructor())) {
            throw new InvalidArgumentException('Builder class can not be generated for class without constructor.');
        }

        if (0 === count($constructor->getParameters())) {
            throw new InvalidArgumentException('Builder class can not be generated for class with constructor without arguments.');
        }

        return $metadata;
    }

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

        if (null === $class) {
            $default = sprintf('%sBuilder', $buildingClass->getFqcn());
            $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);
        }

        if (class_exists($class, true) || file_exists($class)) {
            return $this->loader->load($class);
        }

        return $this->getBuilderLocation(ClassMetadata::create($class));
    }

    /**
     * Get builder class location.
     *
     * @param ClassMetadata $builderClass
     *
     * @return ClassMetadata
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
     * @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
     */
    private function getBuilderLocation(ClassMetadata $builderClass)
    {
        $location = $this->input->getArgument('location');

        if (null !== $location && $builderClass->isAutoloadable() && $location !== $builderClass->getFilename()) {
            throw new InvalidArgumentException(sprintf('You can not provide new file location for existing builder ("%s" to "%s").', $builderClass->getFilename(), $location));
        }

        if ($builderClass->isAutoloadable()) {
            return $builderClass;
        }

        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));
            }

            $location = $path.'/'.end(explode('/', $builderClass->getClass())).'.php';

        }

        return ClassMetadata::clone($builderClass, [ 'filename' => $location ]);
    }

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

        $parameters = $buildingClass->getConstructor()->getParameters();

        foreach ($parameters as $parameter) {
            $getter = sprintf('get%s', ucfirst($parameter->getName()));
            $setter = sprintf('set%s', ucfirst($parameter->getName()));

            if (!$builderClass->hasPublicMethod($getter)) {

                $methods[] = new MethodMetadata($getter, false, false, MethodMetadata::PUBLIC, $parameter->getType(), false, false, []);
            }

            if (!$builderClass->hasPublicMethod($setter)) {

                $methods[] = new MethodMetadata($setter, false, false, MethodMetadata::PUBLIC, $builderClass, false, false, [$parameter]);;
            }
        }

        $methods = array_map(function(MethodMetadata $method) {
            return new MethodChoice($method);
        }, $methods);


        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;
    }
}


1		<?php
2		/*
3		* This file is part of the Abstract builder package, an RunOpenCode project.
4		*
5		* (c) 2017 RunOpenCode
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10		namespace RunOpenCode\AbstractBuilder\Command;
11
12		use RunOpenCode\AbstractBuilder\Ast\ClassLoader;
13		use RunOpenCode\AbstractBuilder\Ast\ClassMetadata;
14		use RunOpenCode\AbstractBuilder\Ast\MethodMetadata;
15		use RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException;
16		use RunOpenCode\AbstractBuilder\Exception\RuntimeException;
17		use Symfony\Component\Console\Command\Command;
18		use Symfony\Component\Console\Input\InputArgument;
19		use Symfony\Component\Console\Input\InputInterface;
20		use Symfony\Component\Console\Input\InputOption;
21		use Symfony\Component\Console\Output\OutputInterface;
22		use Symfony\Component\Console\Question\ChoiceQuestion;
23		use Symfony\Component\Console\Question\Question;
24
25		/**
26		* Class GenerateBuilderCommand
27		*
28		* @package RunOpenCode\AbstractBuilder\Command
29		*/
30		class GenerateBuilderCommand extends Command
31		{
32		/**
33		* @var Style
34		*/
35		private $style;
36
37		/**
38		* @var InputInterface
39		*/
40		private $input;
41
42		/**
43		* @var OutputInterface
44		*/
45		private $output;
46
47		/**
48		* @var ClassLoader
49		*/
50		private $loader;
51
52		/**
53		* {@inheritdoc}
54		*/
55		protected function configure()
56		{
57		$this
58		->setName('runopencode:generate:builder')
59		->setDescription('Generates builder class skeleton for provided class.')
60		->addArgument('class', InputArgument::OPTIONAL, 'Full qualified class name of building object that can be autoloaded, or path to file with class definition.')
61		->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.')
62		->addArgument('location', InputArgument::OPTIONAL, 'Path to location of file where builder class will be saved.')
63		->addOption('all', '-a', InputOption::VALUE_NONE, 'Generate all methods by default.')
64		->addOption('withReturnTypes', '-r', InputOption::VALUE_NONE, 'Generate methods with return types declarations.');
65
66		$this->loader = new ClassLoader();
67		}
68
69		/**
70		* {@inheritdoc}
71		*/
72		public function execute(InputInterface $input, OutputInterface $output)
73		{
74		$this->input = $input;
75		$this->output = $output;
76		$this->style = new Style($input, $output);
77
78		$this->style->displayLogo();
79
80		$this->style->title('Generate builder class');
81
82		try {
83		/**
84		* @var ClassMetadata $buildingClass
85		*/
86		$buildingClass = $this->getBuildingClass();
87		$this->style->info(sprintf('Builder class for class "%s" will be generated.', $buildingClass->getFqcn()));
88
89		/**
90		* @var ClassMetadata $builderClass
91		*/
92		$builderClass = $this->getBuilderClass($buildingClass);
93		$this->style->info(sprintf('Full qualified namespace for builder class is "%s".', $builderClass->getFqcn()));
94		$this->style->info(sprintf('Path to file where builder class will be saved is "%s".', $builderClass->getFilename()));
95		$builderClass->isAutoloadable() ? $this->style->info('Existing builder class will be updated.') : $this->style->info('New builder class will be created.');
96
97		$methods = $this->getMethods($buildingClass, $builderClass);
98		$this->style->info(sprintf('Methods to generate are: "%s".', implode('", "', $methods)));
99
100		} catch (\Exception $e) {
101		$this->style->error($e->getMessage());
102		return 0;
103		}
104
105		}
106
107		/**
108		* Get class name for which skeleton should be built.
109		*
110		* @return ClassMetadata
111		*
112		* @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
113		*/
114		private function getBuildingClass()
115		{
116		$class = $this->input->getArgument('class');
117
118		if (null === $class) {
119		$helper = $this->getHelper('question');
120		$question = new Question('Enter full qualified class name, or path to file with class, for which you want to generate builder class: ', null);
121
122		$class = $helper->ask($this->input, $this->output, $question);
123		}
124
125		$metadata = $this->loader->load($class);
126
127		if (null === ($constructor = $metadata->getConstructor())) {
128		throw new InvalidArgumentException('Builder class can not be generated for class without constructor.');
129		}
130
131		if (0 === count($constructor->getParameters())) {
132		throw new InvalidArgumentException('Builder class can not be generated for class with constructor without arguments.');
133		}
134
135		return $metadata;
136		}
137
138		/**
139		* Get class name for builder class.
140		*
141		* @param ClassMetadata $buildingClass
142		*
143		* @return ClassMetadata
144		*
145		* @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
146		*/
147		private function getBuilderClass(ClassMetadata $buildingClass)
148		{
149		$class = $this->input->getArgument('builder');
150
151		if (null === $class) {
152		$default = sprintf('%sBuilder', $buildingClass->getFqcn());
153		$helper = $this->getHelper('question');
154		$question = new Question(sprintf('Enter full qualified class name of your builder class (default: "%s"): ', $default), $default);
155
156		$class = $helper->ask($this->input, $this->output, $question);
157		}
158
159		if (class_exists($class, true) \|\| file_exists($class)) {
160		return $this->loader->load($class);
161		}
162
163		return $this->getBuilderLocation(ClassMetadata::create($class));
164		}
165
166		/**
167		* Get builder class location.
168		*
169		* @param ClassMetadata $builderClass
170		*
171		* @return ClassMetadata
172		*
173		* @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
174		* @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
175		*/
176		private function getBuilderLocation(ClassMetadata $builderClass)
177		{
178		$location = $this->input->getArgument('location');
179
180		if (null !== $location && $builderClass->isAutoloadable() && $location !== $builderClass->getFilename()) {
181		throw new InvalidArgumentException(sprintf('You can not provide new file location for existing builder ("%s" to "%s").', $builderClass->getFilename(), $location));
182		}
183
184		if ($builderClass->isAutoloadable()) {
185		return $builderClass;
186		}
187
188		if (null === $location) {
189		$helper = $this->getHelper('question');
190		$question = new Question('Enter path to directory where you want to store builder class: ', null);
191
192		$path = str_replace('\\', '/', ltrim($helper->ask($this->input, $this->output, $question), '/'));
193
194		if (!is_dir($path)) {
195		throw new RuntimeException(sprintf('Provided path "%s" is not path to directory.', $path));
196		}
197
198		if (!is_writable($path)) {
199		throw new RuntimeException(sprintf('Directory on path "%s" is not writeable.', $path));
200		}
201
202		$location = $path.'/'.end(explode('/', $builderClass->getClass())).'.php';
		0 ignored issues – show Bug introduced 2017-06-22 10:01 UTC by Report Bug Copy Issue Report `explode('/', $builderClass->getClass())` cannot be passed to `end()` as the parameter `$array` expects a reference. Loading history...
203		}
204
205		return ClassMetadata::clone($builderClass, [ 'filename' => $location ]);
206		}
207
208		/**
209		* Get methods which ought to be generated.
210		*
211		* @param ClassMetadata $buildingClass
212		* @param ClassMetadata $builderClass
213		*
214		* @return array
215		*
216		* @throws \RunOpenCode\AbstractBuilder\Exception\RuntimeException
217		*/
218		private function getMethods(ClassMetadata $buildingClass, ClassMetadata $builderClass)
219		{
220		$methods = [];
221
222		$parameters = $buildingClass->getConstructor()->getParameters();
223
224		foreach ($parameters as $parameter) {
225		$getter = sprintf('get%s', ucfirst($parameter->getName()));
226		$setter = sprintf('set%s', ucfirst($parameter->getName()));
227
228	View Code Duplication	if (!$builderClass->hasPublicMethod($getter)) {
		0 ignored issues – show Duplication introduced 2017-06-24 14:55 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
229		$methods[] = new MethodMetadata($getter, false, false, MethodMetadata::PUBLIC, $parameter->getType(), false, false, []);
230		}
231
232	View Code Duplication	if (!$builderClass->hasPublicMethod($setter)) {
		0 ignored issues – show Duplication introduced 2017-06-24 14:55 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
233		$methods[] = new MethodMetadata($setter, false, false, MethodMetadata::PUBLIC, $builderClass, false, false, [$parameter]);;
234		}
235		}
236
237		$methods = array_map(function(MethodMetadata $method) {
238		return new MethodChoice($method);
239		}, $methods);
240
241
242		if (true !== $this->input->getOption('all')) {
243
244		$helper = $this->getHelper('question');
245
246		$question = new ChoiceQuestion(
247		'Choose which methods you want to generate for your builder class (separate choices with coma, enter none for all choices):',
248		$methods,
249		implode(',', array_keys($methods))
250		);
251
252		$question->setMultiselect(true);
253
254		$selected = $helper->ask($this->input, $this->output, $question);
255
256		$methods = array_filter($methods, function(MethodChoice $choice) use ($selected) {
257		return in_array((string) $choice, $selected, true);
258		});
259		}
260
261		if (0 === count($methods)) {
262		throw new RuntimeException('There is no method to generate.');
263		}
264
265		return $methods;
266		}
267		}
268

RunOpenCode / abstract-builder

Push — master ( ed922a...ce73d9 )

GenerateBuilderCommand::getBuildingClass() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like