Git Hooks: Automazione Personalizzata nel Flusso di Lavoro Git

Codegrind Team•Aug 28 2024

I Git Hooks sono script personalizzati che Git esegue automaticamente in risposta a determinati eventi all’interno del flusso di lavoro. Questi script consentono di automatizzare task specifici come il controllo del codice, la gestione delle dipendenze, o l’invio di notifiche, migliorando così la qualità del codice e la produttività del team. In questa guida, esploreremo come configurare e utilizzare i Git Hooks per personalizzare e automatizzare il flusso di lavoro in Git.

Cos’è un Git Hook?

Un Git Hook è uno script eseguito da Git in risposta a eventi specifici, come l’esecuzione di un commit, la fusione di branch, o l’aggiornamento di un repository remoto. I Git Hooks si dividono in due categorie principali:

Client-side hooks: Eseguiti sul client locale, controllano le azioni come commit, merge, rebase, e checkout.
Server-side hooks: Eseguiti su un server Git, controllano eventi come push e ricezione di aggiornamenti.

Tipi Comuni di Git Hook

Pre-commit

Il pre-commit hook viene eseguito prima che un commit sia finalizzato. Può essere utilizzato per controllare la qualità del codice, eseguire linter, o garantire che il codice rispetti determinati standard.

Post-commit

Il post-commit hook viene eseguito dopo che un commit è stato creato con successo. Può essere usato per inviare notifiche, aggiornare documenti, o eseguire azioni che non devono influenzare il commit stesso.

Pre-push

Il pre-push hook viene eseguito prima di un push verso un repository remoto. Può essere utilizzato per eseguire test, controllare che il branch sia aggiornato, o prevenire il push di codice non conforme.

Post-merge

Il post-merge hook viene eseguito dopo una fusione di branch. Questo hook è utile per eseguire build o aggiornare le dipendenze dopo aver unito il codice.

Configurazione dei Git Hooks

I Git Hooks sono configurati attraverso script posizionati nella directory .git/hooks all’interno del tuo repository Git. Ogni tipo di hook ha un file corrispondente (ad esempio, pre-commit, post-commit), e puoi personalizzare questi script per adattarli alle tue esigenze.

1. Creare un Hook di Base

Supponiamo di voler creare un hook pre-commit che esegua un linter per verificare la qualità del codice prima di ogni commit.

Naviga nella directory hooks:
```
cd .git/hooks
```
Crea il file pre-commit:
```
touch pre-commit
```
Rendi eseguibile lo script:
```
chmod +x pre-commit
```

Modifica lo script pre-commit:

Apri il file pre-commit con un editor di testo e aggiungi il seguente contenuto:

#!/bin/sh
# Esegui il linter prima di ogni commit
npm run lint
if [ $? -ne 0 ]; then
  echo "Errore: Il linter ha rilevato problemi. Correggi gli errori prima di eseguire il commit."
  exit 1
fi

Questo script esegue il comando npm run lint e annulla il commit se il linter rileva problemi.

2. Esempio di Hook Pre-push

Un hook pre-push potrebbe eseguire i test unitari per assicurarsi che nessun codice errato venga inviato al repository remoto:

Crea il file pre-push:
```
touch pre-push
chmod +x pre-push
```

Modifica lo script pre-push:

#!/bin/sh
# Esegui i test prima di eseguire il push
npm test
if [ $? -ne 0 ]; then
  echo "Errore: Test falliti. Correggi gli errori prima di eseguire il push."
  exit 1
fi

Questo script esegue npm test e blocca il push se i test falliscono.

3. Esempio di Hook Post-merge

Un hook post-merge può essere utilizzato per eseguire un npm install ogni volta che si uniscono branch che potrebbero aver aggiornato le dipendenze:

Crea il file post-merge:
```
touch post-merge
chmod +x post-merge
```
Modifica lo script post-merge:
```
#!/bin/sh
# Esegui npm install dopo una fusione
if [ -f package.json ]; then
  npm install
fi
```
Questo script verifica la presenza di package.json e installa automaticamente le dipendenze dopo una fusione.

Best Practices per i Git Hooks

Mantieni gli Script Semplici: Evita script complessi nei Git Hooks per ridurre il rischio di errori. Mantieni gli script concisi e mirati a task specifici.
Usa Hooks per Garantire la Qualità del Codice: Implementa hook come pre-commit e pre-push per assicurarti che il codice sia conforme agli standard prima di essere committato o pushato.
Documenta i Git Hooks: Documenta l’uso dei Git Hooks nel repository per assicurarti che tutti i membri del team capiscano cosa fanno e come influiscono sul flusso di lavoro.
Esegui Test Locali con Hooks: Prima di implementare un hook nel repository, testalo localmente per assicurarti che funzioni come previsto.
Evita Azioni Lente nei Pre-commit: I pre-commit hooks dovrebbero eseguire azioni rapide per non rallentare il flusso di lavoro. Se una verifica richiede tempo, considera di spostarla in un hook post-commit o pre-push.

Esempi di Utilizzo Avanzato dei Git Hooks

1. Forzare lo Stile del Codice

Puoi configurare un hook pre-commit che forza l’uso di uno specifico stile di codice eseguendo un formatter come Prettier:

#!/bin/sh
# Formatta il codice prima di eseguire il commit
npx prettier --write .

2. Inviare Notifiche al Team

Un post-commit hook può essere utilizzato per inviare notifiche al team via Slack o email ogni volta che viene eseguito un commit:

#!/bin/sh
# Invia una notifica su Slack dopo ogni commit
curl -X POST -H 'Content-type: application/json' --data '{"text":"Nuovo commit eseguito nel branch!"}' https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX

3. Sincronizzazione Automatica dei Branch

Un post-checkout hook può essere utilizzato per sincronizzare automaticamente un branch con il branch remoto ogni volta che viene cambiato:

#!/bin/sh
# Sincronizza il branch con il branch remoto
git pull origin $(git rev-parse --abbrev-ref HEAD)

Risolvere Problemi Comuni

Hook Non Funziona

Se un hook non funziona come previsto, verifica che lo script sia eseguibile (chmod +x nomefile) e che il file sia posizionato correttamente nella directory .git/hooks.

Problemi di Compatibilità

Assicurati che gli script siano compatibili con l’ambiente in cui verranno eseguiti. Ad esempio, uno script Bash potrebbe non funzionare su Windows senza un ambiente compatibile come Git Bash.

Impatto sulle Performance

Se gli hook stanno rallentando il flusso di lavoro, considera di spostare le operazioni più lunghe in un hook diverso (ad esempio, da pre-commit a post-commit) o di ottimizzare gli script per migliorare le performance.

Conclusione

I Git Hooks sono uno strumento potente per automatizzare task e migliorare il flusso di lavoro in Git. Configurando correttamente i hook, puoi garantire la qualità del codice, automatizzare operazioni ripetitive e migliorare la collaborazione del team. Sfruttando al meglio le funzionalità dei Git Hooks, potrai ottimizzare l’intero processo di sviluppo e deployment del software.