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

> 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](https://github.com/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.

```mermaid theme={null}
flowchart LR
    A["File PHP"] --> B["Esecuzione di pint"]
    B --> C{Errori<br>di stile?}
    C -- Sì --> D["Correzione automatica"]
    C -- No --> E["Nessuna modifica"]
    D --> F["File formattato"]
    E --> F
```

## Installazione

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

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

## Esecuzione

### Uso di base

Corregge automaticamente tutti i file `.php` del progetto.

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

Puoi anche limitarlo a file o directory specifiche.

```shell theme={null}
./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                                                                           |

```shell theme={null}
# 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.

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

Puoi anche indicare esplicitamente il path del file di configurazione.

```shell theme={null}
./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    |

```shell theme={null}
# 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](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
        }
    }
}
```

### Esclusione di file/cartelle

Puoi escludere cartelle specifiche dal controllo.

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

Per escludere in base al nome file usa `notName`.

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

Per escludere in base al path del file usa `notPath`.

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

## Configurazione consigliata

Esempio di `pint.json` efficace nella pratica di sviluppo.

```json theme={null}
{
    "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                                          |

<Tip>
  `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.
</Tip>

<Info>
  **`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.
</Info>

## Script in composer.json

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

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

Dopo la registrazione:

```shell theme={null}
# Corregge il codice
composer pint

# Solo verifica (non modifica)
composer pint:test
```

<Info>
  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.
</Info>

## Esecuzione automatica con GitHub Actions

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

<Steps>
  <Step title="Configura i permessi del workflow">
    Nelle **Settings > Actions > General > Workflow permissions** della repository GitHub attiva "Read and write permissions".
  </Step>

  <Step title="Crea il file di workflow">
    Crea `.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>

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

<Tip>
  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.
</Tip>


## Related topics

- [Laravel Package Skeleton — template starter per pacchetti ufficiali](/it/blog/package-skeleton-introduction.md)
- [Laravel e lo sviluppo con AI](/it/ai.md)
- [Laravel Boost](/it/boost.md)
- [Laravel Telescope](/it/telescope.md)
- [Laravel Bluesky](/it/packages/laravel-bluesky/index.md)