Composer

Introduction

Dans ce chapitre, nous allons explorer l'utilisation de Composer, un outil essentiel pour la gestion des dépendances dans les projets PHP. Composer est un gestionnaire de packages qui permet d'installer, de mettre à jour et de gérer les bibliothèques externes nécessaires à un projet.

Lorsque nous développons des applications PHP, il est courant d'avoir besoin d'utiliser des bibliothèques tierces pour ajouter des fonctionnalités supplémentaires ou pour faciliter le développement. Composer simplifie grandement ce processus en automatisant la résolution des dépendances et en assurant la compatibilité entre les différentes versions des bibliothèques utilisées.

Installation de Composer

Avant de commencer à utiliser Composer, nous devons d'abord l'installer sur notre machine. Composer est un outil en ligne de commande qui nécessite une installation préalable. Voici les étapes pour installer Composer :

Rendez-vous sur le site officiel de Composer à l'adresse suivante : https://getcomposer.org/.
Suivez les instructions spécifiques à votre système d'exploitation pour télécharger et installer Composer.
Une fois l'installation terminée, vous devriez pouvoir exécuter la commande composer dans votre terminal et voir s'afficher la liste des commandes disponibles.

Maintenant que Composer est installé, nous pouvons passer à la création d'un projet Composer et à l'ajout de dépendances externes à notre projet.

Création d'un dossier et initialisation du projet Composer

Avant de commencer à utiliser Composer, nous devons créer un dossier pour notre projet. Ce dossier servira de répertoire racine pour notre projet Composer. Vous pouvez choisir n'importe quel emplacement sur votre système de fichiers pour créer ce dossier.

Une fois le dossier créé, ouvrez votre terminal et naviguez jusqu'au répertoire que vous venez de créer en utilisant la commande cd (change directory). Par exemple, si vous avez créé un dossier nommé "mon-projet", vous pouvez utiliser la commande suivante pour vous déplacer dans ce dossier :

cd mon-projet

Une fois que vous êtes dans le dossier de votre projet, vous pouvez initialiser le projet Composer en utilisant la commande suivante :

composer init

Cette commande lancera un assistant interactif qui vous guidera tout au long du processus d'initialisation du projet. Vous serez invité à fournir des informations sur votre projet, telles que le nom du projet, sa description, la version, l'auteur, etc. Répondez aux questions de l'assistant en fonction des besoins spécifiques de votre projet.

Une fois que vous avez terminé de répondre aux questions, Composer générera un fichier composer.json dans le répertoire racine de votre projet. Ce fichier contient les informations de configuration de votre projet, y compris les dépendances requises.

Ajoutez la propriété script dans le fichier composer.json

{
  // ...
  "scripts": { "test": "vendor/bin/pest" },
  // ...
}

Maintenant que nous avons initialisé notre projet Composer, nous pouvons passer à l'installation de la bibliothèque Pest.

Installation de Pest

Pour installer le framework de tests PHP Pest, suivez les étapes suivantes :

Prérequis : PHP 8.1+

Avant de commencer, assurez-vous d'avoir PHP 8.1+ ou une version supérieure installée sur votre système.

Ouvrez votre terminal et placez-vous dans le répertoire de votre projet.
Exécutez la commande suivante pour ajouter Pest en tant que dépendance "dev" dans votre projet :

composer require pestphp/pest --dev --with-all-dependencies

Cette commande téléchargera et installera Pest ainsi que toutes ses dépendances nécessaires dans le répertoire vendor de votre projet.

Ensuite, vous devez initialiser Pest dans votre projet PHP actuel. Cette étape créera un fichier de configuration nommé Pest.php à la racine de votre suite de tests. Ce fichier de configuration vous permettra de personnaliser votre suite de tests ultérieurement. Pour initialiser Pest, exécutez la commande suivante :

./vendor/bin/pest --init

Enfin, vous pouvez exécuter vos tests en utilisant la commande pest :

./vendor/bin/pest

composer test

L'importance des tests

Les tests sont une partie essentielle du processus de développement logiciel. Ils permettent de vérifier que notre code fonctionne correctement, de détecter les erreurs et les bugs, et de s'assurer que les fonctionnalités attendues sont bien présentes.

Les tests offrent plusieurs avantages :

Détection précoce des erreurs : Les tests permettent de détecter les erreurs dès leur apparition, ce qui facilite leur correction avant qu'elles ne se propagent dans le code.
Confiance dans les modifications : Les tests garantissent que les modifications apportées au code ne causent pas de régressions ou d'effets indésirables. Ils permettent de s'assurer que les fonctionnalités existantes continuent de fonctionner correctement.
Facilité de collaboration : Les tests fournissent une base commune pour la collaboration entre les membres de l'équipe de développement. Ils permettent de s'assurer que tous les membres comprennent le comportement attendu du code.
Documentation vivante : Les tests servent également de documentation vivante pour le code. Ils décrivent les comportements attendus et permettent de comprendre rapidement comment utiliser et interagir avec les différentes parties du code.

Écriture des tests

Dans Pest, les tests sont écrits en utilisant la syntaxe de test fluide et expressive de l'API d'attente. Voici comment écrire des tests avec Pest :

test('nom du test', function () {
    // Code à tester et assertions
});

it('should do something', function () {
    // Code à tester et assertions
});

Dans cette structure de test, vous devez fournir un nom descriptif pour votre test et une fonction anonyme qui contient le code à tester et les assertions.

Les assertions sont effectuées en utilisant l'API d'attente de Pest. Vous pouvez commencer une assertion en utilisant la fonction expect($value) et la chaîner avec une méthode d'attente pour vérifier une condition spécifique.

Voici un exemple de test utilisant l'API d'attente de Pest :

test('addition', function () {
    $result = sum(2, 3);

    expect($result)->toBe(5);
});

Dans cet exemple, nous testons une fonction sum() qui doit retourner la somme de deux nombres. Nous utilisons l'attente toBe() pour vérifier que le résultat de la fonction est égal à 5.

Vous pouvez également combiner plusieurs attentes dans un même test en les chaînant :

test('multiplication', function () {
    $result = multiply(2, 3);

    expect($result)
        ->toBeInt()
        ->toBe(6);
});

Dans cet exemple, nous testons une fonction multiply() qui doit retourner le produit de deux nombres. Nous utilisons les attentes toBeInt() et toBe() pour vérifier que le résultat est un entier et qu'il est égal à 6.

Exemples de tests

Voici trois exemples supplémentaires de tests que vous pouvez écrire avec Pest :

test("vérification d'une chaîne", function () {
    $string = 'Hello, World!';

    expect($string)
        ->toBeString()
        ->toContain('Hello')
        ->not->toContain('foo');
});

test("vérification d'un tableau", function () {
    $array = [1, 2, 3];

    expect($array)
        ->toBeArray()
        ->toHaveCount(3)
        ->toContain(2)
        ->not->toContain(4);
});

test("vérification d'un objet", function () {
    $object = new stdClass();
    $object->name = 'John Doe';

    expect($object)
        ->toBeObject()
        ->toHaveProperty('name')
        ->toHavePropertyWithValue('name', 'John Doe');
});

Ces exemples illustrent différentes utilisations de l'API d'attente de Pest pour effectuer des assertions sur des chaînes, des tableaux et des objets.

Expectations

Liste des fonctions utilisables

toBe()
toBeArray()
toBeBetween()
toBeEmpty()
toBeTrue()
toBeTruthy()
toBeFalse()
toBeFalsy()
toBeGreaterThan()
toBeGreaterThanOrEqual()
toBeLessThan()
toBeLessThanOrEqual()
toContain()
toContainOnlyInstancesOf()
toHaveCount()
toHaveMethod()
toHaveMethods()
toHaveProperty()
toHaveProperties()
toMatchArray()
toMatchObject()
toEqual()
toEqualCanonicalizing()
toEqualWithDelta()
toBeIn()
toBeInfinite()
toBeInstanceOf()
toBeBool()
toBeCallable()
toBeFile()
toBeFloat()
toBeInt()
toBeIterable()
toBeNumeric()
toBeDigits()
toBeObject()
toBeResource()
toBeScalar()
toBeString()
toBeJson()
toBeNan()
toBeNull()
toHaveKey()
toHaveKeys()
toHaveLength()
toBeReadableDirectory()
toBeReadableFile()
toBeWritableDirectory()
toBeWritableFile()
toStartWith()
toThrow()
toEndWith()
toMatch()
toMatchConstraint()
toBeUppercase()
toBeLowercase()
toBeAlpha()
toBeAlphaNumeric()
toBeSnakeCase()
toBeKebabCase()
toBeCamelCase()
toBeStudlyCase()
toHaveSnakeCaseKeys()
toHaveKebabCaseKeys()
toHaveCamelCaseKeys()
toHaveStudlyCaseKeys()
toHaveSameSize()
toBeUuid()

Helpers

Liste de helpers

and()
dd()
ddWhen()
ddUnless()
each()
json()
match()
not
ray()
sequence()
unless()
when()

Intégration continue avec GitHub Actions

GitHub Actions est une fonctionnalité de GitHub qui permet d'automatiser les workflows et les tâches courantes liées au développement logiciel. Cela inclut notamment l'intégration continue (CI), qui consiste à exécuter automatiquement des tests et des tâches de construction à chaque fois qu'un nouveau commit est effectué ou qu'une pull request est ouverte.

Pour ajouter une action GitHub depuis votre projet, vous pouvez cliquer sur l'onglet "Actions" de votre dépôt GitHub. Vous y trouverez une liste d'actions prédéfinies que vous pouvez utiliser ou personnaliser selon vos besoins.

Dans notre cas, nous allons ajouter l'action "PHP Composer" pour automatiser l'installation des dépendances et l'exécution des tests à chaque fois qu'un commit est effectué sur la branche principale (main).

Code du fichier .github/workflows/php.yml :

name: PHP Composer

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

permissions:
  contents: read

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3

    - name: Validate composer.json and composer.lock
      run: composer validate --strict

    - name: Cache Composer packages
      id: composer-cache
      uses: actions/cache@v3
      with:
        path: vendor
        key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }}
        restore-keys: |
          ${{ runner.os }}-php-

    - name: Install dependencies
      run: composer install --prefer-dist --no-progress

    - name: Run test suite
      run: composer run-script test

Ce fichier de configuration définit un workflow nommé "PHP Composer" qui sera déclenché à chaque push ou pull request sur la branche principale (main). Le workflow est exécuté sur une machine virtuelle Ubuntu.

Les étapes du workflow sont les suivantes :

L'étape "Validate composer.json and composer.lock" valide la structure et la validité du fichier composer.json et composer.lock.
L'étape "Cache Composer packages" utilise le cache d'actions de GitHub pour stocker les packages Composer afin d'accélérer les futures installations.
L'étape "Install dependencies" installe les dépendances du projet en utilisant la commande composer install.
L'étape "Run test suite" exécute la suite de tests en utilisant la commande composer run-script test.

Une fois que vous avez ajouté le fichier de configuration à votre dépôt GitHub, l'action "PHP Composer" sera automatiquement déclenchée à chaque fois qu'un commit est effectué sur la branche principale (main). Vous pourrez voir les résultats des tests dans l'onglet "Actions" de votre dépôt.

Assurez-vous de commit et de push le fichier de configuration .github/workflows/php.yml depuis l’interface de github pour que l'action soit prise en compte. Ensuite, vous devrez pull les fichiers sur votre ordinateur.

Exercice : Librairie de fonctions statistiques

Maintenant que nous avons installé Pest, configuré GitHub Actions et compris comment écrire des tests, nous pouvons passer à la création de notre librairie de fonctions statistiques. Cette librairie fournira un ensemble de fonctions pour effectuer des calculs statistiques sur des tableaux de nombres.

Organisation du code source de la librairie

Avant de commencer à écrire les fonctions statistiques, il est important d'organiser correctement le code source de notre librairie. Voici une structure de base recommandée :

stats/
├── src/
│   ├── Functions/
│   │   ├── Average.php
│   │   ├── Median.php
│   │   ├── StandardDeviation.php
│   │   ├── Variance.php
│   │   └── ...
│   └── Stats.php
├── tests/
│   ├── Functions/
│   │   ├── AverageTest.php
│   │   ├── MedianTest.php
│   │   ├── StandardDeviationTest.php
│   │   ├── VarianceTest.php
│   │   └── ...
│   └── TestCase.php
├── composer.json
└── README.md

Dans cette structure, nous avons un dossier src qui contiendra nos fichiers source, et un dossier tests qui contiendra nos fichiers de tests. Les fichiers de source et de test sont organisés en fonction des fonctions statistiques qu'ils implémentent.

Création des fonctions statistiques

Nous allons maintenant écrire les fonctions statistiques dans nos fichiers source. Chaque fonction sera implémentée dans une classe séparée, suivant le principe de la programmation orientée objet.

Voici un exemple d'implémentation de la fonction de calcul de la moyenne dans le fichier Average.php :

<?php

namespace Opmvpc\Statistiques\Functions;

class Average
{
    public static function calculate(array $numbers): float
    {
        $sum = array_sum($numbers);
        $count = count($numbers);

        return $sum / $count;
    }
}

De manière similaire, vous pouvez implémenter les autres fonctions statistiques telles que la médiane, l'écart-type et la variance dans des classes séparées.

Tests unitaires pour les fonctions statistiques

Maintenant que nous avons implémenté nos fonctions statistiques, nous devons écrire des tests unitaires pour vérifier leur bon fonctionnement. Les tests unitaires nous permettront de valider chaque fonction individuellement et de nous assurer qu'elle renvoie les résultats attendus.

Voici un exemple de test unitaire pour la fonction de calcul de la moyenne dans le fichier AverageTest.php :

<?php

use Opmvpc\Statistiques\Functions\Average;

test("peux calculer la moyenne d'une liste", function () {
    $list = [10, 15, 14, 16, 20];

    expect(Average::calculate($list))->toBe(15.0);
});

De manière similaire, vous pouvez écrire des tests unitaires pour les autres fonctions statistiques en utilisant les données d'entrée appropriées et en vérifiant les résultats attendus. Testez avec des données différentes. Testez les cas limites.

Conclusion

Dans ce chapitre, nous avons appris à utiliser Composer pour créer un package de fonctions statistiques. Nous avons installé Pest, un framework de tests PHP, et écrit des tests unitaires pour nos fonctions statistiques. Nous avons également configuré GitHub Actions pour l'intégration continue de notre projet.

En utilisant Composer, Pest et GitHub Actions, nous avons pu automatiser le processus d'installation des dépendances, d'exécution des tests et de vérification de l'intégrité du code. Cela nous permet de développer notre librairie de fonctions statistiques de manière efficace et fiable.

Exercices complémentaires

Ajoutez des fonctionnalités de génération de graphiques à leur librairie de fonctions statistiques en incluant la bibliothèque c-pchart. Cette bibliothèque permet de créer des graphiques en PHP de manière flexible et personnalisée.

Voici un exemple de code utilisant la bibliothèque c-pchart pour générer un graphique :

use CpChart\Data;
use CpChart\Image;

/* Créer et remplir l'objet Data */
$data = new Data();
for ($i = 0; $i <= 20; $i++) {
    $data->addPoints(rand(0, 20), "Sonde 1");
}
for ($i = 0; $i <= 20; $i++) {
    $data->addPoints(rand(0, 20), "Sonde 2");
}
$data->setSerieShape("Sonde 1", SERIE_SHAPE_FILLEDTRIANGLE);
$data->setSerieShape("Sonde 2", SERIE_SHAPE_FILLEDSQUARE);
$data->setAxisName(0, "Températures");

/* Créer l'objet Image */
$image = new Image(700, 230, $data);

/* Désactiver l'antialiasing */
$image->Antialias = false;

/* Ajouter une bordure à l'image */
$image->drawRectangle(0, 0, 699, 229, ["R" => 0, "G" => 0, "B" => 0]);

/* Écrire le titre du graphique */
$image->setFontProperties(["FontName" => "Forgotte.ttf", "FontSize" => 11]);
$image->drawText(150, 35, "Température moyenne", ["FontSize" => 20, "Align" => TEXT_ALIGN_BOTTOMMIDDLE]);

/* Définir la police par défaut */
$image->setFontProperties(["FontName" => "pf_arma_five.ttf", "FontSize" => 6]);

/* Définir la zone du graphique */
$image->setGraphArea(60, 40, 650, 200);

/* Dessiner l'échelle */
$scaleSettings = [
    "XMargin" => 10,
    "YMargin" => 10,
    "Floating" => true,
    "GridR" => 200,
    "GridG" => 200,
    "GridB" => 200,
    "DrawSubTicks" => true,
    "CycleBackground" => true
];
$image->drawScale($scaleSettings);

/* Activer l'antialiasing */
$image->Antialias = true;
$image->setShadow(true, ["X" => 1, "Y" => 1, "R" => 0, "G" => 0, "B" => 0, "Alpha" => 10]);

/* Dessiner le graphique */
$image->drawPlotChart();

/* Écrire la légende du graphique */
$image->drawLegend(580, 20, ["Style" => LEGEND_NOBORDER, "Mode" => LEGEND_HORIZONTAL]);

/* Enregistrer l'image générée */
$image->autoOutput("exemple.drawPlotChart.simple.png");

Cet exemple utilise la bibliothèque c-pchart pour générer un graphique de températures moyennes. Vous pouvez personnaliser les données, les couleurs, les formes et les paramètres du graphique selon vos besoins.

Composer

Composer

Introduction#

Installation de Composer#

Création d'un dossier et initialisation du projet Composer#

Installation de Pest#

L'importance des tests#

Écriture des tests#

Exemples de tests#

Expectations#

Helpers#

Intégration continue avec GitHub Actions#

Exercice : Librairie de fonctions statistiques#

Organisation du code source de la librairie#

Création des fonctions statistiques#

Tests unitaires pour les fonctions statistiques#

Conclusion#

Exercices complémentaires#

Introduction

Installation de Composer

Création d'un dossier et initialisation du projet Composer

Installation de Pest

L'importance des tests

Écriture des tests

Exemples de tests

Expectations

Helpers

Intégration continue avec GitHub Actions

Exercice : Librairie de fonctions statistiques

Organisation du code source de la librairie

Création des fonctions statistiques

Tests unitaires pour les fonctions statistiques

Conclusion

Exercices complémentaires