Laravel Pint

Formattatore automatico dello stile del codice basato su PHP CS Fixer. Come mantenere in team uno stile di codifica coerente.

​

Cos’è Laravel Pint

Laravel Pint è uno strumento di formattazione automatica del codice costruito su PHP CS Fixer. È progettato per essere usato senza configurazione e formatta il codice secondo lo stile di codifica di Laravel.

Automatizzando i “commenti di code review sullo stile” comuni nello sviluppo in team, puoi concentrarti sulle revisioni davvero importanti.

​

Installazione

Nelle nuove applicazioni Laravel Pint è già installato. Nei progetti più vecchi installalo con Composer.

composer require laravel/pint --dev

​

Esecuzione

​

Uso di base

Corregge automaticamente tutti i file .php del progetto.

./vendor/bin/pint

Puoi anche limitarlo a file o directory specifiche.

./vendor/bin/pint app/Models
./vendor/bin/pint app/Models/User.php

​

Elenco delle opzioni

Opzione	Descrizione
--test	Rileva le violazioni senza modificare i file. Se ne trova, restituisce un exit code diverso da zero
--dirty	Considera solo i file con modifiche non ancora committate su Git
--diff=[branch]	Considera solo i file diversi rispetto al branch indicato
--repair	Corregge le violazioni e restituisce comunque un exit code diverso da zero se ha corretto qualcosa
--parallel	Modalità di esecuzione parallela (sperimentale) per migliorare le prestazioni
--max-processes=4	Da combinare con --parallel per indicare il numero massimo di processi
-v	Mostra il dettaglio delle modifiche
--config	Indica il path del pint.json da usare
--preset	Indica il preset da usare

# Solo verifica, senza modificare i file
./vendor/bin/pint --test

# Solo file non committati
./vendor/bin/pint --dirty

# Esecuzione parallela
./vendor/bin/pint --parallel

​

Configurazione

Puoi personalizzare il comportamento creando pint.json nella root del progetto.

{
    "preset": "laravel"
}

Puoi anche indicare esplicitamente il path del file di configurazione.

./vendor/bin/pint --config vendor/my-company/coding-style/pint.json

​

Preset

Un preset è un insieme di regole. Il preset predefinito è laravel con le regole più adatte a progetti Laravel.

Preset	Descrizione
laravel	Stile di codifica consigliato per Laravel (predefinito)
psr12	Standard di codifica PSR-12
per	PER Coding Style
symfony	Stile di codifica di Symfony
empty	Nessuna regola. Da usare per definire regole da zero

# Indica il preset dalla riga di comando
./vendor/bin/pint --preset psr12

​

Personalizzazione delle regole

Puoi attivare/disattivare singole regole in pint.json. Le regole disponibili sono elencate in PHP CS Fixer Configurator.

{
    "preset": "laravel",
    "rules": {
        "simplified_null_return": true,
        "array_indentation": false,
        "new_with_parentheses": {
            "anonymous_class": true,
            "named_class": true
        }
    }
}

​

Esclusione di file/cartelle

Puoi escludere cartelle specifiche dal controllo.

{
    "exclude": [
        "my-specific/folder"
    ]
}

Per escludere in base al nome file usa notName.

{
    "notName": [
        "*-my-file.php"
    ]
}

Per escludere in base al path del file usa notPath.

{
    "notPath": [
        "path/to/excluded-file.php"
    ]
}

​

Configurazione consigliata

Esempio di pint.json efficace nella pratica di sviluppo.

{
    "preset": "laravel",
    "rules": {
        "no_unused_imports": false,
        "strict_comparison": true,
        "declare_strict_types": true
    }
}

Motivo delle regole:

Regola	Effetto
no_unused_imports	Con false non rimuove gli use non usati. Poiché il default di Pint è true (rimuove), nei progetti Laravel normali questa voce non è necessaria
strict_comparison	Converte == in === e != in !== per prevenire bug da coercizione di tipo
declare_strict_types	Aggiunge automaticamente declare(strict_types=1); all’inizio del file per aumentare la sicurezza dei tipi

strict_comparison e declare_strict_types impongono codice rigoroso sui tipi. Se le aggiungi a un progetto esistente il primo intervento può essere corposo. Nei nuovi progetti conviene introdurle fin da subito.

no_unused_imports è pensato per lo sviluppo di pacchetti. Il default di Pint è true (rimuovere gli use inutilizzati); nei normali progetti Laravel la voce è superflua. Nello sviluppo di pacchetti ci sono pattern con trait/interfacce importate per attivare/disattivare funzionalità, quindi metterlo a false e cambiarlo a true in base al pacchetto è comodo.

​

Script in composer.json

Registrando gli script in composer.json puoi eseguire composer pint direttamente.

{
    "scripts": {
        "pint": "./vendor/bin/pint",
        "pint:test": "./vendor/bin/pint --test"
    }
}

Dopo la registrazione:

# Corregge il codice
composer pint

# Solo verifica (non modifica)
composer pint:test

Nei CI usa composer pint:test per rilevare violazioni senza modificare i file. Con l’opzione --test esce con codice diverso da zero in caso di errore, utile per il gate del CI.

​

Esecuzione automatica con GitHub Actions

Puoi usare GitHub Actions per correggere e committare automaticamente lo stile a ogni push.

1. Configura i permessi del workflow

   Nelle Settings > Actions > General > Workflow permissions della repository GitHub attiva “Read and write permissions”.

2. Crea il file di workflow

   Crea .github/workflows/lint.yml.

   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
   

Questo workflow esegue Pint a ogni push e committa automaticamente i file corretti.

Poiché le correzioni avvengono prima della review, si riducono i commenti di review sullo stile. Quando lo introduci in team, esegui prima una passata locale su tutti i file per evitare commit di rumore.