• 30 hours
  • Medium

Free online content available in this course.

Videos available in this course

Certificate of achievement available at the end this course

Got it!

Last updated on 5/13/19

Installer un bundle grâce à Composer

Log in or subscribe for free to enjoy all this course has to offer!

Je fais une parenthèse pour vous présenter un chapitre sur l'outil Composer.

Cet outil ne fait absolument pas partie de Symfony, mais son usage est tellement omniprésent dans la communauté Symfony que je me dois de vous le présenter. Nous faisons donc une pause dans le développement de notre plateforme pour parler un peu de cet outil de gestion de dépendances, qui va nous servir à installer des bundles et autres bibliothèques très facilement.

Bonne lecture !

Composer, qu'est-ce que c'est ?

Un gestionnaire de dépendances

Composer est un outil pour gérer les dépendances en PHP. Les dépendances, dans un projet, ce sont toutes les bibliothèques dont votre projet dépend pour fonctionner. Par exemple, si votre projet utilise la bibliothèque SwiftMailer pour envoyer des e-mails, il « dépend » donc de SwiftMailer. Autrement dit, SwiftMailer est une dépendance dans votre projet.

Composer a donc pour objectif de vous aider à gérer toutes vos dépendances. En effet, il y a plusieurs problématiques lorsqu'on utilise des bibliothèques externes :

  • Ces bibliothèques sont mises à jour. Il vous faut donc les mettre à jour une à une pour vous assurer de corriger les bogues de chacune d'entre elles.

  • Ces bibliothèques peuvent elles-mêmes dépendre d'autres bibliothèques. En effet, si une de vos bibliothèques dépend d'autres bibliothèques, cela vous oblige à gérer l'ensemble de ces dépendances (installation, mises à jour, etc.).

  • Ces bibliothèques ont chacune leur paramètres d'autoload, et vous devez gérer leur autoload pour chacune d'entre elles.

Composer va nous aider dans chacune de ces tâches.

Comment Composer sait où trouver les bibliothèques ?

Très bonne question. En effet, il est évident que ce système de gestion ne peut fonctionner que si on peut centraliser les informations de chaque bibliothèque. C'est le rôle du site www.packagist.org.

Par exemple, voici la page pour la bibliothèque Symfony (eh oui, c'est une bibliothèque comme une autre !) : https://packagist.org/packages/symfony/symfony. Vous pouvez voir les informations comme le mainteneur principal, le site de la bibliothèque, etc. Mais ce qui nous importe le plus, ce sont les sources ainsi que les dépendances (dansRequires).

Composer va donc lire ces informations, et a alors toutes les cartes en main pour télécharger Symfony ainsi que ses dépendances.

Un outil innovant… dans l'écosystème PHP

Ce genre d'outil de gestion de dépendances n'est pas du tout nouveau dans le monde informatique. Vous connaissez peut-être déjà APT, le gestionnaire de paquets de la distribution Linux Debian. Il existe également des outils de ce genre pour le langage Ruby par exemple. Cependant, jusque très récemment, il n'existait aucun outil de ce genre pour PHP. La forte communauté qui s'est construite autour de Symfony a fait naître le besoin d'un tel outil, et l'a ensuite développé.

Concrètement, comment ça marche ?

Concrètement, voici comment s'utilise Composer :

  • On définit dans un fichier la liste des bibliothèques dont le projet dépend, ainsi que leur version ;

  • On exécute une commande pour installer ou mettre à jour ces bibliothèques (et leurs propres dépendances donc) ;

  • On inclut alors le fichier d'autoload généré par Composer dans notre projet.

Mais avant de manipuler Composer, commençons par l'installer !

Installer Composer et Git

Installer Composer

Installer Composer est très facile, il suffit d'une seule commande… PHP ! Exécutez cette commande dans la console :

C:\wamp\www> php -r "eval('?>'.file_get_contents('http://getcomposer.org/installer'));"

Cette commande télécharge et exécute le fichier PHP suivant : http://getcomposer.org/installer . Vous pouvez aller le voir, ce n'est pas Composer en lui-même mais son installateur. Il fait quelques vérifications (version de PHP, etc.), puis télécharge effectivement Composer dans le fichiercomposer.phar.

Composer en lui-même, c'est le fichier PHARcomposer.phar, c'est lui que nous devrons exécuter par la suite. Vous pouvez déjà l'exécuter pour vérifier que tout est OK :

C:\wamp\www>php composer.phar --version
Composer version a5eaba8

N'hésitez pas à mettre à jour Composer lui-même de temps en temps. Il faut pour cela utiliser la commandeself-updatede Composer, comme suit :

C:\wamp\www>php composer.phar self-update
Updating to version ded485d.
    Downloading: 100%

Et voilà, je viens de mettre à jour Composer très simplement !

Cependant, l'installation n'est pas finie. En effet, pour récupérer certaines bibliothèques, Composer utilise Git.

Installer Git

Comme on l'a vu, pour récupérer les bibliothèques, Composer se base sur les informations répertoriées sur Packagist. Si pour certaines bibliothèques Composer peut télécharger directement des archives contenant les sources, pour d'autres il doit utiliser un gestionnaire de versions tel que Git.

En réalité, beaucoup de bibliothèques sont dans ce cas, c'est pourquoi l'installation de Git ne peut être évitée. Ce n'est pas grave, attaquons-la ! Je vais ici décrire rapidement son installation, mais sachez que le cours « Gérer vos codes source avec Git » de Mathieu Nebra sur le site OpenClassrooms détaille très bien son fonctionnement et son installation.

Installer Git sous Windows

Sous Windows, il faut utiliser msysgit. Cela installe msys (un système d'émulation des commandes Unix sous Windows) et Git lui-même.

Téléchargez le fichier et exécutez-le, cela va tout installer. Laissez les paramètres par défaut, ils conviennent très bien. Cela va prendre un peu de temps, car il y a beaucoup à télécharger (une centaine de Mo) et à exécuter, ne vous inquiétez pas. Une fois que vous avez une ligne de commande (/dev), vous pouvez fermer la fenêtre.

Une fois cela installé, il faut ajouter les exécutables Git au PATH de Windows. Ajoutez donc ceci : «;C:\msysgit\bin;C:\msysgit\mingw\bin» à la suite de votre variable d'environnement système PATH (on en a déjà parlé dans le premier chapitre).

Redémarrez votre ordinateur, et ensuite vérifiez l'installation en exécutant la commande suivante :

C:\wamp\www>git version
git version 1.9.5.msysgit.0

Si vous n'avez pas d'erreur, c'est tout bon !

Installer Git sous Linux

Sous Linux, c'est encore plus simple avec votre gestionnaire de paquets. Voici comment l'installer depuis la distribution Debian et ses dérivées (Ubuntu, etc.) :

sudo apt-get install git-core

Installer un bundle grâce à Composer

Manipulons Composer

Avant d'utiliser Composer dans notre projet Symfony, on va d'abord s'amuser avec lui sur un projet test afin de bien comprendre son fonctionnement. Créez donc un répertoiretestlà où vous avez téléchargé Composer.

Déclarer ses dépendances

La première chose à faire dans un projet, c'est de déclarer ses dépendances. Cela se fait via un fichiercomposer.json, qui contient les informations sur les bibliothèques dont dépend votre projet ainsi que leur version. La syntaxe est assez simple, en JSON, créez le fichiercomposer.json  suivant dans le répertoiretest  :

{
  "require": {
    "twig/extensions": "~1.0"
  }
}

Ce tableau JSON est le minimum syndical : il ne précise que les dépendances via la clérequire. Il n'y a ici qu'une seule dépendance :"twig/extensions". La version requise pour cette dépendance est"~1.0", cela signifie qu'on veut la version la plus récente dans la branche1.* .

Un point sur les versions, voici ce que vous pouvez mettre :

Valeur

Exemple

Description

Un numéro de version exact

"2.0.17"

Ainsi, Composer téléchargera cette version exacte.

Une plage de versions

">=2.0,<2.6"

Ainsi, Composer téléchargera la version la plus à jour, à partir de la version 2.0 et en s'arrêtant avant la version 2.6. Par exemple, si les dernières versions sont 2.4, 2.5 et 2.6, Composer téléchargera la version 2.5.

Une plage de versions sémantique

"~2.1" 

Ainsi, Composer téléchargera la version la plus à jour, à partir de la version 2.1 et en s'arrêtant avant la version 3.0. C'est une façon plus simple d'écrire">=2.1,<3.0"  avec la syntaxe précédente. C'est la façon la plus utilisée pour définir la version des dépendances.

Un numéro de version avec joker « * »

"2.0.*"

Ainsi, Composer téléchargera la version la plus à jour qui commence par 2.0. Par exemple, il téléchargerait la version 2.0.17, mais pas la version 2.1.1.

Un nom de branche "dev-XXX" 

 

C'est un cas un peu particulier, où Composer ira chercher la dernière modification d'une branche Git en particulier. N'utilisez cette syntaxe que pour les bibliothèques dont il n'existe pas de vraie version. Vous verrez assez souvent "dev-master", où "master" correspond à la branche principale d'un dépôt Git.

Dans notre cas,"~1.0"correspond à la branche1.* .

Pour information, vous pouvez consulter les informations de cette bibliothèque sur Packagist. Vous voyez que les seules versions stables existantes (à l'heure où j'écris ces lignes) sont :1.0.0, 1.0.1, 1.1.0, 1.2.0 et 1.3.0 . Notre contrainte de version"~1.0"  les accepte toutes, Composer ira donc chercher dans notre cas la version la plus récente, ici1.3.0 .

Vous constatez également qu'elle dépend d'une autre bibliothèque,"twig/twig", qui correspond au moteur de templates Twig à proprement parler. Elle en a besoin dans sa version"~1.20", Composer ira donc chercher la dernière version dans la branche1.* , en prenant la version1.20  minimum. A l'heure où j'écris ces lignes, il s'agit de la version 1.23.1

Mettre à jour les dépendances

Pour mettre à jour toutes les dépendances,"twig/extensions"dans notre cas, il faut exécuter la commandeupdatede Composer, comme ceci :

C:\wamp\www\test>php ../composer.phar update
Loading composer repositories with package information
Updating dependencies (including require-dev)
 - Installing twig/twig (v1.23.1)
 Downloading: 100%

 - Installing twig/extensions (v1.3.0)
 Downloading: 100%

Writing lock file
Generating autoload files

C:\wamp\www\test>

Et voilà !

Vous pouvez aller vérifier dans le répertoiretest/vendor:

  • Composer a téléchargé la dépendance"twig/extensions"que l'on a définie, dansvendor/twig/extensions;

  • Composer a téléchargé la dépendance"twig/twig"de notre dépendance à nous, dansvendor/twig/twig;

  • Composer a généré les fichiers nécessaires pour l'autoload, allez vérifier le fichiervendor/composer/autoload_namespaces.php.

Tout est maintenant OK pour se servir de"twig/extensions"dans votre projet ! C'était donc la démarche et le fonctionnement pour la gestion des dépendances avec Composer. Mais revenons maintenant à notre projet sous Symfony.

Mettons à jour Symfony

Si vous avez téléchargé Symfony il y a quelque temps, peut-être qu'une nouvelle version est sortie depuis votre installation. Vous pouvez voir qu'en fait il existe déjà un fichier de définition des dépendances à la racine de votre projet : le fichiercomposer.json. N'hésitez pas à l'ouvrir : vous pourrez y voir toutes les dépendances déjà définies.

Il ne vous reste plus qu'à dire à Composer de mettre à jour toutes les dépendances de votre projet, grâce à la commande suivante :

php ../composer.phar update

Cela va prendre un peu de temps, car Composer a beaucoup à télécharger, les dépendances d'un projet Symfony étant nombreuses. Il y a en effet Symfony en lui-même, mais également Doctrine, Twig, certains bundles, etc.

Et voilà, Composer vient de mettre à jour toutes vos dépendances ! Maintenant, on va pouvoir en ajouter une nouvelle : un bundle Symfony !

Installer un bundle avec Composer

Dans ce paragraphe, nous allons installer le bundle DoctrineFixtureBundle, qui permet de préremplir la base de données avec des données, afin de bien tester votre application. Cependant, les explications sont valables pour l'installation de n'importe quel bundle, retenez donc bien la méthode.

1. Trouver le nom du bundle

Vous l'avez compris, on définit une dépendance dans Composer via son nom. Il faut donc logiquement connaître ce nom pour pouvoir l'installer. Pour cela, rien de plus simple, on se rend sur http://packagist.org/ et on fait une petite recherche. Dans notre cas, recherchez « fixture », et cliquez sur le bundle de Doctrine, « doctrine/doctrine-fixtures-bundle ».

2. Déterminer la version du bundle

Une fois que vous avez trouvé votre bundle, il faut en sélectionner une version. Il se peut que celui-ci n'ait pas vraiment de version fixe, et que seul"dev-master"soit disponible. Dans ce cas, assurez vous (auprès du développeur, ou en regardant le code) qu'il est compatible avec votre projet.

Mais la plupart du temps, les bundles sont versionnés et c'est à vous de choisir la version qui vous convient. Restons sur notre cas du bundle fixture : https://packagist.org/packages/doctrin [...] xtures-bundle . Les deux dernières versions stables sont"2.2.1"et"2.3.0":

  • Regardez les prérequis de la version 2.2.1 : il est indiqué que cette version a besoin de"symfony/symfony"dans sa version 2.x (notamment une version plus récente que 2.1). Cette contrainte ne nous permet pas d'installer cette dépendance, car nous utilisons Symfony en version 3.0 ;

  • Regardez alors les prérequis de la version 2.3.0 : ~2.3|~3.0 . Cette version nous convient mieux, vous voyez que l'opérateur|  vient inclure notre version 3.0 de Symfony.

On choisit alors la version"2.3.0"du bundle, ou plus précisément toute la branche2.* à partir de la version 2.3 grâce à la contrainte"~2.3" .

3. Déclarer le bundle à Composer

Une fois qu'on a le nom du bundle et sa version, il faut le déclarer à Composer, dans le fichiercomposer.json. On sait déjà le faire, il faut modifier la section"require", voici ce que cela donne :

// composer.json

// …

"require": {
  "php": ">=5.5.9",
  // …
  "incenteev/composer-parameter-handler": "~2.0",
  "doctrine/doctrine-fixtures-bundle": "~2.3"
},

// …
4. Mettre à jour les dépendances

Une fois la dépendance déclarée à Composer, il ne reste qu'à mettre à jour les dépendances, avec la commandeupdate:

C:\wamp\www\Symfony>php ../composer.phar update
Loading composer repositories with package information
Updating dependencies (including require-dev)
 - Installing doctrine/data-fixtures (v1.1.1)
 Loading from cache

 - Installing doctrine/doctrine-fixtures-bundle (2.3.0)
 Downloading: 100%

[…]
5. Enregistrer le bundle dans le Kernel

Dernier point, totalement indépendant de Composer : il faut déclarer le bundle dans le Kernel de Symfony. Allez dansapp/AppKernel.phpet ajoutez le bundle à la liste :

<?php
// app/AppKernel.php

// …

  if (in_array($this->getEnvironment(), array('dev', 'test'))) {
      // ...
      $bundles[] = new Doctrine\Bundle\FixturesBundle\DoctrineFixturesBundle();
    }

// …

Voilà, votre bundle est opérationnel !

Mais comment Composer donne à Symfony les informations pour l'autoload ?

Bonne question. Composer s'occupe vraiment de tout, et notamment de déclarer les namespaces pour l'autoload : allez le vérifier dans le fichiervendor/composer/autoload_namespaces.php. Ce fichier contient tous les namespaces nécessaires pour votre projet. C'est lui que Symfony inclut déjà, vérifiez-le en regardant le fichierapp/autoload.php, on y voit cette ligne :

<?php
$loader = require __DIR__.'/../vendor/autoload.php';
// …

Voilà comment Symfony utilise Composer pour gérer son autoload.

Gérer l'autoload d'une bibliothèque manuellement

Il se peut que vous ayez besoin d'utiliser une bibliothèque qui n'est pas référencée sur Packagist. Composer ne peut pas gérer entièrement cette bibliothèque, car il n'a pas ses informations : comment la mettre à jour, quelles sont ses dépendances, etc.

Par contre, vous avez tout de même envie de l'intégrer dans votre projet. Notamment, vous souhaitez la charger automatiquement grâce à l'autoload PHP. Il existe un moyen rapide pour y arriver : il faut ajouter les informations à la section"autoload" de votrecomposer.json. Composer ne mettra pas son nez dans cette section pour tout ce qui est installation et mises à jour. Par contre, il l'inclura dans son fichier d'autoload que Symfony2 charge. Voici ce que vous devez rajouter (ligne 8 dans le code suivant) :

// composer.json

{
  // …

  "autoload": {
    "psr-4": {
      "": "src/",
      "VotreNamespace": "chemin/vers/la/bibliotheque"
    },
    "files": [ "app/AppKernel.php" ]
  },

  // …
}

L'idée est donc de dire manuellement à Composer que votre bibliothèqueVotreNamespace  se trouve dans le répertoirechemin/vers/la/bibliothèque. Enfin, pour que Composer regénère les fichiers d'autoload avec cette nouvelle information, il faut exécuter sa commandedump-autoload :

C:\wamp\www\Symfony>php ../composer.phar dump-autoload
Generating autoload files

Bien sûr, pour que cela fonctionne il faut que votre bibliothèque respecte la convention PSR-4, c'est-à-dire une convention de nommage et d'autoloading. Je vous invite à lire le lien pour en savoir plus à ce propos. Symfony suit bien entendu cette convention.

Pour conclure

Ce chapitre-parenthèse sur Composer touche à sa fin. S'il vous semble un peu décalé aujourd'hui, vous me remercierez un peu plus tard de vous en avoir parlé, lorsque vous voudrez installer des bundles trouvés à droite ou à gauche. D'ailleurs, on a déjà installé DoctrineFixtureBundle, un bundle bien pratique dont nous nous resservirons dès la prochaine partie sur Doctrine !

Sachez également que je n'ai absolument pas tout dit sur Composer, car cela ferait trop long et ce n'est pas tellement l'objet de ce tutoriel. Cependant, Composer a sa propre documentation et je vous invite à vous y référer. Par curiosité, par intérêt, en cas de problème, n'hésitez pas : http://getcomposer.org !

En résumé

  • Composer est un outil pour gérer les dépendances d'un projet en PHP, qu'il soit sous Symfony ou non.

  • Le fichiercomposer.jsonpermet de lister les dépendances que doit inclure Composer dans votre projet.

  • Composer détermine la meilleure version possible pour vos dépendances, les télécharge, et configure leur autoload tout seul.

  • Composer trouve toutes les bibliothèques sur le sitehttp://www.packagist.org, sur lequel vous pouvez envoyer votre propre bibliothèque si vous le souhaitez.

  • La très grande majorité des bundles Symfony sont installables avec Composer, ce qui simplifie énormément leur utilisation dans un projet.

  • Le code du cours tel qu'il doit être à ce stade est disponible sur la branche iteration-6 du dépot Github.

Example of certificate of achievement
Example of certificate of achievement