> ## 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

> Een tool voor automatische correctie van codestijl, gebouwd op PHP CS Fixer. Uitleg over hoe je een consistente codeerstijl in je team behoudt.

## Wat is Laravel Pint

[Laravel Pint](https://github.com/laravel/pint) is een tool voor automatische correctie van codestijl, gebouwd op PHP CS Fixer. Hij is ontworpen om zonder configuratie direct bruikbaar te zijn en formatteert je code automatisch volgens de codeerstijl van Laravel.

Door de bij teamontwikkeling veelvoorkomende "reviewcommentaren over codestijl" te automatiseren, kun je je concentreren op de inhoudelijke codereview.

```mermaid theme={null}
flowchart LR
    A["PHP-bestand"] --> B["pint uitvoeren"]
    B --> C{Stijl-<br>fouten?}
    C -- ja --> D["Automatisch corrigeren"]
    C -- nee --> E["Geen wijzigingen"]
    D --> F["Geformatteerd bestand"]
    E --> F
```

## Installatie

In nieuw aangemaakte Laravel-applicaties is Pint automatisch geïnstalleerd. Voor projecten met een oudere versie installeer je hem met Composer.

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

## Uitvoeren

### Basisgebruik

Corrigeert automatisch alle `.php`-bestanden in het project.

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

Je kunt ook alleen specifieke bestanden of directory's als doel opgeven.

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

Standaard formatteert Pint geen Blade-templates. Geef je `--blade` op, dan worden alleen voor die run ook `.blade.php`-bestanden geformatteerd, zonder `pint.json` te wijzigen.

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

Deze optie schakelt de regel `Pint/laravel_blade` in. Omdat Pint Prettier gebruikt in combinatie met `prettier-plugin-blade` en `prettier-plugin-tailwindcss`, is Node.js vereist. Als bij de eerste run Prettier-dependencies ontbreken, word je gevraagd deze te installeren.

### Overzicht van opties

| Optie               | Beschrijving                                                                                                     |
| ------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `--blade`           | Formatteert alleen voor deze run ook Blade-templates                                                             |
| `--test`            | Detecteert alleen stijlfouten zonder bestanden te wijzigen. Geeft bij fouten een exitcode ongelijk aan nul terug |
| `--dirty`           | Richt zich alleen op bestanden met niet-gecommitte wijzigingen in Git                                            |
| `--diff=[branch]`   | Richt zich alleen op bestanden die verschillen van de opgegeven branch                                           |
| `--repair`          | Corrigeert stijlfouten en geeft bij correcties een exitcode ongelijk aan nul terug                               |
| `--parallel`        | Verbetert de prestaties met de parallelle modus (experimenteel)                                                  |
| `--max-processes=4` | Geeft in combinatie met `--parallel` het maximale aantal processen op                                            |
| `-v`                | Toont details van de wijzigingen                                                                                 |
| `--config`          | Geeft het pad op naar de te gebruiken `pint.json`                                                                |
| `--preset`          | Geeft de te gebruiken preset op                                                                                  |

```shell theme={null}
# Alleen controleren zonder bestanden te wijzigen
./vendor/bin/pint --test

# Alleen niet-gecommitte bestanden
./vendor/bin/pint --dirty

# Parallel uitvoeren
./vendor/bin/pint --parallel
```

## Configuratie

Je kunt het gedrag aanpassen door in de projectroot een `pint.json` aan te maken.

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

Je kunt het pad naar het configuratiebestand ook expliciet opgeven.

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

### Presets

Een preset is een set regels. De standaard is de `laravel`-preset, met regels die optimaal zijn voor Laravel-projecten.

| Preset    | Beschrijving                                             |
| --------- | -------------------------------------------------------- |
| `laravel` | De aanbevolen codeerstijl van Laravel (standaard)        |
| `psr12`   | De PSR-12-codeerstandaard                                |
| `per`     | PER Coding Style                                         |
| `symfony` | De codeerstijl van Symfony                               |
| `empty`   | Geen regels. Te gebruiken door zelf regels te definiëren |

```shell theme={null}
# Een preset opgeven op de commandoregel
./vendor/bin/pint --preset psr12
```

### Regels aanpassen

In `pint.json` kun je regels afzonderlijk in- of uitschakelen. De beschikbare regels vind je in de [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
        }
    }
}
```

### Bestanden en mappen uitsluiten

Je kunt bepaalde mappen uitsluiten van de controle.

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

Gebruik `notName` om uit te sluiten op bestandsnaampatronen.

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

Gebruik `notPath` om uit te sluiten op een specifiek bestandspad.

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

## Aanbevolen configuratie

Hier een voorbeeld van een `pint.json`-configuratie die effectief is in de praktijk.

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

De redenen om elke regel toe te voegen zijn als volgt.

| Regel                  | Effect                                                                                                                                                             |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `no_unused_imports`    | Bij `false` blijven ongebruikte `use`-statements behouden. De standaard van Pint is `true` (verwijderen), dus in een gewoon Laravel-project is dit item niet nodig |
| `strict_comparison`    | Zet `==` om naar `===` en `!=` naar `!==` om bugs door onverwachte typeconversies te voorkomen                                                                     |
| `declare_strict_types` | Voegt automatisch `declare(strict_types=1);` toe bovenaan het bestand voor betere typeveiligheid                                                                   |

<Tip>
  Omdat `strict_comparison` en `declare_strict_types` typestrikte code afdwingen, kan de eerste correctieronde bij bestaande projecten omvangrijk zijn. Bij nieuwe projecten raden we aan ze vanaf het begin in te voeren.
</Tip>

<Info>
  **`no_unused_imports` is een instelling voor pakketontwikkeling.** De standaard van Pint is `true` (ongebruikte `use`-statements verwijderen), dus in een gewoon Laravel-project is dit item helemaal niet nodig. Bij pakketontwikkeling bestaat het patroon om functionaliteit aan of uit te zetten via imports van traits of interfaces; daarom is het handig om `false` toe te voegen en dit per pakket naar `true` te wijzigen waar dat past.
</Info>

## Scripts instellen in composer.json

Als je in `composer.json` een script voor `pint` registreert, kun je het uitvoeren met alleen `composer pint`.

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

Na registratie voer je het zo uit:

```shell theme={null}
# Code automatisch corrigeren
composer pint

# Alleen controleren (niet corrigeren)
composer pint:test
```

<Info>
  In een CI-omgeving kun je met `composer pint:test` stijlschendingen detecteren zonder bestanden te wijzigen. De optie `--test` geeft bij fouten een exitcode ongelijk aan nul terug en is daarom bruikbaar als pass-check in CI.
</Info>

## Automatisch uitvoeren met GitHub Actions

Met GitHub Actions kun je bij elke push de codestijl automatisch laten corrigeren en committen.

<Steps>
  <Step title="Stel de workflowrechten in">
    Schakel in je GitHub-repository onder **Settings > Actions > General > Workflow permissions** "Read and write permissions" in.
  </Step>

  <Step title="Maak het workflowbestand aan">
    Maak `.github/workflows/lint.yml` aan.

    ```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>

Deze workflow voert Pint uit bij elke push en commit automatisch de bestanden waarin stijlschendingen zijn gecorrigeerd.

<Tip>
  Omdat de automatische correcties vóór de review van een pull request plaatsvinden, nemen reviewcommentaren over codestijl af. Voer je dit in met je team, corrigeer dan eerst lokaal alle bestanden voordat je de workflow toevoegt — zo voorkom je overbodige commits.
</Tip>


## Related topics

- [Laravel Package Skeleton — officiële startertemplate voor packages](/nl/blog/package-skeleton-introduction.md)
- [Laravel en AI-ontwikkeling](/nl/ai.md)
- [GitHub Actions pinnen en beveiliging](/nl/advanced/github-actions-pinning.md)
- [Laravel Boost](/nl/boost.md)
- [cpx 2.0 — de Composer Package Executor volledig herschreven](/nl/blog/cpx-introduction.md)
