Generando código con un comando

Para generar código desde un comando, debe realizar tres pasos:

  1. Crear una plantilla Twig para el código que quiera generar.
  2. Crear y registrar un servicio personalizado Generator para renderizar la plantilla Twig.
  3. Inyectar el servicio personalizado Generator en su comando.

Creando una plantilla Twig para el código generado

Todas las plantilllas Twig deben estar situadas dentro de un subdirectorio templates de su módulo o extensión. Por ejemplo:

templates/module/info.yml.twig

name: {{ module }}
type: {{ type }}
description: {{ description }}
core: {{ core }}
package: {{ package }}
{% if dependencies %}
dependencies:
{% for dependency in dependencies %}
  - {{ dependency }}
{% endfor %}
{% endif %}

Creando un servicio personalizado de Generator

Para crear un servicio personalizado Generator, primero cree una clase que extienda de Drupal\Console\Core\Generator\Generator. Por ejemplo:

src/Generator/ModuleGenerator

namespace Drupal\your_extension\Generator;

use Drupal\Console\Core\Generator\Generator;

class ModuleGenerator extends Generator
{
  ...
}

Use el método renderFile() heredado de la clase Generator para renderizar su template Twig.

public function generate($module, $machineName, $output_dir, $description, $core, $package, $dependencies) {

  $parameters = [
    'module' => $module,
    'core' => $core,
    'description' => $description,
    'package' => $package,
    'dependencies' => $dependencies,
  ];

  $this->renderFile(
    'module/info.yml.twig',
    $output_dir.'/'.$machineName.'.info.yml',
    $parameters
  );

}

Finalmente, registre su clase Generator como un servicio personalizado en console.services.yml.

services:
  your_extension.module_generator:
    class: Drupal\your_extension\Generator\ModuleGenerator
    tags:
      - { name: drupal.generator }

Asegúrese de incluir la etiqueta drupal.generator para que el renderizador de Twig sea inicializado propiamente.

Inyectando la clase Generator personalizada en su comando

En console.services.yml, añada su servicio personalizado Generator como argumento de su comando personalizado.

services:
  your_extension.generate_module:
    class: Drupal\your_extension\Command\Generate\ModuleCommand
    arguments: ['@your_extension.module_generator']
    tags:
       - { name: drupal.command }

Y añada su Generator personalizado al los parámetros del constructor de su clase de comando:

use Drupal\your_extension\Generator\ModuleGenerator;

class ModuleCommand extends Command
{
  /**
   * ModuleCommand constructor.
   *
   * @param \Drupal\your_extension\Generator\ModuleGenerator $generator
   */
  public function __construct(ModuleGenerator $generator) {
    $this->generator = $generator;
    parent::__construct();
  }

  ...
}

Ahora puede llamar a su Generator desde el método execute() en su comando para producir los archivos de código renderizados:

protected function execute(InputInterface $input, OutputInterface $output) {

  ...

  $this->generator->generate(
    $module,
    $machineName,
    $modulePath,
    $description,
    $core,
    $package,
    $dependencies
  );

}