Comment installer et utiliser Composer sur Ubuntu 14.04

Introduction

Composer est un outil populaire de gestion des dépendances pour PHP, créé principalement pour faciliter l'installation et les mises à jour des dépendances du projet. Il vérifiera de quels autres packages dépend un projet spécifique et les installera pour vous, en utilisant les versions appropriées en fonction des exigences du projet.

Ce tutoriel montrera comment installer et démarrer avec Composer sur un serveur Ubuntu 14.04.

Conditions préalables

Pour ce tutoriel, vous aurez besoin de :

Un serveur exécutant Ubuntu 14.04
Accès au serveur en tant qu'utilisateur régulier avec autorisation sudo

Étape 1 - Installation des dépendances

Avant de télécharger et d'installer Composer, nous devons nous assurer que toutes les dépendances sont installées sur notre serveur.

Tout d'abord, mettez à jour le cache du gestionnaire de packages en exécutant :

sudo apt-get update

Maintenant, installons les dépendances. Nous aurons besoin de curl pour télécharger Composer et de php5-cli pour l'installer et l'exécuter. git est utilisé par Composer pour télécharger les dépendances du projet. Tout peut être installé avec la commande suivante :

sudo apt-get install curl php5-cli git

Vous pouvez maintenant passer à l'étape suivante.

Étape 2 - Téléchargement et installation de Composer

L'installation de Composer est vraiment simple et peut se faire avec une seule commande :

curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer

Cela téléchargera et installera Composer en tant que commande à l'échelle du système nommée composer, sous /usr/local/bin. La sortie devrait ressembler à ceci :

Output#!/usr/bin/env php
All settings correct for using Composer
Downloading...

Composer successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Pour tester votre installation, exécutez :

composer

Et vous devriez obtenir une sortie similaire à celle-ci :

Output   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.0-dev (9859859f1082d94e546aa75746867df127aa0d9e) 2015-08-17 14:57:00

Usage:
 command [options] [arguments]

Options:
 --help (-h)           Display this help message
 --quiet (-q)          Do not output any message
 --verbose (-v|vv|vvv) Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
 --version (-V)        Display this application version
 --ansi                Force ANSI output
 --no-ansi             Disable ANSI output
 --no-interaction (-n) Do not ask any interactive question
 --profile             Display timing and memory usage information
 --working-dir (-d)    If specified, use the given directory as working directory.

. . .

Cela signifie que Composer a été installé avec succès sur votre système.

Si vous préférez avoir des exécutables Composer distincts pour chaque projet que vous pourriez héberger sur ce serveur, vous pouvez simplement l'installer localement, projet par projet. Cette méthode est également utile lorsque l'utilisateur de votre système n'est pas autorisé à installer des logiciels à l'échelle du système. Dans ce cas, l'installation peut être effectuée avec curl -sS https://getcomposer.org/installer | php - cela générera un fichier composer.phar dans votre répertoire actuel, qui peut être exécuté avec php composer.phar [command].

Étape 3 - Génération du fichier composer.json

Pour utiliser Composer dans votre projet, vous aurez besoin d'un fichier composer.json. Le fichier composer.json indique essentiellement à Composer quelles dépendances il doit télécharger pour votre projet et quelles versions de chaque package sont autorisées à être installées. Ceci est extrêmement important pour garder votre projet cohérent et éviter d'installer des versions instables qui pourraient potentiellement causer des problèmes de rétrocompatibilité.

Vous n'avez pas besoin de créer ce fichier manuellement - il est facile de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer génère automatiquement le fichier composer.json lorsque vous ajoutez une dépendance à votre projet à l'aide de la commande require. Des dépendances supplémentaires peuvent également être ajoutées de la même manière, sans qu'il soit nécessaire de modifier manuellement ce fichier.

Le processus d'utilisation de Composer pour installer un package en tant que dépendance dans un projet implique généralement les étapes suivantes :

Identifier le type de bibliothèque dont l'application a besoin
Recherchez une bibliothèque open source appropriée sur Packagist.org, le référentiel officiel de Composer
Choisissez le forfait dont vous voulez dépendre
Exécutez composer require pour inclure la dépendance dans le fichier composer.json et installez le package

Nous verrons comment cela fonctionne en pratique avec une simple application de démonstration.

Le but de cette application est de transformer une phrase donnée en une chaîne conviviale pour les URL - un slug. Ceci est couramment utilisé pour convertir les titres de page en chemins d'URL (comme la dernière partie de l'URL de ce didacticiel).

Commençons par créer un répertoire pour notre projet. Nous l'appellerons slugify :

cd ~
mkdir slugify
cd slugify

Recherche de packages sur Packagist

Il est maintenant temps de chercher sur Packagist.org un paquet qui peut nous aider à générer des slugs. Si vous recherchez le terme "slug" sur Packagist, vous obtiendrez un résultat similaire à celui-ci :

Vous verrez deux numéros sur le côté droit de chaque paquet dans la liste. Le nombre en haut représente le nombre de fois que le package a été installé, et le nombre en bas indique le nombre de fois qu'un package a été mis en vedette sur GitHub. Vous pouvez réorganiser les résultats de la recherche en fonction de ces numéros (recherchez les deux icônes sur le côté droit de la barre de recherche). De manière générale, les packages avec plus d'installations et plus d'étoiles ont tendance à être plus stables, car de nombreuses personnes les utilisent. Il est également important de vérifier la pertinence de la description du package - est-ce vraiment ce que vous recherchez ?

Ce dont nous avons besoin est un simple convertisseur de chaîne en slug. D'après les résultats de la recherche, le package cocur/slugify semble être un bon match, avec un nombre raisonnable d'installations et d'étoiles. (Le package est un peu plus bas sur la page que ne le montre la capture d'écran.)

Vous remarquerez que les packages sur Packagist ont un nom fournisseur et un nom package. Chaque package a un identifiant unique (un espace de noms) dans le même format que Github utilise pour ses référentiels : vendor/package. La bibliothèque que nous voulons installer utilise l'espace de noms cocur/slugify L'espace de noms est ce dont nous avons besoin pour exiger le package dans notre projet.

Exiger un package

Maintenant que nous savons exactement quel package nous voulons installer, nous pouvons exécuter composer require pour l'inclure en tant que dépendance et également générer le fichier composer.json pour le projet :

composer require cocur/slugify

OutputUsing version ^1.3 for cocur/slugify
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing cocur/slugify (v1.3)
    Downloading: 100%         

Writing lock file
Generating autoload files

Comme vous pouvez le voir sur la sortie, Composer a automatiquement décidé quelle version du package doit être utilisée. Si vous vérifiez maintenant le répertoire de votre projet, il contiendra deux nouveaux fichiers : composer.json et composer.lock, et un répertoire vendor :

ls -l

Outputtotal 12
-rw-rw-r-- 1 sammy sammy   59 Sep  9 16:22 composer.json
-rw-rw-r-- 1 sammy sammy 2835 Sep  9 16:22 composer.lock
drwxrwxr-x 4 sammy sammy 4096 Sep  9 16:22 vendor

Le fichier composer.lock est utilisé pour stocker des informations sur les versions de chaque package installées et pour s'assurer que les mêmes versions sont utilisées si quelqu'un d'autre clone votre projet et installe ses dépendances. Le répertoire vendor est l'endroit où se trouvent les dépendances du projet. Le dossier vendor ne doit pas être engagé dans le contrôle de version - il vous suffit d'inclure les fichiers composer.json et composer.lock.

Lors de l'installation d'un projet qui contient déjà un fichier composer.json, vous devez exécuter composer install afin de télécharger les dépendances du projet.

Comprendre les contraintes de version

Si vous vérifiez le contenu de votre fichier composer.json, vous verrez quelque chose comme ceci :

cat composer.json

compositeur.json

{
    "require": {
        "cocur/slugify": "^1.3"
    }
}

Vous remarquerez peut-être le caractère spécial ^ avant le numéro de version sur composer.json. Composer prend en charge plusieurs contraintes et formats différents pour définir la version de package requise, afin de fournir une flexibilité tout en maintenant la stabilité de votre projet. L'opérateur caret (^) utilisé par le fichier composer.json généré automatiquement est l'opérateur recommandé pour une interopérabilité maximale, suite au versioning sémantique. Dans ce cas, il définit 1.3 comme la version minimale compatible et autorise les mises à jour vers toute future version inférieure à 2.0.

De manière générale, vous n'aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Cependant, certaines situations peuvent nécessiter que vous modifiiez manuellement les contraintes - par exemple, lorsqu'une nouvelle version majeure de votre bibliothèque requise est publiée et que vous souhaitez effectuer une mise à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la gestion sémantique des versions.

Voici quelques exemples pour vous permettre de mieux comprendre le fonctionnement des contraintes de version de Composer :

Contrainte	Sens	Exemples de versions autorisées
^1.0	>= 1,0 < 2,0	1.0, 1.2.3, 1.9.9
^1.1.0	>= 1.1.0 < 2.0	1.1.0, 1.5.6, 1.9.9
~1.0	>= 1.0 < 2.0.0	1.0, 1.4.1, 1.9.9
~1.0.0	>= 1.0.0 < 1.1	1.0.0, 1.0.4, 1.0.9
1.2.1	1.2.1	1.2.1
1.*	>= 1,0 < 2,0	1.0.0, 1.4.5, 1.9.9
1.2.*	>= 1,2 < 1,3	1.2.0, 1.2.3, 1.2.9

Pour une vue plus détaillée des contraintes de version de Composer, consultez leur documentation officielle.

Étape 4 - Inclure le script de chargement automatique

Composer fournit également un script de chargement automatique que vous pouvez inclure dans votre projet pour obtenir le chargement automatique gratuitement. Cela facilite grandement le travail avec vos dépendances et la définition de vos propres espaces de noms.

La seule chose que vous devez faire est d'inclure le fichier vendor/autoload.php dans vos scripts PHP, avant toute instanciation de classe.

Revenons à l'exemple d'application slugify. Nous allons créer un script test.php où nous utiliserons la bibliothèque cocur/slugify :

vim test.php

test.php

<?php
require __DIR__ . '/vendor/autoload.php';

use Cocur\Slugify\Slugify;

$slugify = new Slugify();

echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');

Vous pouvez exécuter le script en ligne de commande avec :

php test.php

Cela devrait produire la sortie hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

Étape 5 - Mise à jour des dépendances du projet

Chaque fois que vous souhaitez mettre à jour les dépendances de votre projet, il vous suffit d'exécuter la commande update :

composer update

Cela vérifiera les versions plus récentes des bibliothèques dont vous avez besoin dans votre projet. Si une version plus récente est trouvée et qu'elle est compatible avec la contrainte de version définie dans le fichier composer.json, elle remplacera la version précédente installée. Le fichier composer.lock sera mis à jour pour refléter ces modifications.

Vous pouvez également mettre à jour une ou plusieurs bibliothèques spécifiques en exécutant :

composer update vendor/package vendor2/package2

Conclusion

Composer est un outil puissant que tout développeur PHP devrait avoir dans sa ceinture utilitaire.

En plus de fournir un moyen simple et fiable de gérer les dépendances des projets, il établit également une nouvelle norme de facto pour le partage et la découverte des packages PHP créés par la communauté.

Ce didacticiel a couvert les éléments essentiels pour démarrer avec Composer sur Ubuntu 14.04.