Yiisoft\Yii\Gii\Generator\CRUD\Generator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getDescription()	0	3	1
A	getId()	0	3	1
A	__construct()	0	7	1
A	getViewFile()	0	13	2
A	getName()	0	3	1
A	getControllerFile()	0	12	2
A	doGenerate()	0	28	3
A	getRequiredTemplates()	0	5	1
A	getCommandClass()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Gii\Generator\CRUD;

use InvalidArgumentException;
use Yiisoft\ActiveRecord\ActiveRecordFactory;
use Yiisoft\Aliases\Aliases;
use Yiisoft\Strings\StringHelper;
use Yiisoft\Validator\ValidatorInterface;
use Yiisoft\Yii\Gii\Component\CodeFile\CodeFile;
use Yiisoft\Yii\Gii\Generator\AbstractGenerator;
use Yiisoft\Yii\Gii\GeneratorCommandInterface;
use Yiisoft\Yii\Gii\ParametersProvider;

/**
 * This generator will generate a controller and one or a few action view files.
 */
final class Generator extends AbstractGenerator
{
    public function __construct(
        Aliases $aliases,
        ValidatorInterface $validator,
        ParametersProvider $parametersProvider,
        private readonly ActiveRecordFactory $activeRecordFactory,
    ) {
        parent::__construct($aliases, $validator, $parametersProvider);
    }

    public static function getId(): string
    {
        return 'crud';
    }

    public static function getName(): string
    {
        return 'CRUD';
    }

    public static function getDescription(): string
    {
        return 'This generator helps you to quickly generate a new controller class with
            one or several controller actions and their corresponding views.';
    }

    public function getRequiredTemplates(): array
    {
        return [
            'controller.php',
            'view.php',
        ];
    }

    public function doGenerate(GeneratorCommandInterface $command): array
    {
        if (!$command instanceof Command) {
            throw new InvalidArgumentException();
        }

        $files = [];

        $rootPath = $this->aliases->get('@root');

        $codeFile = (new CodeFile(
            $this->getControllerFile($command),
            $this->render($command, 'controller.php')
        ))->withBasePath($rootPath);
        $files[$codeFile->getId()] = $codeFile;

        //$actions = $command->getActions();
        $actions = ['index', 'view'];
        $model = $this->activeRecordFactory->createAR($command->getModel());
        foreach ($actions as $action) {
            $codeFile = (new CodeFile(
                $this->getViewFile($command, $action),
                $this->render($command, $action . '.php', ['action' => $action, 'model' => $model])
            ))->withBasePath($rootPath);
            $files[$codeFile->getId()] = $codeFile;
        }

        return $files;
    }

    /**
     * @return string the controller class file path
     */
    private function getControllerFile(Command $command): string
    {
        $directory = empty($command->getDirectory()) ? '@src/Controller/' : $command->getDirectory();

        return $this->aliases->get(
            str_replace(
                ['\\', '//'],
                '/',
                sprintf(
                    '%s/%s.php',
                    $directory,
                    StringHelper::baseName($command->getModel()) . 'Controller',
                ),
            ),
        );
    }

    /**
     * @param string $action the action ID
     *
     * @return string the action view file path
     */
    public function getViewFile(Command $command, string $action): string
    {
        $directory = empty($command->getViewsPath()) ? '@views/' : $command->getViewsPath();

        return $this->aliases->get(
            str_replace(
                ['\\', '//'],
                '/',
                sprintf(
                    '%s/%s/%s.php',
                    $directory,
                    StringHelper::lowercase(StringHelper::baseName($command->getModel())),
                    $action,
                ),
            ),
        );
    }

    public static function getCommandClass(): string
    {
        return Command::class;
    }
}