Su guía única para los comandos de Laravel

En esta época, es bastante normal que un desarrollador tenga una comprensión de las consolas y de cómo emitir comandos básicos. ¿Pero qué pasaría si pudiera codificar sus propios comandos personalizados para mejorar su flujo de trabajo? Si volvemos a mirar a Laravel 3, quizás recuerden que ofreció tareas. Las tareas fueron extremadamente útiles, pero aún así quedaron cortas para operaciones más complejas. Afortunadamente, Laravel 4 incluye un Artisan reforzado que hará que tu vida como desarrollador sea mucho más fácil.!

Que es el artesano?

Artisan es la utilidad de línea de comandos que se lanzó en Laravel 3.

Si no estás familiarizado con Laravel, es posible que no conozcas a Artisan. Artisan es la utilidad de línea de comandos que se lanzó en Laravel 3. Si has usado otros marcos, puedes comparar Artisan con Oil en FuelPHP, ZFTool en Zend o la Consola en Symfony 2.

Artisan ofrece muchos comandos útiles que pueden ayudarlo a realizar diversas tareas, como generar migraciones o publicar los activos de un paquete. Además de los comandos incorporados, puede extender Artisan con sus propios comandos..

Fundaciones artesanales

Aquí es donde el artesano saca su poder..

En Laravel 3, Artisan fue escrito desde cero por Taylor Otwell (el creador de Laravel), por lo que era bastante básico (aunque todavía impresionante). Ahora que Laravel 4 está basado en Composer, puede usar paquetes existentes desarrollados por otros desarrolladores brillantes. Como resultado, Laravel 4 ahora depende de numerosos paquetes del framework Symfony. Uno de estos paquetes es el excelente componente de consola..

Si echamos un vistazo a la fuente de la aplicación Artisan en Illuminate \ Console \ Application, Podemos ver que la clase, en sí, se extiende. Symfony \ Component \ Console \ Application. Aquí es donde el artesano saca su poder. Aunque Artisan hace uso del componente de la Consola de Symfony, muchos de los métodos comunes han recibido alias más fluidos similares a Laravel. Así que no te preocupes, todavía sentirás que estás desarrollando con Laravel.!

Preguntas comunes

Normalmente surgen dos preguntas al intentar desarrollar un nuevo comando.

Q ¿Dónde debo poner los comandos??

Cuando instala una copia de Laravel, encontrará un directorio predefinido en aplicación / comandos. Este directorio también está en el mapa de clase de tu compositor.json por defecto. Esto significa que, una vez que haya creado un comando, deberá ejecutar compositor dump-autoload para generar un archivo de carga automática actualizado. Si no lo hace, recibirá errores, quejándose de que no se puede encontrar su comando.

Si está desarrollando un paquete, deberá crear un directorio dentro de sus paquetes. src // Directorio para mantener sus comandos. A lo largo de la base de código de Laravel 4, este directorio se llama Consola. Recuerde asegurarse de que el directorio se carga automáticamente en sus paquetes compositor.json.

Q ¿Cómo debo nombrar los comandos?

A lo largo de la base de código de Laravel 4, todos los comandos tienen el sufijo Mando, y llevan el nombre de la tarea que realizan. Digamos, por ejemplo, que tiene un comando que borra su caché. Usted podría nombrar este comando, CacheClearCommand.

Fundamentos de un comando

Un comando debe realizar una sola tarea. A lo largo del resto de este artículo, vamos a desarrollar un comando generador de usuarios. Repasemos los fundamentos de un comando..

// aplicación / comandos / UserGeneratorCommand.php línea ('Bienvenido al generador de usuarios.');

¡Laravel puede generar este código para ti! Simplemente ejecute:

$ php artisan command: make UserGeneratorCommand

Esto creará un comando de esqueleto para que lo modifiques, sin embargo, para los fines de este tutorial, realizaremos el proceso de creación de un comando desde cero, para que podamos aprender cada parte del proceso..

Nombre del comando

Todos los comandos deben proporcionar un nombre. Este nombre se utiliza para ejecutar el comando desde la consola y debe describir la tarea que realiza el comando. Si bien no existe una convención sobre cómo se nombra su comando, puede considerar uno de los siguientes: espacio de nombres: grupo / comando, espacio de nombres: comando, o solo mando.

Descripción del comando

Todos los comandos deben proporcionar una descripción. La descripción se utiliza al recuperar una lista de comandos disponibles de Artisan y al ver los documentos de ayuda de un comando. Las descripciones deben describir brevemente la tarea que realiza el comando.

Si tuviéramos que abrir nuestra consola y obtener una lista de los comandos disponibles, aún no podremos ver nuestro comando en la lista.

$ php lista de artesanos Laravel Framework versión 4.0.0 Uso: [opciones] comando [argumentos] Opciones: --help -h Mostrar este mensaje de ayuda. --quiet -q No muestra ningún mensaje. --verbose -v Aumenta la verbosidad de los mensajes. --version -V Muestra la versión de esta aplicación. --ansi fuerza salida ANSI. --no-ansi Deshabilita la salida ANSI. --no-la interacción -n No hagas ninguna pregunta interactiva. --env El entorno en el que se debe ejecutar el comando. Comandos disponibles: ayuda Muestra ayuda para una lista de comandos Listas de comandos migrar Ejecutar las migraciones de base de datos Servir Servir la aplicación en el servidor de desarrollo de PHP Tinker Interactuar con el banco de trabajo de su aplicación Crear un nuevo activo activo de paquete de trabajo de banco: publicar Publicar los activos de un paquete en el directorio público auth: recordatorios Crear una migración para el comando de la tabla de recordatorios de contraseña comando: crear Crear un nuevo comando de Artisan configuración de configuración: publicar Publicar la configuración de un paquete en el controlador del controlador de la aplicación: crear Crear un nuevo controlador con recursos db db: semilla Recopilar la base de datos con la clave de registros clave: generar Establecer la clave de la aplicación migrar migrar: instalar Crear el repositorio de migración migrar: crear Crear un nuevo archivo de migración migrar: actualizar Restablecer y volver a ejecutar todas las migraciones migrar: restablecer Revertir todas las migraciones de base de datos migrar: deshacer Revertir la última cola de migración de base de datos cola : escuchar Escuchar una cola de espera dada: trabajar Procesar el siguiente trabajo en una sesión de cola session: table Crear una migración para la tabla de base de datos de sesión

Para registrar nuestro nuevo comando, abra aplicación / inicio / artisan.php y lea rápidamente el bloque de comentarios predeterminado que se encuentra allí. Cuando ejecutamos Artisan desde la consola, este archivo está incluido; Lo usaremos para arrancar nuestros comandos. En este archivo, tenemos acceso a un $ artesano Variable que fue declarada antes de incluir el archivo. ¿Recuerdas la clase de aplicación Artisan que vimos antes? ¿El que extendió el componente de la Consola Symfony? Bien, $ artesano es una instancia de esa clase.

Añadamos nuestro comando para que esté disponible en la consola..

$ artisan-> add (nuevo UserGeneratorCommand);

O, si prefieres la sintaxis estática:

Artisan :: add (nuevo UserGeneratorCommand);

los añadir El método acepta una instancia de comando. Una vez que hemos agregado nuestro comando, podemos acceder a él desde la consola..

$ php artesano usuario: generar Bienvenido al generador de usuarios.

El comando también debe aparecer en los comandos disponibles, así como la información de ayuda.

$ php lista de artesanos

$ php artisan usuario: generar - ayuda Uso: usuario: generar Opciones: - ayuda (-h) Mostrar este mensaje de ayuda. --quiet (-q) No muestra ningún mensaje. --verbose (-v) Aumenta la verbosidad de los mensajes. --version (-V) Muestra la versión de esta aplicación. --ansi fuerza salida ANSI. --no-ansi Deshabilita la salida ANSI. --no-la interacción (-n) No haga ninguna pregunta interactiva. --env El entorno en el que debe ejecutarse el comando.

Si recibe algún error, asegúrese de ejecutar compositor dump-autoload Desde su raíz de aplicaciones, después de crear el comando..

Salida de color

La salida de texto en color a la consola es muy fácil en Artisan. Hay cuatro métodos de ayuda diferentes para hacer eco de la salida ANSI de color.

$ this-> info ("Esta es información"); $ this-> comment ("Esto es un comentario"); $ this-> question ("Esto es una pregunta"); $ this-> error ("Esto es un error");

Opciones y Argumentos

Una nueva característica emocionante para Artisan es la capacidad de proporcionar un comando con opciones y argumentos.

Argumentos

Los argumentos son cadenas que se envían a un comando. Deben darse a un comando en el orden en que están definidos. Considere el siguiente comando:

$ php usuario artesano: generar [nombre] [correo electrónico]

los nombre argumento debe ser especificado antes de la correo electrónico argumento.

Los argumentos se pueden definir como opcionales.

Opciones

Las opciones son siempre Opcional, y están prefijados con dos guiones, cuando se proporcionan.

$ php usuario artesano: generar --admin

Además de usarse como conmutadores booleanos, una opción puede configurarse para aceptar un valor o una matriz de valores.

$ php usuario artesano: generar --nombre = Jason $ php usuario artesano: generar --role = usuario --role = editor

Definir opciones y argumentos

Antes de definir nuestras opciones y argumentos, es mejor importar las clases requeridas de Symfony (son largas y sería un dolor escribirlas todo el tiempo). Las dos clases que necesitamos son Symfony \ Component \ Console \ Input \ InputOption y Symfony \ Component \ Console \ Input \ InputArgument.

Por encima de nuestra declaración de clase, importaremos ambas clases..

// aplicación / comandos / UserGenerateCommand.php línea ('Bienvenido al generador de usuarios.');

Para definir las opciones y los argumentos, debe crear dos nuevos métodos: getArguments y getOptions. Ambos métodos devuelven una serie de argumentos u opciones. Hagamos que nuestro comando acepte un nombre argumento, y un años opción.

// aplicación / comandos / UserGenerateCommand.php línea ('Bienvenido al generador de usuarios.'); // Obtenga los argumentos de nombre y la opción de edad de la instancia de entrada. $ nombre = $ este-> argumento ('nombre'); $ age = $ this-> option ('age'); $ this-> line ("$ name tiene $ age años.");  / ** * Obtener los argumentos del comando de consola. * * @return array * / función protegida getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Obtener las opciones de comando de la consola. * * @return array * / función protegida getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user'));

Recuerde: Laravel puede generar todo este código repetitivo para usted. Simplemente lo hacemos manualmente para revisar cada línea de la clase..

Ahora, podemos proporcionar una nombre argumento y un años Opción desde nuestra consola..

$ php usuario artesano: generar Jason --age = 22 Jason tiene 22 años.

Tanto los argumentos como las opciones se definen como matrices multidimensionales. Echemos un vistazo más de cerca a las definiciones de cada uno de ellos..

Definiciones de Argumento

La definición de matriz para un argumento acepta cuatro claves, y solo se requiere la primera (el nombre de los argumentos). La segunda clave es el modo argumentos y debe ser EntradaArgumento :: OPCIONAL o InputArgument :: REQUIRED. La tercera es la descripción, y la cuarta clave es un valor predeterminado, si el modo está configurado en EntradaArgumento :: OPCIONAL.

Aquí hay un argumento usando todas las claves de matriz.

array ('nombre', InputArgument :: OPCIONAL, 'Nombre del nuevo usuario', 'Jason')

Definiciones de las opciones

La definición de la matriz para una opción acepta cinco claves y solo se requiere la primera (el nombre de las opciones). La segunda tecla es un atajo para la opción (-una por ejemplo). El tercero es el modo de opciones y puede ser uno de los siguientes valores: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, o InputOption :: VALUE_IS_ARRAY. La cuarta clave es la descripción de las opciones, y la quinta clave es un valor predeterminado, si el modo no está InputOption :: VALUE_NONE o InputOption :: VALUE_REQUIRED.

Aquí hay una opción, usando todas las claves de matriz.

array ('age', 'a', InputOption :: VALUE_OPTIONAL, 'Age of the new user', 22)

También puedes combinar el InputOption :: VALUE_IS_ARRAY modo con InputOption :: VALUE_REQUIRED o InputOption :: VALUE_OPTIONAL.

array ('role', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Roles del nuevo usuario', 'usuario')

Confirmaciones y preguntas

Otra característica nueva y emocionante para Artisan es su capacidad para solicitar confirmación, o incluso para hacerle una pregunta al usuario. Esto hace que el desarrollo de comandos interactivos sea lo más simple posible..

Confirmaciones

Utilizando confirmar, podemos hacerle una pregunta a un usuario y confirmarla con "sí" o "no". Confirmemos que el usuario ha ingresado su edad correctamente..

// aplicación / comandos / UserGenerateCommand.php línea ('Bienvenido al generador de usuarios.'); // Obtenga los argumentos de nombre y la opción de edad de la instancia de entrada. $ nombre = $ este-> argumento ('nombre'); $ age = $ this-> option ('age'); si (! $ this-> confirme ("¿Tiene realmente $ age años? [sí | no]", verdadero)) $ this-> comentario ('¿¡Entonces por qué dijo que estaba !?'); regreso;  $ this-> comment ("$ name tiene $ age años.");  / ** * Obtener los argumentos del comando de consola. * * @return array * / función protegida getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Obtener las opciones de comando de la consola. * * @return array * / función protegida getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

El primer parámetro es la pregunta que desea formular, y el segundo es el valor predeterminado, si un usuario pulsa Intro sin escribir nada.

Preguntas

Utilizando pedir, podemos hacerle una pregunta a un usuario y esperar una respuesta de ellos. En lugar de matar nuestro comando si el usuario especifica que ingresó su edad de manera incorrecta, en vez de eso, le pedimos que la ingrese nuevamente.

// aplicación / comandos / UserGenerateCommand.php línea ('Bienvenido al generador de usuarios.'); // Obtenga los argumentos de nombre y la opción de edad de la instancia de entrada. $ nombre = $ este-> argumento ('nombre'); $ age = $ this-> option ('age'); // Confirme que el usuario ingresó su edad correctamente y, si no lo han hecho, // les pediremos que la ingresen nuevamente. si (! $ this-> confirme ("¿Tiene realmente $ age años? [sí | no]", verdadero)) $ age = $ this-> ask ('Entonces, ¿qué edad tiene?') ;  $ this-> comment ("$ name tiene $ age años.");  / ** * Obtener los argumentos del comando de consola. * * @return array * / función protegida getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Obtener las opciones de comando de la consola. * * @return array * / función protegida getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null));

Dependencias de Comando

La inyección de dependencia es un paso importante para garantizar que su código sea verificable y sea una prueba de futuro. Vamos a llevar nuestro comando un paso más allá inyectando una instancia de modelo, para que podamos generar el usuario. Comenzaremos creando una interfaz de usuario y un modelo de usuario..

// app / models / UserInterface.php   Nuestro Interfaz de usuario en realidad no define ninguna implementación de métodos, ya que esto es solo un ejemplo. Para una aplicación del mundo real, definiría los métodos que esperaría en su modelo.
 
 // app / models / User.php  Ahora que tenemos nuestro Usuario modelo implementando nuestro Interfaz de usuario, Podemos continuar configurando nuestra dependencia en nuestro comando. Voy a agregar un poco más a nuestro comando de generación e interactuar con el Usuario modelo que se inyecta.
 // aplicación / comandos / UserGenerateCommand.php usuario = $ usuario;  / ** * Ejecutar el comando de la consola. * * @return void * / public function fire () $ this-> line ('Bienvenido al generador de usuarios.'); // Obtenga los argumentos de nombre y la opción de edad de la instancia de entrada. $ this-> usuario-> nombre = $ this-> argumento ('nombre'); $ this-> user-> age = $ this-> option ('age'); // Confirme que el usuario ingresó su edad correctamente y, si no lo han hecho, // les pediremos que la ingresen nuevamente. Seguiremos preguntándoles hasta que estén // seguros de que han entrado en la edad adecuada. $ correctAge = falso; while (! $ correctAge) if (! $ this-> confirm ("¿Realmente eres $ this-> user-> age años? [yes | no]", true)) $ this-> user- > age = $ this-> ask ('Entonces, ¿cuántos años tienes?');  else $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('¿Cuál es tu framework favorito?', 'Laravel'); $ this-> user-> website = $ this-> ask ('¿Cuál es la dirección de su sitio web?'); // Guardar el usuario en la base de datos. $ this-> user-> save (); // Informe que el usuario ha sido guardado. $ this-> info ("$ this-> user-> name se ha generado y guardado.");  / ** * Obtener los argumentos del comando de consola. * * @return array * / función protegida getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Name of the new user'),);  / ** * Obtener las opciones de comando de la consola. * * @return array * / función protegida getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'Age of the new user', null)); 
 Lo primero que debe notar es que el comando ahora tiene un constructor. Este constructor acepta un solo parámetro y hemos tipeado el tipo Interfaz de usuario, así que sabemos que la clase que obtenemos implementa los métodos definidos en la interfaz. Los constructores de comandos también deben llamar al constructor padre.
 En el fuego Método del comando, estamos asignando directamente las propiedades en el Usuario ejemplar del modelo. También estamos usando un bucle para continuar preguntándole al usuario si ha ingresado su edad correctamente. Finalmente, el usuario se guarda en la base de datos y nosotros enviamos a la consola que el usuario fue generado y guardado.
 ¡Pero espera! Antes de que podamos usar el comando, necesitamos inyectar una instancia de nuestro Usuario modelo.
 // app / start / artisan.php $ user = new User; $ artisan-> add (nuevo UserGeneratorCommand ($ user));
 Si tiene una configuración de base de datos y está configurada correctamente, ahora debería poder ejecutar el comando y hacer que se guarde un nuevo usuario en la base de datos.!
 
 Comandos del paquete
 Si está desarrollando un paquete en Laravel, es posible que desee incluir comandos. El registro de comandos de paquetes es mayormente el mismo proceso, excepto que usted no (o no puede) agregar el comando en aplicación / inicio / artisan.php. En su lugar, los resuelve con Artisan desde su proveedor de servicios de paquetes..
 // ruta / a / su / PackageServiceProvider.php / ** * Registre el proveedor de servicios. * * @return void * / public function register () $ this-> app ['command.package.command'] = $ this-> app-> share (function ($ app) return new PackageCommand ($ app [ 'dependencia']);); $ this-> comandos ('command.package.command'); 
 los comandos el método puede aceptar cualquier número de argumentos y resolverá el comando fuera del contenedor de la aplicación cuando se inicie Artisan.
 
 Conclusión
 Cuando comparas Artisan en Laravel 4 con su contraparte de Laravel 3, encontrarás rápidamente que las mejoras son monumentales. Los comandos ahora pueden vincularse al contenedor de IoC e incluir la inyección de dependencia, proporcionar una salida ANSI de color, usar argumentos y opciones, y solicitar la interacción del usuario.
 El poder de Artisan, gracias al componente de la Consola de Symfony, es increíble. Los comandos van a jugar un papel muy importante a medida que avancemos, así que suba a bordo pronto!



		
			
	   
	




Código