Zikula\Bundle\CoreBundle\Maker\ExtensionMaker

Complexity

Total Complexity

17

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getCommandName()	0	3	1
A	generate()	0	22	3
A	__construct()	0	4	1
A	configureCommand()	0	7	1
A	getFilesToGenerate()	0	7	1
A	configureDependencies()	0	13	1
A	generateBlankFiles()	0	17	1
A	generateClasses()	0	24	4
A	getClassesToGenerate()	0	9	1
A	generateFiles()	0	12	2
A	createDirAndAutoload()	0	8	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Zikula package.
 *
 * Copyright Zikula Foundation - https://ziku.la/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zikula\Bundle\CoreBundle\Maker;

use Symfony\Bundle\MakerBundle\ConsoleStyle;
use Symfony\Bundle\MakerBundle\DependencyBuilder;
use Symfony\Bundle\MakerBundle\FileManager;
use Symfony\Bundle\MakerBundle\Generator;
use Symfony\Bundle\MakerBundle\InputConfiguration;
use Symfony\Bundle\MakerBundle\Maker\AbstractMaker;
use Symfony\Bundle\MakerBundle\Str;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Filesystem\Filesystem;
use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaHttpKernelInterface;

class ExtensionMaker extends AbstractMaker
{
    /**
     * @var ZikulaHttpKernelInterface
     */
    private $kernel;

    /**
     * @var FileManager
     */
    private $fileManager;

    /**
     * @var Generator
     */
    private $localGenerator;

    /**
     * @var string
     */
    private $extensionPath;

    public function __construct(ZikulaHttpKernelInterface $kernel, FileManager $fileManager)
    {
        $this->kernel = $kernel;
        $this->fileManager = $fileManager;
    }

    public static function getCommandName(): string
    {
        return 'make:zikula-extension';
    }

    public function configureCommand(Command $command, InputConfiguration $inputConfig)
    {
        $command
            ->setDescription('Creates a new zikula extension bundle')
            ->addArgument('namespace', InputArgument::OPTIONAL, sprintf('Choose a namespace (e.g. <fg=yellow>Acme\%s</>)', Str::asClassName(Str::getRandomTerm())))
            ->addArgument('type', InputArgument::OPTIONAL, sprintf('Choose a extension type (<fg=yellow>module or theme</>)'))
            ->setHelp(file_get_contents(dirname(__DIR__) . '/Resources/help/ExtensionMaker.txt'))
        ;
    }

    public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator)
    {
        try {
            $namespace = Validators::validateBundleNamespace($input->getArgument('namespace'));

It seems like $input->getArgument('namespace') can also be of type null and string[]; however, parameter $namespace of Zikula\Bundle\CoreBundle\Maker\Validators::validateBundleNamespace() does only seem to accept string, maybe add an additional type check?

        } catch (\InvalidArgumentException $exception) {
            $io->error($exception->getMessage());

            return 1;
        }
        $type = 'theme' === trim(mb_strtolower($input->getArgument('type'))) ? 'Theme' : 'Module';

It seems like $input->getArgument('type') can also be of type string[]; however, parameter $str of mb_strtolower() does only seem to accept string, maybe add an additional type check?

        $this->localGenerator = new Generator($this->fileManager, $namespace . $type);

        $this->createDirAndAutoload($namespace . $type);
        $bundleClass = $this->generateClasses($namespace, $type);
        $this->generateFiles($namespace, $type, $bundleClass);
        $this->generateBlankFiles();

        $this->localGenerator->writeChanges();
        $this->writeSuccessMessage($io);
        $io->warning(sprintf('In order to use other make:foo commands, you must change the root_namespace value in /config/packages/dev/maker.yaml to %s.', $namespace . $type));

        return 0;
    }

    public function configureDependencies(DependencyBuilder $dependencies)
    {
        $dependencies->addClassDependency(
            Command::class,
            'console'
        );
        $dependencies->addClassDependency(
            FileManager::class,
            'maker-bundle'
        );
        $dependencies->addClassDependency(
            ZikulaHttpKernelInterface::class,
            'zikula/core-bundle'
        );
    }

    private function createDirAndAutoload(string $namespace): void
    {
        $projectDir = $this->fileManager->getRootDirectory();
        $fs = new Filesystem();
        [$vendor, $extensionName] = explode('\\', $namespace, 2);
        $this->extensionPath = $projectDir . '/src/extensions/' . mb_strtolower($vendor) . '/' . $extensionName;
        $fs->mkdir($this->extensionPath);
        $this->kernel->getAutoloader()->addPsr4($namespace . '\\', $this->extensionPath);
    }

    private function getClassesToGenerate(string $namespace, string $type): iterable
    {
        $bundleClassName = str_replace('\\', '', $namespace);
        [$vendor, $extensionName] = explode('\\', $namespace, 2);

        return [
            ['name' => $bundleClassName, 'prefix' => '', 'suffix' => $type, 'template' => 'BundleClass.tpl.php'],
            ['name' => $bundleClassName, 'prefix' => 'DependencyInjection', 'suffix' => 'Extension', 'template' => 'DIExtensionClass.tpl.php'],
            ['name' => $extensionName . $type, 'prefix' => '', 'suffix' => 'Installer', 'template' => 'InstallerClass.tpl.php'],
        ];
    }

    private function generateClasses(string $namespace, string $type): string
    {
        $bundleClassFullName = '';
        foreach ($this->getClassesToGenerate($namespace, $type) as $classInfo) {
            $bundleClassNameDetails = $this->localGenerator->createClassNameDetails(
                $classInfo['name'],
                $classInfo['prefix'],
                $classInfo['suffix'],
                'Invalid!' . $classInfo['name']
            );
            $bundleClassFullName = ('' === $classInfo['prefix'] && $type === $classInfo['suffix']) ? $bundleClassNameDetails->getShortName() : $bundleClassFullName;
            $this->localGenerator->generateClass(
                $bundleClassNameDetails->getFullName(),
                dirname(__DIR__) . '/Resources/skeleton/extension/' . $classInfo['template'],
                [
                    'namespace' => $namespace . $type,
                    'type' => $type,
                    'name' => $bundleClassNameDetails->getShortName(),
                    'vendor' => mb_substr($namespace, 0, mb_strpos($namespace, '\\'))
                ]
            );
        }

        return $bundleClassFullName;
    }

    private function getFilesToGenerate(): iterable
    {
        return [
            'Resources/config/services.yaml' => 'services.yaml.tpl.php',
            'README.md' => 'README.md.tpl.php',
            'composer.json' => 'composer.json.tpl.php',
            'LICENSE.txt' => 'MIT.txt.tpl.php',
        ];
    }

    private function generateFiles(string $namespace, string $type, string $bundleClass): void
    {
        foreach ($this->getFilesToGenerate() as $targetPath => $templateName) {
            $this->localGenerator->generateFile(
                $this->extensionPath . '/' . $targetPath,
                dirname(__DIR__) . '/Resources/skeleton/extension/' . $templateName,
                [
                    'namespace' => $namespace . $type,
                    'type' => $type,
                    'vendor' => mb_substr($namespace, 0, mb_strpos($namespace, '\\')),
                    'name' => mb_substr($namespace, mb_strpos($namespace, '\\') + 1),
                    'bundleClass' => $bundleClass
                ]
            );
        }
    }

    private function generateBlankFiles(): void
    {
        $fs = new Filesystem();
        $fs->mkdir($this->extensionPath . '/Resources/doc');
        $fs->touch($this->extensionPath . '/Resources/doc/index.md');
        $fs->mkdir($this->extensionPath . '/Resources/doc/help/en');
        $fs->touch($this->extensionPath . '/Resources/doc/help/en/README.md');
        $fs->mkdir($this->extensionPath . '/Resources/public/css');
        $fs->touch($this->extensionPath . '/Resources/public/css/style.css');
        $fs->mkdir($this->extensionPath . '/Resources/public/images');
        $fs->touch($this->extensionPath . '/Resources/public/images/.gitkeep');
        $fs->mkdir($this->extensionPath . '/Resources/public/js');
        $fs->touch($this->extensionPath . '/Resources/public/js/.gitkeep');
        $fs->mkdir($this->extensionPath . '/Resources/translations');
        $fs->touch($this->extensionPath . '/Resources/translations/.gitkeep');
        $fs->mkdir($this->extensionPath . '/Resources/views');
        $fs->touch($this->extensionPath . '/Resources/views/.gitkeep');
    }
}