> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Laravel Pint

> Outil de correction automatique du style de code basé sur PHP CS Fixer. Maintenez une convention de code cohérente au sein de l'équipe.

## Qu'est-ce que Laravel Pint

[Laravel Pint](https://github.com/laravel/pint) est un outil de correction automatique du style de code basé sur PHP CS Fixer. Prêt à l'emploi sans configuration, il formate le code selon les conventions Laravel.

En automatisant les remarques de style, vous vous concentrez sur les vraies discussions de code review.

```mermaid theme={null}
flowchart LR
    A["Fichier PHP"] --> B["Exécution de pint"]
    B --> C{Erreurs<br>de style ?}
    C -- Oui --> D["Correction automatique"]
    C -- Non --> E["Aucun changement"]
    D --> F["Fichier formaté"]
    E --> F
```

## Installation

Pint est installé automatiquement dans les nouvelles applications Laravel. Sinon, ajoutez-le via Composer.

```shell theme={null}
composer require laravel/pint --dev
```

## Utilisation

### Base

Corrige tous les fichiers `.php` du projet.

```shell theme={null}
./vendor/bin/pint
```

Vous pouvez cibler un dossier ou un fichier.

```shell theme={null}
./vendor/bin/pint app/Models
./vendor/bin/pint app/Models/User.php
```

### Options

| Option              | Description                                                          |
| ------------------- | -------------------------------------------------------------------- |
| `--test`            | Vérifie sans modifier ; code de sortie non nul si erreur             |
| `--dirty`           | Ne cible que les fichiers modifiés non commit                        |
| `--diff=[branch]`   | Fichiers différents par rapport à la branche indiquée                |
| `--repair`          | Corrige et retourne un code non nul si des modifications ont eu lieu |
| `--parallel`        | Exécution parallèle (expérimental)                                   |
| `--max-processes=4` | Nombre max de processus (avec `--parallel`)                          |
| `-v`                | Détail des changements                                               |
| `--config`          | Chemin d'un `pint.json`                                              |
| `--preset`          | Preset à utiliser                                                    |

```shell theme={null}
# Sans modification
./vendor/bin/pint --test

# Uniquement les fichiers non commit
./vendor/bin/pint --dirty

# Parallèle
./vendor/bin/pint --parallel
```

## Configuration

Créez un `pint.json` à la racine.

```json theme={null}
{
    "preset": "laravel"
}
```

Ou précisez le chemin :

```shell theme={null}
./vendor/bin/pint --config vendor/my-company/coding-style/pint.json
```

### Presets

Un preset est un ensemble de règles. `laravel` est le défaut, optimal pour les projets Laravel.

| Preset    | Description                       |
| --------- | --------------------------------- |
| `laravel` | Style Laravel recommandé (défaut) |
| `psr12`   | Standard PSR-12                   |
| `per`     | PER Coding Style                  |
| `symfony` | Style Symfony                     |
| `empty`   | Aucune règle, à composer          |

```shell theme={null}
./vendor/bin/pint --preset psr12
```

### Personnalisation des règles

Activez / désactivez individuellement dans `pint.json`. Consultez le [PHP CS Fixer Configurator](https://mlocati.github.io/php-cs-fixer-configurator).

```json theme={null}
{
    "preset": "laravel",
    "rules": {
        "simplified_null_return": true,
        "array_indentation": false,
        "new_with_parentheses": {
            "anonymous_class": true,
            "named_class": true
        }
    }
}
```

### Exclusions

Exclure des dossiers :

```json theme={null}
{
    "exclude": [
        "my-specific/folder"
    ]
}
```

Exclure via un pattern de nom :

```json theme={null}
{
    "notName": [
        "*-my-file.php"
    ]
}
```

Exclure un chemin précis :

```json theme={null}
{
    "notPath": [
        "path/to/excluded-file.php"
    ]
}
```

## Configuration recommandée

Exemple efficace de `pint.json`.

```json theme={null}
{
    "preset": "laravel",
    "rules": {
        "no_unused_imports": false,
        "strict_comparison": true,
        "declare_strict_types": true
    }
}
```

Raisons :

| Règle                  | Effet                                                                                                                                              |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `no_unused_imports`    | `false` conserve les `use` non utilisés. Par défaut Pint les supprime (`true`) : cette option n'est pas nécessaire dans un projet Laravel standard |
| `strict_comparison`    | Remplace `==` par `===` et `!=` par `!==` pour éviter les bugs de conversion de type                                                               |
| `declare_strict_types` | Ajoute automatiquement `declare(strict_types=1);` en tête de fichier                                                                               |

<Tip>
  `strict_comparison` et `declare_strict_types` imposent un typage strict. Sur un projet existant, la première exécution peut modifier beaucoup de fichiers. À adopter dès le départ sur un nouveau projet.
</Tip>

<Info>
  **`no_unused_imports` est surtout utile en développement de package.** Par défaut, Pint supprime les `use` inutilisés (`true`) ; il n'est donc pas nécessaire dans un projet Laravel classique. Dans les packages, les imports de traits ou d'interfaces jouent un rôle d'activation, donc `false` puis `true` selon les cas est pratique.
</Info>

## Scripts `composer.json`

Ajoutez des scripts pour lancer `pint` plus facilement.

```json theme={null}
{
    "scripts": {
        "pint": "./vendor/bin/pint",
        "pint:test": "./vendor/bin/pint --test"
    }
}
```

```shell theme={null}
# Corrige
composer pint

# Vérifie sans modifier
composer pint:test
```

<Info>
  En CI, utilisez `composer pint:test` pour détecter les violations sans modifier les fichiers. `--test` retourne un code non nul en cas d'erreurs.
</Info>

## Automatisation via GitHub Actions

Exécutez Pint et committez automatiquement les corrections à chaque push.

<Steps>
  <Step title="Configurer les permissions du workflow">
    Dans **Settings > Actions > General > Workflow permissions**, activez « Read and write permissions ».
  </Step>

  <Step title="Créer le workflow">
    `.github/workflows/lint.yml` :

    ```yaml theme={null}
    name: Fix Code Style

    on: [push]

    jobs:
      lint:
        runs-on: ubuntu-latest
        strategy:
          fail-fast: true
          matrix:
            php: [8.4]

        steps:
          - name: Checkout code
            uses: actions/checkout@v5

          - name: Setup PHP
            uses: shivammathur/setup-php@v2
            with:
              php-version: ${{ matrix.php }}
              tools: pint

          - name: Run Pint
            run: pint

          - name: Commit linted files
            uses: stefanzweifel/git-auto-commit-action@v6
    ```
  </Step>
</Steps>

Ce workflow lance Pint à chaque push et commit les corrections automatiquement.

<Tip>
  Les corrections arrivent avant la revue, ce qui réduit les remarques de style. Corrigez d'abord tout localement puis ajoutez le workflow pour éviter les commits en trop.
</Tip>


## Related topics

- [Laravel Package Skeleton — le template de démarrage pour packages officiels](/fr/blog/package-skeleton-introduction.md)
- [Laravel et le développement IA](/fr/ai.md)
- [Laravel Boost](/fr/boost.md)
- [Laravel Telescope](/fr/telescope.md)
- [Laravel Octane](/fr/octane.md)