URL:     https://linuxfr.org/news/sortie-de-laravel-10
Title:   Sortie de Laravel 10
Authors: windu.2b
         Benoît Sibaud, Nÿco, Xavier Teyssier et bobble bubble
Date:    2023-01-11T11:40:26+01:00
License: CC By-SA
Tags:    php et laravel
Score:   3


Laravel, l'un des frameworks PHP les plus en vogue en ce moment, est sorti en version 10 le 7 février 2023.
Petit tour des nouveautés !

----

[Site officiel](https://laravel.com/)
[Annonce de la sortie](https://laravel-news.com/laravel-10)

----

Un an après la version 9, Laravel maintient son rythme de sortie (qui était autrefois d'une nouvelle version majeure tous les six mois).
Avec, toutefois, une évolution qui se veut sans (trop de) révolution : les changements sont plus discrets, et nécessitent moins d'intervention ou d'attention lors de la montée de version, [comme le montre d'ailleurs la taille de la page "Upgrade Guide"](https://laravel.com/docs/10.x/upgrade#main-content), qui est [l'une des plus petites de ces dernières années.](https://twitter.com/PovilasKorop/status/1625766366572605441)

Liste (non-exhaustive) des nouveautés
-----------



### Fin du support de PHP 8.0
Avec cette nouvelle version vient l'abandon du support de la version 8.0 de PHP (qui est, de toute façon, dans sa phase "_security support_" [depuis novembre 2022](https://www.php.net/supported-versions.php)). En effet, des nouveautés de PHP 8.1 et 8.2 (seules versions supportées, donc) sont utilisées par Laravel, telles que les `enum` et les propriétés de classes _readonly_.


### Déclarations natives et typage fort
Désormais, Laravel aura beaucoup plus recours au typage et aux déclarations natives. Finis les commentaires en PHPDoc : place aux types partout !
Ainsi, [ce fichier stub de Laravel 9](https://github.com/laravel/framework/blob/9.x/src/Illuminate/Foundation/Console/stubs/cast.inbound.stub) :


```php

namespace {{ namespace }};

use Illuminate\Database\Eloquent\Model;
use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;

class {{ class }} implements CastsInboundAttributes
{
    /**
     * Prepare the given value for storage.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $model
     * @param  string  $key
     * @param  mixed  $value
     * @param  array  $attributes
     * @return mixed
     */
    public function set($model, string $key, $value, array $attributes)
    {
        return $value;
    }
}
```



[devient désormais, en Laravel 10](https://github.com/laravel/framework/blob/be2ddb5c31b0b9ebc2738d9f37a9d4c960aa3199/src/Illuminate/Foundation/Console/stubs/cast.inbound.stub) :


```php

namespace {{ namespace }};

use Illuminate\Database\Eloquent\Model;
use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;

class {{ class }} implements CastsInboundAttributes
{
    /**
     * Prepare the given value for storage.
     *
     * @param  array<string, mixed>  $attributes
     */
    public function set(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        return $value;
    }
}
```



Deux choses à noter :


- La documentation est certes réduite (inutile de déclarer le type d'un paramètre en commentaire ET dans la signature de la méthode), mais il reste encore les informations concernant la structure des tableaux (en attendant qu'une future version de PHP permette de déclarer cela, comme en Java ?) ;
- L'exemple ci-dessus provient d'un fichier stub de Laravel : ce sont des fichiers "à trous" (d'où le fait que ni le _namespace_ ni le nom de la classe ne soient renseignés) utilisés lorsque le développeur veut créer une nouvelle classe (modèle, contrôleur, job, ...) au sein de son projet. Le but ici étant de ne pas limiter au framework uniquement cette nouveauté mais, au contraire, de propager cet usage du typage dans le code du développeur.

### Les règles de validation _Invokable_ deviennent le fonctionnement par défaut
Laravel fournit de base un ensemble de règles de validation (appelées _Rules_) pour vérifier que les données provenant des formulaires sont correctes. Il est néanmoins possible de créer les siennes.
Jusqu'à présent, une telle rule devait être écrite ainsi :



```php
namespace App\Rules;
 
use Illuminate\Contracts\Validation\Rule;
 
class Uppercase implements Rule
{
    /**
     * Determine if the validation rule passes.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */
    public function passes($attribute, $value)
    {
        return strtoupper($value) === $value;
    }
 
    /**
     * Get the validation error message.
     *
     * @return string
     */
    public function message()
    {
        return 'The :attribute must be uppercase.';
    }
}
```




À partir de Laravel 9, on peut la simplifier en utilisant la méthode magique `__invoke` de PHP, et donc écrire la même _rule_ ainsi :



```php
namespace App\Rules;
 
use Illuminate\Contracts\Validation\InvokableRule;
 
class Uppercase implements InvokableRule
{
    /**
     * Run the validation rule.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @param  \Closure  $fail
     * @return void
     */
    public function __invoke($attribute, $value, $fail)
    {
        if (strtoupper($value) !== $value) {
            $fail('The :attribute must be uppercase.');
        }
    }
}
```





Néanmoins, pour que ce changement se fasse en douceur, il avait été décidé qu'il ne serait possible qu'en ajoutant le paramètre `--invokable` à la ligne de commande.
Ainsi, pour obtenir la classe telle que dans l'exemple ci-dessus, il fallait faire : `php artisan make:rule Uppercase --invokable`.



Depuis Laravel 10, ce comportement est désormais celui par défaut, et le paramètre optionnel a donc disparu de la ligne de commande indiqué précédemment.



### Process Layer
Déjà existant dans Symfony depuis longtemps, ce service-objet permet de lancer des processus en ligne de commande, et d’interagir avec (code d'erreur, valeur renvoyée, ...). Comme souvent dans Laravel, l'usage d'une _fluent interface_ y est très présent, permettant l'enchaînement d'appels de méthodes pour construire le processus voulu, avant de l'exécuter.


```php
use Illuminate\Support\Facades\Process;
 
$result = Process::run('ls -la');
 
$result->successful();
$result->failed();
$result->exitCode();
$result->output();
$result->errorOutput();
$result->throw();
$result->throwIf($condition);
```




À noter que, comme [le client HTTP](https://laravel.com/docs/10.x/http-client#main-content) déjà présent dans Laravel, qui (comme son nom l'indique) permet d'interagir avec des appels HTTP(S), ce service est prévu pour pouvoir être "mocké", afin de faciliter l'écriture des tests.



### Détecter les tests les plus lents
Une nouvelle option `--profile` est apparue, pour faire ressortir les 10 tests les plus lents à l'exécution. Cela permet de détecter ceux qui auraient peut-être besoin d'être optimisés ou, parce que ça n'est pas toujours possible de les rendre plus rapides, de voir lesquels devraient être regroupés dans un lot de tests lents (qui ne seraient pas exécutés tout le temps, par exemple).


Fin du partenariat avec le "Laravel Certification Program"
-----------
Depuis plusieurs années, Laravel avait un partenariat avec un organisme extérieur, le reconnaissant comme seul autorisé à délivrer officiellement une certification de Laravel. [Depuis ce début d'année](https://twitter.com/taylorotwell/status/1610661365110247425), ce partenariat n'existe plus, et il n'y en a pas d'autres officiels pour autant (ce qui n'interdit pas quiconque de créer une certification Laravel).


Laravel Pennant
-----------
Il s'agit non pas d'une nouveauté de Laravel 10, mais d'un _first-class package_ dont la sortie coïncide quasiment, et qui était très demandé et attendu par la communauté.



[Laravel Pennant](https://laravel.com/docs/10.x/pennant) est un package officiel dont le but est de permettre de faire du _feature flag_. Il s'agit d'une technique d'ingénierie logicielle permettant d'activer/désactiver une fonctionnalité à tout ou partie des utilisateurs d'une application. Ainsi, on peut tester en production l'accueil qu'aura une nouvelle interface graphique, ne proposer dans un premier temps une fonctionnalité qu'à des utilisateurs triés sur le volet.

Laravel 11 ?
-----------



Bien que la prochaine version majeure de Laravel ne soit pas attendue avec début 2024, on sait déjà au moins une chose la concernant : [elle abandonnera le support de PHP 8.1](https://github.com/laravel/framework/pull/45526) ! Seules les versions 8.2 et 8.3 (dont la sortie est prévue en novembre 2023) de PHP seront donc supportées.