Votre guide unique pour les commandes Laravel

De nos jours, il est tout à fait normal pour un développeur de comprendre les consoles et de définir des commandes de base. Mais que se passerait-il si vous pouviez coder vos propres commandes personnalisées pour améliorer votre flux de travail? Si nous revenons à Laravel 3, vous vous souviendrez peut-être qu'il offrait des tâches. Les tâches ont été extrêmement utiles, mais ont tout de même été courtes pour des opérations plus complexes. Heureusement, Laravel 4 emballe un Artisan renforcé qui facilitera grandement votre vie de développeur.!

Qu'est-ce que l'artisan??

Artisan est l'utilitaire de ligne de commande publié dans Laravel 3..

Si vous ne connaissez pas Laravel, vous ne connaissez peut-être pas Artisan. Artisan est l'utilitaire de ligne de commande publié dans Laravel 3. Si vous avez utilisé d'autres frameworks, vous pouvez comparer Artisan à Oil in FuelPHP, à ZFTool dans Zend ou à la console dans Symfony 2..

Artisan propose de nombreuses commandes utiles pouvant vous aider à effectuer diverses tâches, telles que la génération de migrations ou la publication des ressources d'un package. En plus des commandes intégrées, vous pouvez étendre Artisan avec vos propres commandes..

Fondations d'artisan

C’est là que Artisan tire son pouvoir.

Dans Laravel 3, Artisan a été écrit à partir de rien par Taylor Otwell (le créateur de Laravel), il était donc assez basique (bien qu'il soit encore génial). Maintenant que Laravel 4 est basé sur Composer, il peut utiliser les packages existants développés par d’autres développeurs brillants. En conséquence, Laravel 4 dépend maintenant de nombreux packages du framework Symfony. L’un de ces packages est l’excellent composant console..

Si nous jetons un coup d’œil à la source de l’application Artisan à Illuminer \ Console \ Application, nous pouvons voir que la classe, elle-même, s'étend Symfony \ Component \ Console \ Application. C'est là que Artisan tire son pouvoir. Bien que Artisan utilise le composant Console de Symfony, de nombreuses méthodes communes ont été attribuées à des alias plus proches de Laravel. Alors ne vous inquiétez pas, vous aurez toujours l'impression que vous développez avec Laravel!

Questions courantes

Deux questions apparaissent généralement lorsque vous essayez de développer une nouvelle commande.

Q Où devrais-je mettre des commandes?

Lorsque vous installez une copie de Laravel, vous trouverez un répertoire prédéfini à app / commandes. Ce répertoire est également dans le classmap de votre composer.json par défaut. Cela signifie qu'une fois que vous avez créé une commande, vous devez exécuter composer dump-autoload générer un fichier de chargement automatique mis à jour. Si vous ne le faites pas, vous recevrez des erreurs, vous plaignant que votre commande est introuvable..

Si vous développez un package, vous devez créer un répertoire dans vos packages. src // répertoire pour contenir vos commandes. Dans la base de code Laravel 4, ce répertoire est nommé Console. N'oubliez pas de vous assurer que le répertoire est automatiquement chargé dans vos packages. composer.json.

Q Comment dois-je nommer les commandes?

Dans la base de code Laravel 4, toutes les commandes sont suffixées Commander, et sont nommés d'après la tâche qu'ils effectuent. Disons, par exemple, que vous avez une commande qui efface votre cache. Vous pouvez nommer cette commande, CacheClearCommand.

Notions de base d'une commande

Une commande doit effectuer une seule tâche. Dans le reste de cet article, nous allons développer une commande de générateur d'utilisateurs. Passons en revue les bases d'une commande.

// app / commandes / UserGeneratorCommand.php line ('Bienvenue dans le générateur d'utilisateurs.');

Laravel peut générer ce code passe-partout pour vous! Il suffit de lancer:

$ php artisan command: make UserGeneratorCommand

Cela créera une commande squelette que vous pourrez modifier. Cependant, pour les besoins de ce didacticiel, nous allons suivre le processus de création d'une commande à partir de zéro, afin que nous puissions apprendre chaque partie du processus..

Nom de la commande

Toutes les commandes doivent fournir un nom. Ce nom est utilisé pour exécuter la commande à partir de la console et doit décrire la tâche effectuée par la commande. Bien qu'il n'y ait pas de convention pour le nom de votre commande, vous pouvez envisager l'une des solutions suivantes: espace de noms: groupe / commande, espace de noms: commande, ou juste commander.

Description de la commande

Toutes les commandes doivent fournir une description. La description est utilisée lors de l'extraction d'une liste de commandes disponibles d'Artisan et lors de l'affichage des documents d'aide d'une commande. Les descriptions doivent décrire brièvement la tâche effectuée par la commande..

Si nous devions ouvrir notre console et récupérer une liste des commandes disponibles, nous ne pourrions toujours pas voir notre commande listée..

$ php artisan list Laravel Framework version 4.0.0 Usage: [options] command [arguments] Options: --help -h Affiche ce message d’aide. --quiet -q Ne génère aucun message. --verbose -v Augmente la verbosité des messages. --version -V Affiche cette version de l'application. --ansi Force la sortie ANSI. --no-ansi Désactive la sortie ANSI. --no-interaction -n Ne posez aucune question interactive. --env L'environnement dans lequel la commande doit être exécutée. Commandes disponibles: help Affiche l'aide pour une liste de commandes. Listes des commandes migrées. Exécuter le service de migration de base de données. Servir l'application sur le bricoleur du serveur de développement PHP. Interagir avec votre atelier. Créer un nouvel actif de workbench de package: publier. Publier les actifs d'un package dans le répertoire public. auth: rappels Créer une migration pour la table des rappels de mots de passe commande: make Créer une nouvelle commande Artisan config config: publish Publier la configuration d'un package sur le contrôleur du contrôleur d'application: make Créer un nouveau contrôleur de ressources db db: seed Créer à partir de la clé la base de données key: generate Définir la clé de l'application migrate migrate: install Crée le référentiel de migration migrate: make Crée un nouveau fichier de migration migrate: refresh Réinitialise et réexécute toutes les migrations migrate: reset Annule toutes les migrations de base de données migrate: annule : listen Écouter une file d'attente donnée: work Traiter le travail suivant dans une session de file d'attente session: table Créer une migration pour la table de base de données de session

Pour enregistrer notre nouvelle commande, ouvrez app / start / artisan.php et avoir une lecture rapide à travers le bloc de commentaires par défaut qui est là. Lorsque nous exécutons Artisan à partir de la console, ce fichier est inclus. nous allons l'utiliser pour amorcer nos commandes. Dans ce fichier, nous avons accès à un $ artisan variable qui a été déclarée avant l’inclusion du fichier. Rappelez-vous la classe d'application Artisan que nous avons examinée plus tôt Celui qui a étendu le composant de la console Symfony? bien, $ artisan est une instance de cette classe.

Ajoutons notre commande pour la rendre disponible dans la console.

$ artisan-> add (new UserGeneratorCommand);

Ou, si vous préférez la syntaxe statique:

Artisan :: add (new UserGeneratorCommand);

le ajouter La méthode accepte une instance de commande. Une fois notre commande ajoutée, nous pouvons y accéder depuis la console.

$ php artisan user: generate Bienvenue dans le générateur d'utilisateurs.

La commande doit également figurer dans les commandes disponibles, ainsi que dans les informations d'aide..

$ php liste d'artisans

$ php artisan utilisateur: generate --help Usage: utilisateur: generate Options: --help (-h) Affiche ce message d'aide. --quiet (-q) Ne renvoie aucun message. --verbose (-v) Augmente la verbosité des messages. --version (-V) Affiche cette version de l'application. --ansi Force la sortie ANSI. --no-ansi Désactive la sortie ANSI. --no-interaction (-n) Ne posez aucune question interactive. --env L'environnement dans lequel la commande doit être exécutée.

Si vous recevez des erreurs, assurez-vous d’exécuter composer dump-autoload depuis la racine de vos applications, après avoir créé la commande.

Sortie couleur

La sortie de texte en couleur sur la console est un jeu d'enfant dans Artisan. Il existe quatre méthodes d'assistance différentes pour faire écho à la sortie ANSI colorée.

$ this-> info ("Ceci est quelques informations."); $ this-> comment ("Ceci est un commentaire."); $ this-> question ("Ceci est une question."); $ this-> error ("Ceci est une erreur.");

Options et arguments

Une nouvelle fonctionnalité intéressante d’Artisan est la possibilité de fournir une commande avec des options et des arguments..

Arguments

Les arguments sont des chaînes que vous envoyez à une commande. Ils doivent être donnés à une commande dans l'ordre dans lequel ils ont été définis. Considérez la commande suivante:

$ php artisan utilisateur: générer [nom] [email]

le prénom l'argument doit être spécifié avant la email argument.

Les arguments peuvent être définis comme optionnels.

Les options

Les options sont toujours facultatif, et sont précédés de deux tirets, le cas échéant.

$ php artisan utilisateur: generate --admin

En plus d’être utilisée comme commutateur booléen, une option peut être configurée pour accepter une valeur ou un tableau de valeurs..

$ utilisateur artisan php: générer --name = Jason $ utilisateur artisan php: générer --role = utilisateur --role = éditeur

Définir les options et les arguments

Avant de définir nos options et nos arguments, il est préférable d’importer les classes Symfony requises (elles sont longues et il serait difficile d’écrire tout le temps). Les deux classes dont nous avons besoin sont Symfony \ Component \ Console \ Input \ InputOption et Symfony \ Component \ Console \ Input \ InputArgument.

Au-dessus de notre déclaration de classe, nous allons importer les deux classes.

// app / commandes / UserGenerateCommand.php line ('Bienvenue dans le générateur d'utilisateurs.');

Pour définir les options et les arguments, vous devez créer deux nouvelles méthodes: getArguments et getOptions. Ces deux méthodes renvoient un tableau d'arguments ou d'options. Faisons en sorte que notre commande accepte un prénom argument, et un âge option.

// app / commandes / UserGenerateCommand.php line ('Bienvenue dans le générateur d'utilisateurs.'); // Récupère les arguments de nom et l'option age de l'instance d'entrée. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); $ this-> line ("$ name a $ age ans.");  / ** * Récupère les arguments de la commande de la console. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nom du nouvel utilisateur'),);  / ** * Obtenir les options de commande de la console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'L'âge du nouvel utilisateur'));

N'oubliez pas: Laravel peut générer tout ce code passe-partout pour vous. Nous le faisons simplement manuellement afin de revoir chaque ligne de la classe..

Maintenant, nous pouvons fournir un prénom argument et un âge option de notre console.

$ php artisan utilisateur: génère Jason --age = 22 Jason a 22 ans..

Les arguments et les options sont définis comme des tableaux multidimensionnels. Regardons de plus près les définitions de chacune d'elles.

Définitions d'argument

La définition de tableau pour un argument accepte quatre clés, seule la première (le nom de l'argument) est requise. La deuxième clé est le mode arguments et devrait être soit InputArgument :: FACULTATIF ou InputArgument :: REQUIRED. La troisième est la description et la quatrième clé est une valeur par défaut si le mode est défini sur InputArgument :: FACULTATIF.

Voici un argument utilisant toutes les clés du tableau.

array ('name', InputArgument :: OPTIONAL, 'Nom du nouvel utilisateur', 'Jason')

Définitions d'options

La définition de tableau pour une option accepte cinq clés et seule la première (le nom de l’option) est requise. La deuxième touche est un raccourci pour l’option (-une par exemple). Le troisième est le mode options et peut être l'une des valeurs suivantes: InputOption :: VALUE_NONE, InputOption :: VALUE_REQUIRED, InputOption :: VALUE_OPTIONAL, ou InputOption :: VALUE_IS_ARRAY. La quatrième clé est la description des options, et la cinquième est une valeur par défaut si le mode n’est pas activé. InputOption :: VALUE_NONE ou InputOption :: VALUE_REQUIRED.

Voici une option, en utilisant toutes les clés du tableau.

array ('age', 'a', InputOption :: VALUE_OPTIONAL, 'Age du nouvel utilisateur', 22)

Vous pouvez également combiner les InputOption :: VALUE_IS_ARRAY mode avec InputOption :: VALUE_REQUIRED ou InputOption :: VALUE_OPTIONAL.

tableau ('rôle', 'r', InputOption :: VALUE_OPTIONAL | InputOption :: VALUE_IS_ARRAY, 'Rôles du nouvel utilisateur', 'utilisateur')

Confirmations et questions

Une autre nouvelle fonctionnalité intéressante d’Artisan est sa capacité à demander une confirmation, voire à poser une question à l’utilisateur. Cela rend le développement de commandes interactives aussi simple que possible.

Les confirmations

En utilisant confirmer, nous pouvons poser une question à un utilisateur et lui demander de confirmer par "oui" ou par "non". Confirmons que l'utilisateur a entré son âge correctement.

// app / commandes / UserGenerateCommand.php line ('Bienvenue dans le générateur d'utilisateurs.'); // Récupère les arguments de nom et l'option age de l'instance d'entrée. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); if (! $ this-> confirm ("avez-vous vraiment $ age ans? [oui | non]", vrai)) $ this-> comment ('Alors pourquoi avez-vous dit que vous étiez!?'); revenir;  $ this-> comment ("$ name a $ age ans.");  / ** * Récupère les arguments de la commande de la console. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nom du nouvel utilisateur'),);  / ** * Obtenir les options de commande de la console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'l'âge du nouvel utilisateur', null));

Le premier paramètre correspond à la question à poser et le second à la valeur par défaut si un utilisateur appuie sur Entrée sans rien taper..

Des questions

En utilisant demander, nous pouvons poser une question à un utilisateur et attendre une réponse de sa part. Au lieu de tuer notre commande si l'utilisateur spécifie qu'il a entré son âge de manière incorrecte, demandons-lui de le saisir à nouveau..

// app / commandes / UserGenerateCommand.php line ('Bienvenue dans le générateur d'utilisateurs.'); // Récupère les arguments de nom et l'option age de l'instance d'entrée. $ name = $ this-> argument ('name'); $ age = $ this-> option ('age'); // Confirmez que l'utilisateur a entré son âge correctement et s'il ne l'a pas //, nous lui demanderons de le saisir à nouveau. if (! $ this-> confirm ("avez-vous vraiment $ age ans? [oui | non]", vrai)) $ age = $ this-> demander ("Quel âge avez-vous alors?") ;  $ this-> comment ("$ name a $ age ans.");  / ** * Récupère les arguments de la commande de la console. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nom du nouvel utilisateur'),);  / ** * Obtenir les options de commande de la console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'l'âge du nouvel utilisateur', null));

Dépendances de commandes

L'injection de dépendance est une étape importante pour garantir que votre code est testable et évolutif. Allons un peu plus loin dans notre commande en injectant une instance de modèle afin de générer l'utilisateur. Nous allons commencer par créer une interface utilisateur et un modèle utilisateur.

// app / models / UserInterface.php   Notre Interface utilisateur ne définit en réalité aucune implémentation de méthode, car il ne s'agit que d'un exemple. Pour une application réelle, vous définissez les méthodes que vous attendez de votre modèle..
 
 // app / models / User.php  Maintenant que nous avons notre Utilisateur modèle mettant en œuvre notre Interface utilisateur, nous pouvons continuer à installer notre dépendance dans notre commandement. Je vais ajouter un peu plus à notre commande de générer, et interagir avec le Utilisateur modèle injecté.
 // app / commandes / UserGenerateCommand.php utilisateur = $ utilisateur;  / ** * Exécuter la commande de la console. * * @return void * / public function fire () $ this-> line ('Bienvenue dans le générateur d'utilisateurs.'); // Récupère les arguments de nom et l'option age de l'instance d'entrée. $ this-> user-> name = $ this-> argument ('name'); $ this-> user-> age = $ this-> option ('age'); // Confirmez que l'utilisateur a entré son âge correctement et s'il ne l'a pas //, nous lui demanderons de le saisir à nouveau. Nous continuerons à leur demander jusqu'à ce qu'ils soient // sûrs d'être entrés dans le bon âge. $ correctAge = false; while (! $ correctAge) if (! $ this-> confirmer ("Êtes-vous vraiment $ this-> utilisateur-> age ans? [oui | non]", vrai)) $ this-> utilisateur- > age = $ this-> ask ('Alors quel âge as-tu alors?');  else $ correctAge = true;  $ this-> user-> framework = $ this-> ask ('Quel est votre framework préféré?', 'Laravel'); $ this-> user-> website = $ this-> ask ('Quelle est l'adresse de votre site web?'); // Sauvegarder l'utilisateur dans la base de données. $ this-> user-> save (); // Indique que l'utilisateur a été enregistré. $ this-> info ("$ this-> user-> name a été généré et enregistré.");  / ** * Récupère les arguments de la commande de la console. * * @return array * / protected function getArguments () return array (array ('name', InputArgument :: REQUIRED, 'Nom du nouvel utilisateur'),);  / ** * Obtenir les options de commande de la console. * * @return array * / protected function getOptions () return array (array ('age', null, InputOption :: VALUE_REQUIRED, 'l'âge du nouvel utilisateur', null)); 
 La première chose que vous devriez remarquer est que la commande a maintenant un constructeur. Ce constructeur accepte un seul paramètre et nous avons le type suggéré Interface utilisateur, nous savons donc que la classe que nous obtenons implémente les méthodes définies sur l'interface. Les constructeurs de commande doivent également appeler le constructeur parent.
 dans le Feu méthode de la commande, nous assignons directement les propriétés sur le Utilisateur instance de modèle. Nous utilisons également une boucle pour continuer à demander à l'utilisateur s'il a entré correctement son âge. Enfin, l'utilisateur est enregistré dans la base de données et nous indiquons sur la console qu'il a été généré et enregistré..
 Mais attendez! Avant de pouvoir utiliser la commande, nous devons injecter une instance de notre Utilisateur modèle.
 // app / start / artisan.php $ user = nouvel utilisateur; $ artisan-> add (new UserGeneratorCommand ($ user));
 Si vous avez configuré et configuré correctement la base de données, vous devriez maintenant pouvoir exécuter la commande et faire enregistrer un nouvel utilisateur dans la base de données.!
 
 Commandes de paquets
 Si vous développez un paquet dans Laravel, vous pouvez inclure des commandes. L'enregistrement de commandes à partir de packages est essentiellement le même processus, sauf que vous n'ajoutez pas (ou ne pouvez pas) ajouter la commande dans app / start / artisan.php. Au lieu de cela, vous les résolvez avec Artisan depuis votre fournisseur de services de packages..
 // chemin / vers / votre / PackageServiceProvider.php / ** * Enregistrez le fournisseur de services. * * @return void * / public function register () $ this-> app ['command.package.command'] = $ this-> app-> share (function ($ app) retourne le nouveau PackageCommand ($ app [ 'dépendance']);); $ this-> controls ('command.package.command'); 
 le commandes méthode peut accepter un nombre quelconque d'arguments et résoudra la commande hors du conteneur d'applications au démarrage d'Artisan.
 
 Conclusion
 Lorsque vous comparez Artisan dans Laravel 4 à son homologue Laravel 3, vous constaterez rapidement que les améliorations sont monumentales. Les commandes peuvent maintenant être liées au conteneur IoC et inclure l'injection de dépendance, fournir une sortie ANSI colorée, utiliser des arguments et des options et demander une interaction utilisateur.
 La puissance d'Artisan, grâce au composant Console de Symfony, est incroyable. Les ordres vont jouer un rôle énorme, à mesure que nous progressons - alors engagez-vous tôt!



		
			
	   
	




Code