MakeFactory::interact() - Code Metrics - Inspection of "Adds an 'All' option to factory generation that cr..." - zenstruck/foundry - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#247)

unknown

created 2022-02-02 03:47 UTC

MakeFactory::interact() A

↳ Parent: MakeFactory

Complexity

Conditions	4
Paths	5

Size

Total Lines	21
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	4.8437

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	12
c	2
b	0
f	0
dl	0
loc	21
ccs	10
cts	16
cp	0.625
rs	9.8666
cc	4
nc	5
nop	3
crap	4.8437

<?php

namespace Zenstruck\Foundry\Bundle\Maker;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Bundle\MakerBundle\ConsoleStyle;
use Symfony\Bundle\MakerBundle\DependencyBuilder;
use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
use Symfony\Bundle\MakerBundle\Generator;
use Symfony\Bundle\MakerBundle\InputConfiguration;
use Symfony\Bundle\MakerBundle\Maker\AbstractMaker;
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 Zenstruck\Foundry\ModelFactory;

/**
 * @author Kevin Bond <[email protected]>
 */
final class MakeFactory extends AbstractMaker
{
    private const ORM_DEFAULTS = [
        'ARRAY' => '[],',
        'ASCII_STRING' => 'self::faker()->text(),',
        'BIGINT' => 'self::faker()->randomNumber(),',
        'BLOB' => 'self::faker()->text(),',
        'BOOLEAN' => 'self::faker()->boolean(),',
        'DATE' => 'self::faker()->datetime(),',
        'DATE_MUTABLE' => 'self::faker()->datetime(),',
        'DATE_IMMUTABLE' => 'self::faker()->datetime(),',
        'DATETIME_MUTABLE' => 'self::faker()->datetime(),',
        'DATETIME_IMMUTABLE' => 'self::faker()->datetime(),',
        'DATETIMETZ_MUTABLE' => 'self::faker()->datetime(),',
        'DATETIMETZ_IMMUTABLE' => 'self::faker()->datetime(),',
        'DECIMAL' => 'self::faker()->randomFloat(),',
        'FLOAT' => 'self::faker()->randomFloat(),',
        'INTEGER' => 'self::faker()->randomNumber(),',
        'JSON' => '[],',
        'JSON_ARRAY' => '[],',
        'SIMPLE_ARRAY' => '[],',
        'SMALLINT' => 'self::faker()->numberBetween(1, 32767),',
        'STRING' => 'self::faker()->text(),',
        'TEXT' => 'self::faker()->text(),',
        'TIME_MUTABLE' => 'self::faker()->datetime(),',
        'TIME_IMMUTABLE' => 'self::faker()->datetime(),',
    ];

    /** @var ManagerRegistry */
    private $managerRegistry;

    /** @var string[] */
    private $entitiesWithFactories;

    public function __construct(ManagerRegistry $managerRegistry, \Traversable $factories)
    {
        $this->managerRegistry = $managerRegistry;
        $this->entitiesWithFactories = \array_map(
            static function(ModelFactory $factory) {
                return $factory::getEntityClass();
            },
            \iterator_to_array($factories)
        );
    }

    public static function getCommandName(): string
    {
        return 'make:factory';
    }

    public static function getCommandDescription(): string
    {
        return 'Creates a Foundry model factory for a Doctrine entity class';
    }

    public function configureCommand(Command $command, InputConfiguration $inputConfig): void
    {
        $command
            ->setDescription(self::getCommandDescription())
            ->addArgument('entity', InputArgument::OPTIONAL, 'Entity class to create a factory for')
            ->addOption('namespace', null, InputOption::VALUE_REQUIRED, 'Customize the namespace for generated factories', 'Factory')
            ->addOption('test', null, InputOption::VALUE_NONE, 'Create in <fg=yellow>tests/</> instead of <fg=yellow>src/</>')
            ->addOption('all-fields', null, InputOption::VALUE_NONE, 'Create defaults for all entity fields, not only required fields')
        ;

        $inputConfig->setArgumentAsNonInteractive('entity');
    }

    public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void
    {
        if ($input->getArgument('entity')) {
            return;
        }

        if (!$input->getOption('test')) {
            $io->text('// Note: pass <fg=yellow>--test</> if you want to generate factories in your <fg=yellow>tests/</> directory');
            $io->newLine();
        }

        if (!$input->getOption('all-fields')) {
            $io->text('// Note: pass <fg=yellow>--all-fields</> if you want to generate default values for all fields, not only required fields');
            $io->newLine();
        }

        $entity_argument = $command->getDefinition()->getArgument('entity');
        $choices = array_merge($this->entityChoices(), ['All']);
        $entity = $io->choice($entity_argument->getDescription(), $choices);

        $input->setArgument('entity', $entity);
    }

    public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void
    {
        $class_or_all = $input->getArgument('entity');
        switch ($class_or_all) {
            case 'All':
                foreach($this->entityChoices() as $class) {
                    $this->generateEntity($class, $input, $io, $generator);
                }
                break;
            default:
                $this->generateEntity($class_or_all, $input, $io, $generator);
                break;
        }
    }

    /**
     * Generates a single entity factory.
     */
    private function generateEntity(string $class, InputInterface $input, ConsoleStyle $io, Generator $generator) {
        if (!\class_exists($class)) {
            $class = $generator->createClassNameDetails($class, 'Entity\\')->getFullName();
        }

        if (!\class_exists($class)) {
            throw new RuntimeCommandException(\sprintf('Entity "%s" not found.', $input->getArgument('entity')));
        }

        $namespace = $input->getOption('namespace');

        // strip maker's root namespace if set
        if (0 === \mb_strpos($namespace, $generator->getRootNamespace())) {
            $namespace = \mb_substr($namespace, \mb_strlen($generator->getRootNamespace()));
        }

        $namespace = \trim($namespace, '\\');

        // if creating in tests dir, ensure namespace prefixed with Tests\
        if ($input->getOption('test') && 0 !== \mb_strpos($namespace, 'Tests\\')) {
            $namespace = 'Tests\\'.$namespace;
        }

        $entity = new \ReflectionClass($class);
        $factory = $generator->createClassNameDetails($entity->getShortName(), $namespace, 'Factory');

        $repository = new \ReflectionClass($this->managerRegistry->getRepository($entity->getName()));

        if (0 !== \mb_strpos($repository->getName(), $generator->getRootNamespace())) {
            // not using a custom repository
            $repository = null;
        }

        $generator->generateClass(
            $factory->getFullName(),
            __DIR__.'/../Resources/skeleton/Factory.tpl.php',
            [
                'entity' => $entity,
                'defaultProperties' => $this->defaultPropertiesFor($entity->getName(), $input->getOption('all-fields')),
                'repository' => $repository,
            ]
        );

        $generator->writeChanges();

        $this->writeSuccessMessage($io);

        $io->text([
            'Next: Open your new factory and set default values/states.',
            'Find the documentation at https://symfony.com/bundles/ZenstruckFoundryBundle/current/index.html#model-factories',
        ]);
    }

    public function configureDependencies(DependencyBuilder $dependencies): void
    {
        // noop
    }

    private function entityChoices(): array
    {
        $choices = [];

        foreach ($this->managerRegistry->getManagers() as $manager) {
            foreach ($manager->getMetadataFactory()->getAllMetadata() as $metadata) {
                if (!\in_array($metadata->getName(), $this->entitiesWithFactories, true)) {
                    $choices[] = $metadata->getName();
                }
            }
        }

        \sort($choices);

        if (empty($choices)) {
            throw new RuntimeCommandException('No entities or documents found, or none left to make factories for.');
        }

        return $choices;
    }

    private function defaultPropertiesFor(string $class, bool $allFields): iterable
    {
        $em = $this->managerRegistry->getManagerForClass($class);

        if (!$em instanceof EntityManagerInterface) {
            return [];
        }

        $metadata = $em->getClassMetadata($class);
        $ids = $metadata->getIdentifierFieldNames();

        foreach ($metadata->fieldMappings as $property) {
            // ignore identifiers and nullable fields
            if ((!$allFields && ($property['nullable'] ?? false)) || \in_array($property['fieldName'], $ids, true)) {
                continue;
            }

            $type = \mb_strtoupper($property['type']);
            $value = "null, // TODO add {$type} ORM type manually";

            if (\array_key_exists($type, self::ORM_DEFAULTS)) {
                $value = self::ORM_DEFAULTS[$type];
            }

            yield $property['fieldName'] => $value;
        }
    }
}


1		<?php
2
3		namespace Zenstruck\Foundry\Bundle\Maker;
4
5		use Doctrine\ORM\EntityManagerInterface;
6		use Doctrine\Persistence\ManagerRegistry;
7		use Symfony\Bundle\MakerBundle\ConsoleStyle;
8		use Symfony\Bundle\MakerBundle\DependencyBuilder;
9		use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
10		use Symfony\Bundle\MakerBundle\Generator;
11		use Symfony\Bundle\MakerBundle\InputConfiguration;
12		use Symfony\Bundle\MakerBundle\Maker\AbstractMaker;
13		use Symfony\Component\Console\Command\Command;
14		use Symfony\Component\Console\Input\InputArgument;
15		use Symfony\Component\Console\Input\InputInterface;
16		use Symfony\Component\Console\Input\InputOption;
17		use Zenstruck\Foundry\ModelFactory;
18
19		/**
20		* @author Kevin Bond <[email protected]>
21		*/
22		final class MakeFactory extends AbstractMaker
23		{
24		private const ORM_DEFAULTS = [
25	20	'ARRAY' => '[],',
26		'ASCII_STRING' => 'self::faker()->text(),',
27	20	'BIGINT' => 'self::faker()->randomNumber(),',
28	20	'BLOB' => 'self::faker()->text(),',
29		'BOOLEAN' => 'self::faker()->boolean(),',
30	4	'DATE' => 'self::faker()->datetime(),',
31		'DATE_MUTABLE' => 'self::faker()->datetime(),',
32	4	'DATE_IMMUTABLE' => 'self::faker()->datetime(),',
33		'DATETIME_MUTABLE' => 'self::faker()->datetime(),',
34		'DATETIME_IMMUTABLE' => 'self::faker()->datetime(),',
35	20	'DATETIMETZ_MUTABLE' => 'self::faker()->datetime(),',
36		'DATETIMETZ_IMMUTABLE' => 'self::faker()->datetime(),',
37		'DECIMAL' => 'self::faker()->randomFloat(),',
38	20	'FLOAT' => 'self::faker()->randomFloat(),',
39	20	'INTEGER' => 'self::faker()->randomNumber(),',
40	20	'JSON' => '[],',
41		'JSON_ARRAY' => '[],',
42		'SIMPLE_ARRAY' => '[],',
43	20	'SMALLINT' => 'self::faker()->numberBetween(1, 32767),',
44	20	'STRING' => 'self::faker()->text(),',
45		'TEXT' => 'self::faker()->text(),',
46	20	'TIME_MUTABLE' => 'self::faker()->datetime(),',
47		'TIME_IMMUTABLE' => 'self::faker()->datetime(),',
48	20	];
49	12
50		/** @var ManagerRegistry */
51		private $managerRegistry;
52	8
53	4	/** @var string[] */
54	4	private $entitiesWithFactories;
55
56		public function __construct(ManagerRegistry $managerRegistry, \Traversable $factories)
57	8	{
58	8	$this->managerRegistry = $managerRegistry;
59		$this->entitiesWithFactories = \array_map(
60	8	static function(ModelFactory $factory) {
61	8	return $factory::getEntityClass();
62		},
63	20	\iterator_to_array($factories)
64		);
65	20	}
66
67	20	public static function getCommandName(): string
68	4	{
69		return 'make:factory';
70		}
71	20
72	4	public static function getCommandDescription(): string
73		{
74		return 'Creates a Foundry model factory for a Doctrine entity class';
75	16	}
76	16
77	16	public function configureCommand(Command $command, InputConfiguration $inputConfig): void
78	16	{
79	16	$command
80		->setDescription(self::getCommandDescription())
81		->addArgument('entity', InputArgument::OPTIONAL, 'Entity class to create a factory for')
82	16	->addOption('namespace', null, InputOption::VALUE_REQUIRED, 'Customize the namespace for generated factories', 'Factory')
83		->addOption('test', null, InputOption::VALUE_NONE, 'Create in <fg=yellow>tests/</> instead of <fg=yellow>src/</>')
84	16	->addOption('all-fields', null, InputOption::VALUE_NONE, 'Create defaults for all entity fields, not only required fields')
85		;
86	16
87		$inputConfig->setArgumentAsNonInteractive('entity');
88		}
89	16
90	16	public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void
91	16	{
92		if ($input->getArgument('entity')) {
93	16	return;
94	16	}
95
96		if (!$input->getOption('test')) {
97		$io->text('// Note: pass <fg=yellow>--test</> if you want to generate factories in your <fg=yellow>tests/</> directory');
98	16	$io->newLine();
99		}
100	16
101		if (!$input->getOption('all-fields')) {
102	16	$io->text('// Note: pass <fg=yellow>--all-fields</> if you want to generate default values for all fields, not only required fields');
103	16	$io->newLine();
104		}
105
106	16	$entity_argument = $command->getDefinition()->getArgument('entity');
107		$choices = array_merge($this->entityChoices(), ['All']);
108	20	$entity = $io->choice($entity_argument->getDescription(), $choices);
109
110		$input->setArgument('entity', $entity);
111	20	}
112
113	8	public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void
114		{
115	8	$class_or_all = $input->getArgument('entity');
116		switch ($class_or_all) {
117	8	case 'All':
118	8	foreach($this->entityChoices() as $class) {
119	8	$this->generateEntity($class, $input, $io, $generator);
120		}
121		break;
122		default:
123	8	$this->generateEntity($class_or_all, $input, $io, $generator);
124		break;
125	8	}
126		}
127
128		/**
129		* Generates a single entity factory.
130		*/
131		private function generateEntity(string $class, InputInterface $input, ConsoleStyle $io, Generator $generator) {
132		if (!\class_exists($class)) {
133		$class = $generator->createClassNameDetails($class, 'Entity\\')->getFullName();
134		}
135
136		if (!\class_exists($class)) {
137		throw new RuntimeCommandException(\sprintf('Entity "%s" not found.', $input->getArgument('entity')));
138		}
139
140		$namespace = $input->getOption('namespace');
141
142		// strip maker's root namespace if set
143		if (0 === \mb_strpos($namespace, $generator->getRootNamespace())) {
144		$namespace = \mb_substr($namespace, \mb_strlen($generator->getRootNamespace()));
145		}
146
147		$namespace = \trim($namespace, '\\');
148
149		// if creating in tests dir, ensure namespace prefixed with Tests\
150		if ($input->getOption('test') && 0 !== \mb_strpos($namespace, 'Tests\\')) {
151		$namespace = 'Tests\\'.$namespace;
152		}
153
154		$entity = new \ReflectionClass($class);
155		$factory = $generator->createClassNameDetails($entity->getShortName(), $namespace, 'Factory');
156
157		$repository = new \ReflectionClass($this->managerRegistry->getRepository($entity->getName()));
158
159		if (0 !== \mb_strpos($repository->getName(), $generator->getRootNamespace())) {
160		// not using a custom repository
161		$repository = null;
162		}
163
164		$generator->generateClass(
165		$factory->getFullName(),
166		__DIR__.'/../Resources/skeleton/Factory.tpl.php',
167		[
168		'entity' => $entity,
169		'defaultProperties' => $this->defaultPropertiesFor($entity->getName(), $input->getOption('all-fields')),
170		'repository' => $repository,
171		]
172		);
173
174		$generator->writeChanges();
175
176		$this->writeSuccessMessage($io);
177
178		$io->text([
179		'Next: Open your new factory and set default values/states.',
180		'Find the documentation at https://symfony.com/bundles/ZenstruckFoundryBundle/current/index.html#model-factories',
181		]);
182		}
183
184		public function configureDependencies(DependencyBuilder $dependencies): void
185		{
186		// noop
187		}
188
189		private function entityChoices(): array
190		{
191		$choices = [];
192
193		foreach ($this->managerRegistry->getManagers() as $manager) {
194		foreach ($manager->getMetadataFactory()->getAllMetadata() as $metadata) {
195		if (!\in_array($metadata->getName(), $this->entitiesWithFactories, true)) {
196		$choices[] = $metadata->getName();
197		}
198		}
199		}
200
201		\sort($choices);
202
203		if (empty($choices)) {
204		throw new RuntimeCommandException('No entities or documents found, or none left to make factories for.');
205		}
206
207		return $choices;
208		}
209
210		private function defaultPropertiesFor(string $class, bool $allFields): iterable
211		{
212		$em = $this->managerRegistry->getManagerForClass($class);
213
214		if (!$em instanceof EntityManagerInterface) {
215		return [];
216		}
217
218		$metadata = $em->getClassMetadata($class);
219		$ids = $metadata->getIdentifierFieldNames();
220
221		foreach ($metadata->fieldMappings as $property) {
222		// ignore identifiers and nullable fields
223		if ((!$allFields && ($property['nullable'] ?? false)) \|\| \in_array($property['fieldName'], $ids, true)) {
224		continue;
225		}
226
227		$type = \mb_strtoupper($property['type']);
228		$value = "null, // TODO add {$type} ORM type manually";
229
230		if (\array_key_exists($type, self::ORM_DEFAULTS)) {
231		$value = self::ORM_DEFAULTS[$type];
232		}
233
234		yield $property['fieldName'] => $value;
235		}
236		}
237		}
238

zenstruck / foundry

Pull Request — master (#247)

MakeFactory::interact() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like