PHP Master | Construire l'automatisation avec des scripts compositeurs

Après l'introduction d'Alexander Cogneau à la gestion des dépendances avec le compositeur , vous savez maintenant que le compositeur est un résolveur pour gérer les dépendances de projet externes et les contraintes de version. Mais c'est tout ce qu'il fait? Dans cet article, je vais vous montrer comment le compositeur peut également être utilisé comme outil d'automatisation de base de base.

Les plats clés

• Le compositeur, en plus d'être un résolveur pour gérer les dépendances de projet externes et les contraintes de version, peut également être utilisée comme un outil d'automatisation de base. Il expose pre
• et post
• Installer / mettre à jour / désinstaller des crochets d'événements pendant l'exécution qui peuvent être scénarisés pour une gamme de tâches automatisées.

Scripts compositeurs

Tout outil d'automatisation de construction qui vaut son sel doit offrir la possibilité de scénorter une gamme de tâches automatisées - de la construction, de l'emballage et de l'exécution de suites de tests, au déploiement sur les systèmes de mise en scène et de production. La phing, par exemple, est basée sur la fourmi et vous permet de définir ces tâches dans des fichiers de construction XML. Le compositeur diffère à cet égard en ce qu'il ne fait aucune hypothèse quant à ces tâches, ou si elles doivent être effectuées. Ce que le compositeur fait à la place, c'est exposer ses crochets d'événements pré- et post-installation / mise à jour / désinstaller pendant l'exécution que vous pouvez rappeler à l'aide de «scripts», de la même manière que Pyrus offre la possibilité de définir des commandes personnalisées dans le package.xml via le - Plugin Option à ses commandes d'installation, de mise à niveau et de désinstallation. La propriété Scripts est définie dans l'objet racine JSON de Composer.json de votre package racine déposer. Vous pouvez définir n'importe quel nombre de méthodes statiques PHP (qui doivent être automatiquement en fonction du mécanisme automatique du compositeur), des exécutables en ligne de commande ou une combinaison des deux. Toutes les commandes de code ou de package personnalisées définies par ces scripts sont ensuite appelées pendant le processus d'exécution du compositeur. La mise en garde est que seuls les scripts définis dans le compositeur du package racine sont exécutés. Composer n'exécutera aucun script spécifié dans une dépendance du package racine. Les événements suivants sont licenciés pendant le processus d'exécution du compositeur:

• Pré-stall-cmd - se produit avant que la commande d'installation ne soit exécutée
• post-stall-cmd - se produit après l'exécution de la commande d'installation
• pré-update-cmd - se produit avant que la commande de mise à jour ne soit exécutée
• post-update-cmd - se produit après l'exécution de la commande de mise à jour
• Pré-package-install - se produit avant un package installé
• Post-package-install - se produit après l'installation d'un package
• avant le mise à jour du package - se produit avant qu'un package ne soit mis à jour
• Post-package-update - se produit une fois qu'un package est mis à jour
• pré-emballage-uninstall - se produit avant qu'un package ne soit désinstallé
• Post-package-uninstall - se produit une fois qu'un package est désinstallé

Ce sont assez explicites, et je pense que vous allez être d'accord, que la beauté réside dans sa simplicité. Mais pour illustrer, voici un exemple de compositeur de package racine.json:

<span>{
</span>    <span>"name": "MyProject",
</span>    <span>"description": "An example to demonstrate the use of Composer scripts",
</span>    <span>"version": "1.0.0",
</span>    <span>"require": {
</span>        <span>"php": ">=5.3",
</span>        <span>"ext-xsl": "*",
</span>        <span>"ext-imap": "*",
</span>        <span>"ext-gd": "*"
</span>      <span>},
</span>
    <span>"autoload": {
</span>        <span>"psr-0": {
</span>            <span>"MyProject": "src/"
</span>        <span>}
</span>    <span>},
</span>
    <span>"scripts": {
</span>        <span>"pre-install-cmd": "MyProject\Installer::preInstall",
</span>        <span>"post-install-cmd": [
</span>            <span>"MyProject\Installer::postInstall"
</span>        <span>],
</span>        <span>"post-package-install": [
</span>            <span>"MyProject\Installer::postPackageInstall",
</span>            <span>"phpunit -c /tests",
</span>            <span>"./bin/install.sh"
</span>        <span>]
</span>    <span>}
</span><span>}</span>

J'ai défini certains scripts pour les événements pré-installation, post-install-CMD et post-stall. Comme vous pouvez le voir, nous pouvons définir toute combinaison de méthodes PHP statiques et d'exécutables en ligne de commande. Dans le cas de l'événement post-emballage, il exécute également certains tests unitaires et un script d'installation personnalisé. Voici à quoi ressemble notre exemple de script:

<span><span><?php </span></span><span><span>namespace MyProject;
</span></span><span><span>use ComposerScriptEvent;
</span></span><span>
</span><span><span>class Installer
</span></span><span><span>{
</span></span><span>    <span>public static function preInstall(Event $event) {
</span></span><span>        <span>// provides access to the current ComposerIOConsoleIO
</span></span><span>        <span>// stream for terminal input/output
</span></span><span>        <span>$io = $event->getIO();
</span></span><span>        <span>if ($io->askConfirmation("Are you sure you want to proceed? ", false)) {
</span></span><span>            <span>// ok, continue on to composer install
</span></span><span>            <span>return true;
</span></span><span>        <span>}
</span></span><span>        <span>// exit composer and terminate installation process
</span></span><span>        <span>exit;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public static function postInstall(Event $event) {
</span></span><span>        <span>// provides access to the current Composer instance
</span></span><span>        <span>$composer = $event->getComposer();
</span></span><span>        <span>// run any post install tasks here
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public static function postPackageInstall(Event $event) {
</span></span><span>        <span>$installedPackage = $event->getComposer()->getPackage();
</span></span><span>        <span>// any tasks to run after the package is installed?
</span></span><span>    <span>}
</span></span><span><span>}</span></span></span>

Lorsque chacun de ces événements est licencié, le gestionnaire d'événements interne du compositeur transmet un objet ComposerScriptTevent comme premier (et unique) argument à chacun des rappels. L'événement Object expose les Getters suivants pour d'autres objets compositeurs à votre rappel:

• getComposer () - Renvoie l'instance actuelle de ComposerCoser
• getName () - Renvoie le nom de l'événement en cours de licenciement
• getio () - Renvoie le flux d'entrée / sortie actuel qui implémente ComposeRioioInterface pour la lecture / l'écriture sur la console

Vous pouvez vous référer à la documentation de l'API Composer pour chacune des signatures de méthode et pour les autres méthodes que chacun de ces objets exposent - en particulier, l'instance de compositeur et l'interface IO. Bien que cette implémentation apparemment rudimentaire puisse ne pas sembler aussi «puissante» que les définitions de phing, sa simplicité dément sa flexibilité incroyable. Il tire parti de votre investissement existant sur les connaissances dans PHP, et avec un peu de créativité et d'imagination, vous pouvez utiliser le résolveur de dépendance du compositeur et les scripts PHP natifs pour créer des tâches de construction et de retrait assez complexes. Vous pouvez même l'intégrer à Jenkins pour une intégration continue.

Résumé

Dans cet article, j'ai introduit un exemple rudimentaire de la façon dont les scripts compositeurs peuvent être utilisés pour effectuer l'automatisation de la construction. Ces tâches peuvent être aussi simples ou aussi complexes que vous en avez besoin, car elles exploitent votre investissement de connaissances existant dans PHP. Et j'espère que cet article vous inspirera à utiliser le compositeur pour plus qu'une simple gestion des dépendances. Pour plus d'informations sur la façon d'utiliser les scripts compositeurs, voir getcomposer.org/doc/articles/scripts.md. Image via Fotolia

Questions fréquemment posées (FAQ) sur l'automatisation de la construction avec les scripts compositeurs

Quelle est la fonction principale du compositeur dans le développement de PHP?

Le compositeur est un outil de gestion de dépendance en PHP. Il vous permet de déclarer les bibliothèques dont votre projet dépend, et il les gérera (les installera) pour vous. Le compositeur n'est pas un gestionnaire de packages dans le même sens que Yum ou APT. Oui, il traite des «packages» ou des bibliothèques, mais il les gère sur une base par projet, en les installant dans un répertoire (par exemple, vendeur) à l'intérieur de votre projet.

Comment puis-je automatiser les tâches à l'aide de scripts compositeurs?

Les scripts compositeurs sont un moyen d'automatiser les tâches dans le développement de PHP. Ils sont définis dans le fichier composer.json et peuvent être exécutés à partir de la ligne de commande à l'aide de la commande ‘Composer run-script’. Les scripts peuvent être utilisés pour automatiser des tâches telles que les tests, la construction et le déploiement. Ils peuvent également être utilisés pour exécuter le code PHP personnalisé.

Puis-je utiliser des scripts compositeurs pour les tests?

Oui, les scripts compositeurs peuvent être utilisés pour les tests. Vous pouvez définir un script dans votre fichier composer.json qui exécute vos tests. Par exemple, vous pouvez définir un script appelé «Test» qui exécute PHPUnit. Ensuite, vous pouvez exécuter vos tests à partir de la ligne de commande à l'aide de la commande 'Composer Run-Script Test'.

Comment puis-je utiliser des scripts compositeurs pour le déploiement?

Les scripts compositeurs peuvent être utilisés pour le déploiement En définissant un script dans votre fichier composer.json qui effectue les étapes nécessaires pour déployer votre application. Cela pourrait inclure des tâches telles que la compilation des actifs, l'optimisation du code et le téléchargement de fichiers sur un serveur. Une fois le script défini, vous pouvez l'exécuter à partir de la ligne de commande à l'aide de la commande 'Composer Run-Script'.

Les scripts de compositeur peuvent-ils exécuter le code PHP personnalisé?

Oui, les scripts de compositeur peuvent exécuter Code PHP personnalisé. Vous pouvez définir un script dans votre fichier composer.json qui exécute un fichier PHP. Le fichier PHP peut contenir n'importe quel code souhaité. Lorsque vous exécutez le script à l'aide de la commande 'Composer Run-Script', le code PHP sera exécuté.

Comment puis-je gérer les scripts dans Composer?

Les scripts dans Composer sont gérés dans le compositeur Fichier .json. Chaque script est défini comme une paire de valeurs de clé, la clé étant le nom du script et la valeur étant la commande à exécuter. Vous pouvez ajouter, modifier ou supprimer les scripts en modifiant le fichier composer.json.

Puis-je utiliser des scripts compositeurs pour automatiser les processus de construction?

Oui, les scripts compositeurs peuvent être utilisés pour automatiser les processus de construction . En définissant des scripts dans votre fichier composer.json, vous pouvez automatiser des tâches telles que la compilation de code, les actifs minimisant et la production de documentation. Ces scripts peuvent ensuite être exécutés à partir de la ligne de commande à l'aide de la commande 'Composer Run-Script'.

Quels sont les avantages de l'utilisation de scripts compositeurs pour l'automatisation?

L'utilisation de scripts compositeurs pour l'automatisation peut faire Votre processus de développement plus efficace. En automatisant les tâches répétitives, vous pouvez gagner du temps et réduire le risque d'erreurs. Les scripts compositeurs rendent également votre processus de construction plus cohérent, car les mêmes tâches sont effectuées de la même manière à chaque fois.

Puis-je utiliser des scripts compositeurs en conjonction avec d'autres outils?

Oui, Script compositeur Peut être utilisé conjointement avec d'autres outils. Par exemple, vous pouvez utiliser un script de compositeur pour exécuter une tâche Gulp ou pour exécuter une suite de test PHPUnit. Cela vous permet de tirer parti des capacités d'autres outils tout en bénéficiant de l'automatisation fournie par les scripts du compositeur.

Comment puis-je en savoir plus sur l'utilisation des scripts compositeurs pour l'automatisation?

Il existe de nombreuses ressources disponibles pour vous aider à en savoir plus sur l'utilisation des scripts compositeurs pour l'automatisation. La documentation officielle du compositeur est un excellent point de départ. Il existe également de nombreux tutoriels et articles de blog disponibles en ligne qui fournissent des exemples et les meilleures pratiques pour l'utilisation de scripts compositeurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!