0 follower

Abstract Class Yiisoft\Yii\Gii\Generator\AbstractGenerator

InheritanceYiisoft\Yii\Gii\Generator\AbstractGenerator
ImplementsYiisoft\Yii\Gii\GeneratorInterface
SubclassesYiisoft\Yii\Gii\Generator\ActiveRecord\Generator, Yiisoft\Yii\Gii\Generator\Controller\Generator

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:

Protected Methods

Hide inherited methods

Method Description Defined By
doGenerate() Yiisoft\Yii\Gii\Generator\AbstractGenerator
render() Generates code using the specified code template and parameters. Yiisoft\Yii\Gii\Generator\AbstractGenerator

Property Details

Hide inherited properties

$aliases protected property
protected \Yiisoft\Aliases\Aliases $aliases null
$parametersProvider protected property
$validator protected property
protected \Yiisoft\Validator\ValidatorInterface $validator null

Method Details

Hide inherited methods

__construct() public method

public __construct( \Yiisoft\Aliases\Aliases $aliases, \Yiisoft\Validator\ValidatorInterface $validator, Yiisoft\Yii\Gii\ParametersProvider $parametersProvider ): mixed
$aliases \Yiisoft\Aliases\Aliases
$validator \Yiisoft\Validator\ValidatorInterface
$parametersProvider Yiisoft\Yii\Gii\ParametersProvider

                public function __construct(
    protected Aliases $aliases,
    protected ValidatorInterface $validator,
    protected ParametersProvider $parametersProvider,
) {
}

            
doGenerate() protected abstract method

protected abstract doGenerate( Yiisoft\Yii\Gii\GeneratorCommandInterface $command ): array
$command Yiisoft\Yii\Gii\GeneratorCommandInterface

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

            
generate() public method

public generate( Yiisoft\Yii\Gii\GeneratorCommandInterface $command ): Yiisoft\Yii\Gii\Component\CodeFile\CodeFile[]
$command Yiisoft\Yii\Gii\GeneratorCommandInterface
throws Yiisoft\Yii\Gii\Exception\InvalidGeneratorCommandException

                final public function generate(GeneratorCommandInterface $command): array
{
    $result = $this->validator->validate($command);
    if (!$result->isValid()) {
        throw new InvalidGeneratorCommandException($result);
    }
    return $this->doGenerate($command);
}

            
getCommandClass() public abstract static method
public abstract static getCommandClass( ): string

                public static function getCommandClass(): string;

            
getDescription() public abstract static method

Defined in: Yiisoft\Yii\Gii\GeneratorInterface::getDescription()

Returns the detailed description of the generator

public abstract static getDescription( ): string

                public static function getDescription(): string;

            
getId() public abstract static method

Defined in: Yiisoft\Yii\Gii\GeneratorInterface::getId()

Returns the id of the generator

public abstract static getId( ): string

                public static function getId(): string;

            
getName() public abstract static method

Defined in: Yiisoft\Yii\Gii\GeneratorInterface::getName()

Returns the name of the generator

public abstract static getName( ): string

                public static function getName(): string;

            
getRequiredTemplates() public method

public getRequiredTemplates( ): array

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

            
getTemplatePath() public method

public getTemplatePath( Yiisoft\Yii\Gii\GeneratorCommandInterface $command ): string
$command Yiisoft\Yii\Gii\GeneratorCommandInterface

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

            
render() protected method

Generates code using the specified code template and parameters.

Note that the code template will be used as a PHP file.

protected render( Yiisoft\Yii\Gii\GeneratorCommandInterface $command, string $templateFile, array $params = [] ): string
$command Yiisoft\Yii\Gii\GeneratorCommandInterface
$templateFile string

The code template file. This must be specified as a file path relative to getTemplatePath().

$params array

List of parameters to be passed to the template file.

return string

The generated code

throws Throwable

                protected function render(GeneratorCommandInterface $command, string $templateFile, array $params = []): string
{
    $file = sprintf(
        '%s/%s',
        $this->aliases->get($this->getTemplatePath($command)),
        $templateFile
    );
    $renderer = function (): void {
        /** @psalm-suppress MixedArgument,PossiblyFalseArgument */
        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 PossiblyNullFunctionCall */
        $renderer->bindTo($this)($file, array_merge($params, ['command' => $command]));
        return (string)ob_get_clean();
    } catch (Throwable $e) {
        while (ob_get_level() > $obInitialLevel) {
            if (!@ob_end_clean()) {
                ob_clean();
            }
        }
        throw $e;
    }
}