Utilisation de Composer et autoloading

1. Téléchargez l'installateur depuis getcomposer.org
2. Exécutez l'installateur et suivez les instructions
3. Vérifiez l'installation avec la commande :

composer --version

Installation via la ligne de commande :

# Téléchargement du programme d'installation
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

# Vérification du hachage SHA-384 (optionnel mais recommandé)
php -r "if (hash_file('sha384', 'composer-setup.php') === '55ce33d7678c5a611085589f1f3ddf8b3c52d662cd01d4ba75c0ee0459970c2200a51f492d557530c71c15d8dba01eae') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

# Installation
php composer-setup.php

# Nettoyage
php -r "unlink('composer-setup.php');"

# Installation globale (optionnel)
sudo mv composer.phar /usr/local/bin/composer

# Vérification
composer --version

# Initialiser un nouveau projet
composer init

# Installer toutes les dépendances du projet
composer install

# Installer avec optimisation pour la production
composer install --no-dev --optimize-autoloader

# Ajouter une nouvelle dépendance
composer require monolog/monolog

# Ajouter une dépendance de développement
composer require --dev phpunit/phpunit

# Spécifier une version précise
composer require twig/twig:^3.0

# Mettre à jour toutes les dépendances
composer update

# Mettre à jour une dépendance spécifique
composer update monolog/monolog

# Supprimer une dépendance
composer remove symfony/yaml

Composer utilise le versionnement sémantique (SemVer) pour les contraintes de versions.

Contrainte	Signification	Exemple
1.2.3	Version exacte	Seule la version 1.2.3
>=1.2.3	Version minimale	1.2.3 ou plus récent
>1.2.3	Version strictement supérieure	1.2.4 ou plus récent
^1.2.3	Compatible avec les versions 1.x	≥ 1.2.3 et < 2.0.0
~1.2.3	Compatible avec les versions de correctifs	≥ 1.2.3 et < 1.3.0
1.2.*	Joker	≥ 1.2.0 et < 1.3.0
1.2.3 || 1.3.0	OU logique	Soit 1.2.3, soit 1.3.0

• monolog/monolog - Système de journalisation
• guzzlehttp/guzzle - Client HTTP
• symfony/http-foundation - Composants web fondamentaux
• twig/twig - Moteur de templates
• doctrine/orm - ORM pour bases de données
• phpunit/phpunit - Framework de test
• ramsey/uuid - Génération d'identifiants uniques
• nesbot/carbon - Manipulation des dates
• vlucas/phpdotenv - Chargement de variables d'environnement
• league/flysystem - Abstraction du système de fichiers

# Afficher les informations sur les packages installés
composer show

# Afficher les détails d'un package spécifique
composer show monolog/monolog

# Vérifier les mises à jour disponibles
composer outdated

# Vérifier les problèmes de sécurité dans les dépendances
composer audit

# Valider la configuration composer.json
composer validate

# Nettoyer le cache Composer
composer clear-cache

# Créer un projet à partir d'un squelette
composer create-project laravel/laravel mon-projet

# Exécuter un script défini dans composer.json
composer run-script test

PSR-4 est la norme d'autoloading moderne qui permet de faire correspondre les espaces de noms avec les répertoires.

Configuration dans composer.json :

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Structure de répertoires :

projet/
├── composer.json
├── src/
│   ├── Controller/
│   │   └── UserController.php
│   └── Model/
│       └── User.php

Dans src/Controller/UserController.php :

namespace App\Controller;

use App\Model\User;

class UserController
{
    public function show($id)
    {
        $user = new User($id);
        return $user->getData();
    }
}

PSR-0 (Déprécié)

{
    "autoload": {
        "psr-0": {
            "App\\": "src/"
        }
    }
}

Différence principale avec PSR-4 : PSR-0 convertit les underscores dans les noms de classes en séparateurs de répertoire.

Classmap

{
    "autoload": {
        "classmap": ["src/", "lib/"]
    }
}

Scanne les répertoires spécifiés et génère une correspondance statique entre chaque classe trouvée et son emplacement de fichier.

Files

{
    "autoload": {
        "files": ["src/helpers.php", "src/functions.php"]
    }
}

Inclut des fichiers spécifiques dans chaque requête, utile pour les fichiers de fonctions globales.

Après modification de la configuration d'autoloading :

# Régénérer les fichiers d'autoloading
composer dump-autoload

# Optimiser pour la production
composer dump-autoload --optimize

Pour utiliser l'autoloading dans vos scripts, incluez le fichier vendor/autoload.php généré par Composer :

require_once 'vendor/autoload.php';

// Maintenant, vous pouvez utiliser vos classes sans require/include
$logger = new Monolog\Logger('app');
$user = new App\Model\User(1);

Dans un projet structuré, cela se fait généralement dans un point d'entrée unique :

// public/index.php
define('ROOT_DIR', dirname(dirname(__FILE__)));

require_once ROOT_DIR . '/vendor/autoload.php';

// Code de démarrage de l'application
$app = new App\Application();
$app->run();

En production, optimisez l'autoloading pour de meilleures performances :

# Génère un fichier de class map qui accélère la résolution des classes
composer dump-autoload --optimize --no-dev

Comparaison des différentes options :

Option	Description	Utilisation
--optimize ou -o	Convertit PSR-0/PSR-4 en classmap	Production
--classmap-authoritative ou -a	Utilise uniquement le classmap (plus strict)	Production critique
--apcu	Utilise APCu pour mettre en cache les classmap	Production avec APCu
--no-dev	Exclut les dépendances de développement	Production

Exemple de classe dans src/Calculator.php :

namespace MonVendor\MonPackage;

class Calculator
{
    /**
     * Additionne deux nombres.
     *
     * @param float $a Premier nombre
     * @param float $b Second nombre
     * @return float La somme des deux nombres
     */
    public function add($a, $b)
    {
        return $a + $b;
    }
    
    /**
     * Soustrait le second nombre du premier.
     *
     * @param float $a Premier nombre
     * @param float $b Second nombre
     * @return float La différence entre les deux nombres
     */
    public function subtract($a, $b)
    {
        return $a - $b;
    }
}

Test unitaire correspondant dans tests/CalculatorTest.php :

namespace MonVendor\MonPackage\Tests;

use MonVendor\MonPackage\Calculator;
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase
{
    public function testAdd()
    {
        $calculator = new Calculator();
        $result = $calculator->add(5, 3);
        $this->assertEquals(8, $result);
    }

    public function testSubtract()
    {
        $calculator = new Calculator();
        $result = $calculator->subtract(5, 3);
        $this->assertEquals(2, $result);
    }
}

Configuration PHPUnit dans phpunit.xml.dist :

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.5/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true">
    <testsuites>
        <testsuite name="MonPackage Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
    <coverage>
        <include>
            <directory suffix=".php">src</directory>
        </include>
    </coverage>
</phpunit>