Yiisoft\Yii\Gii\Generator\AbstractGenerator

Complexity

Total Complexity

11

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

72.72%

Importance

Changes	8
Bugs	2	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	defaultTemplate()	0	5	1
A	generate()	0	9	2
A	getRequiredTemplates()	0	3	1
A	render()	0	28	4
A	getTemplatePath()	0	11	2
A	__construct()	0	5	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Gii\Generator;

use ReflectionClass;
use ReflectionException;
use Throwable;
use Yiisoft\Aliases\Aliases;
use Yiisoft\Validator\ValidatorInterface;
use Yiisoft\Yii\Gii\Component\CodeFile\CodeFile;
use Yiisoft\Yii\Gii\Exception\InvalidConfigException;
use Yiisoft\Yii\Gii\Exception\InvalidGeneratorCommandException;
use Yiisoft\Yii\Gii\GeneratorCommandInterface;
use Yiisoft\Yii\Gii\GeneratorInterface;
use Yiisoft\Yii\Gii\GiiParametersProvider;

/**
 * This is the base class for all generator classes.
 *
 * A generator instance is responsible for taking user inputs, validating them,
 * and using them to generate the corresponding code based on a set of code template files.
 *
 * A generator class typically needs to implement the following methods:
 *
 * - {@see GeneratorInterface::getName()}: returns the name of the generator
 * - {@see GeneratorInterface::getDescription()}: returns the detailed description of the generator
 * - {@see GeneratorInterface::generate()}: generates the code based on the current user input and the specified code
 * template files. This is the place where main code generation code resides.
 */
abstract class AbstractGenerator implements GeneratorInterface
{
    public function __construct(
        protected Aliases $aliases,
        protected ValidatorInterface $validator,
        protected GiiParametersProvider $parametersProvider,
    ) {
    }

    public function getRequiredTemplates(): array
    {
        return [];
    }

    /**
     * Returns the root path to the default code template files.
     * The default implementation will return the "templates" subdirectory of the
     * directory containing the generator class file.
     *
     * @throws ReflectionException
     *
     * @return string the root path to the default code template files.
     */
    private function defaultTemplate(): string
    {
        $class = new ReflectionClass($this);

        return dirname($class->getFileName()) . '/default';
    }

    public function getTemplatePath(GeneratorCommandInterface $command): string
    {
        $template = $command->getTemplate();

        if ($template === 'default') {
            return $this->defaultTemplate();
        }

        $templates = $this->parametersProvider->getTemplates(static::getId());

        return $templates[$template] ?? throw new InvalidConfigException("Unknown template: \"{$template}\"");
    }

    /**
     * @param GeneratorCommandInterface $command
     *
     * @throws InvalidGeneratorCommandException
     *
     * @return CodeFile[]
     */
    final public function generate(GeneratorCommandInterface $command): array
    {
        $result = $this->validator->validate($command);

        if (!$result->isValid()) {
            throw new InvalidGeneratorCommandException($result);
        }

        return $this->doGenerate($command);
    }

    abstract protected function doGenerate(AbstractGeneratorCommand $command): array;

    /**
     * Generates code using the specified code template and parameters.
     * Note that the code template will be used as a PHP file.
     *
     * @param string $templateFile the code template file. This must be specified as a file path
     * relative to {@see getTemplatePath()}.
     * @param array $params list of parameters to be passed to the template file.
     *
     * @throws Throwable
     *
     * @return string the generated code
     */
    protected function render(GeneratorCommandInterface $command, string $templateFile, array $params = []): string
    {
        $file = sprintf(
            '%s/%s',
            $this->aliases->get($this->getTemplatePath($command)),
            $templateFile
        );

        $renderer = function (): void {
            extract(func_get_arg(1));
            /** @psalm-suppress UnresolvableInclude */
            require func_get_arg(0);
        };

        $obInitialLevel = ob_get_level();
        ob_start();
        ob_implicit_flush(false);
        try {
            /** @psalm-suppress PossiblyInvalidFunctionCall */
            $renderer->bindTo($this)($file, array_merge($params, ['command' => $command]));
            return ob_get_clean();
        } catch (Throwable $e) {
            while (ob_get_level() > $obInitialLevel) {
                if (!@ob_end_clean()) {
                    ob_clean();
                }
            }
            throw $e;
        }
    }
}