Usa gli hook Git per controllare il tuo lavoro prima che lasci il tuo computer
Un hook Git è uno script che Git esegue da solo in un momento fisso, ad esempio subito prima di un commit o di un push. In Preferences › Hooks, GitTree mostra cosa viene eseguito e quando, ti consente di aggiungere hook da modelli già pronti, modificarli ed eseguirli di prova, attivarli e disattivarli e condividerli con il tuo team tramite il repository.
Funziona in GitTree Gratuito: tutte le funzionalità Git locali, senza bisogno di un account.
In questa pagina
Prima di iniziare
- Un repository è aperto: gli hook appartengono a un repository.
- Il repository è attendibile. In modalità limitata Git non esegue nessuno dei suoi hook; puoi ancora leggerli e modificarli (repository trust).
- Gli hook sono script di shell. I modelli utilizzano il semplice
sh, fornito da macOS, Windows (attraverso Git for Windows) e Linux.
Dove trovarlo
- La casella di commit: sotto il pulsante di commit, May run: … elenca gli hook eseguiti da un commit. Manage Hooks apre la pagina.
- Tools nella barra degli strumenti o nella sezione TOOLS del pannello di sinistra: Git hooks.
- Il menu della scheda repository o la tavolozza dei comandi: Manage Git Hooks… o
Alt+Shift+H. - Preferences (
Mod+,) › Hooks. Anche la ricerca nelle Preferenze di "hook", "pre-commit" o "husky" lo trova.
| Azione | macOS | Windows e Linux |
|---|---|---|
| Gestisci gli hook Git | ⌥⇧H | Alt+Shift+H |
| Apri Preferenze | ⌘, | Ctrl+, |
Passi
Apri la pagina Hooks
Utilizza Manage Hooks sotto il pulsante di commit o
Alt+Shift+H. Con diversi repository aperti, scegline uno in Repository. La pagina inizia con cosa sono gli hook, una guida How it works in tre passaggi e un collegamento a questo articolo.Leggi cosa viene eseguito quando
What runs when mostra il flusso di commit (pre-commit, prepare-commit-msg, commit-msg, post-commit) e il flusso di push (pre-push). Ogni passaggio dice Runs, Off, Not executable o No hook e se Can stop the action o solo report.
La pagina nomina gli hook che Git può eseguire durante il commit e il push e offre Share Through .githooks.GitTree interfaccia con un repository dimostrativo. Aggiungi un gancio
Premi Add Hook…. Sotto When it runs, scegli il gancio; sotto Start from, scegli un modello, Git’s sample o Empty script. L'anteprima Script mostra esattamente cosa verrà scritto. Create Hook scrive il file, pronto per l'esecuzione, e lo apre nell'editor.
Modifica la sceneggiatura
Edit apre lo script con i numeri di riga. Modificalo e premi Save (o
Mod+S). Se il file è cambiato sul disco da quando lo hai aperto, GitTree rifiuta di sovrascriverlo e conserva il testo, così puoi riaprirlo e confrontarlo.Provalo
Test Run ora esegue l'hook, come farebbe Git, senza effettuare un commit o un push. Per commit-msg e prepare-commit-msg, digita un messaggio da controllare. L'output viene visualizzato e il risultato dice cosa farebbe Git: Passed with exit code 0: Git would continue. o Failed with exit code 1: Git would stop here. Stop termina una lunga esecuzione.
Disattiva un hook o condividili
L'interruttore accanto a un hook lo spegne rinominandolo in
<name>.disablede lo riaccende; nulla viene cancellato. Share Through .githooks inserisce gli hook nel repository per il tuo team (vedi sotto).
Risultato atteso
Dal successivo commit o push, Git esegue gli hook contrassegnati con Runs. La riga May run: … della casella di commit li nomina e l'output di un hook appare sotto Hook output quando stampa qualcosa o interrompe il commit.
Cosa sono gli hook e perché usarli
Git cerca file eseguibili con nomi fissi nella cartella degli hook (.git/hooks a meno che core.hooksPath non dica diversamente) e li esegue nei momenti corrispondenti. Un hook che viene eseguito prima di un'azione, come pre-commit o pre-push, può fermarla uscendo con uno stato diverso da zero. Un hook che lo segue, come post-commit o post-merge, può solo segnalare.
- Individua gli errori prima che lascino il tuo computer: test falliti, errori di lanugine, indicatori di conflitto rimanenti e file di grandi dimensioni.
- Mantieni coerenti i messaggi di commit, ad esempio Conventional Commits o una chiave di problema in ogni messaggio.
- Ottieni feedback in pochi secondi, invece di attendere che l'esecuzione di un CI fallisca.
- Dai a tutto il team gli stessi controlli mantenendo gli hook nel repository.
I ganci che utilizzerai di più
| Gancio | Quando Git lo esegue | Utilizzo tipico |
|---|---|---|
| pre-commit | Prima della creazione del commit | Lint e test rapidi su ciò che viene in stage; il blocco fa commit su main |
| prepare-commit-msg | Prima che il messaggio venga scritto | Inserisci la chiave di emissione dal nome del ramo nel messaggio |
| commit-msg | Dopo che il messaggio è stato scritto | Controlla il formato del messaggio, ad esempio Conventional Commits |
| post-commit | Dopo la creazione del commit | Notifica o registra; non è possibile annullare il commit |
| pre-push | Prima che qualsiasi cosa venga inviata al remoto | Esegui la suite di test completa; i rifiuti si inviano verso i rami protetti |
| post-merge | Dopo una fusione o un pull | Di' quando un file di blocco è cambiato, quindi le dipendenze vengono reinstallate |
| post-checkout | Dopo aver cambiato ramo | Pulisci l'output della build o aggiorna i file generati |
Gli hook del server come pre-receive e update vengono eseguiti solo su un server che riceve push. GitTree li elenca quando sono presenti ma non li esegue mai i test.
Modelli già pronti
| Modello | Gancio | Cosa fa |
|---|---|---|
| Proteggi i rami principali | pre-commit | Interrompe i commit effettuati direttamente su main o master |
| Cattura gli indicatori di conflitto e gli spazi bianchi | pre-commit | Interrompe un commit che aggiunge marcatori di conflitto rimanenti o spazi bianchi finali (git diff --cached --check) |
| Blocca file di grandi dimensioni | pre-commit | Interrompe un commit che aggiunge un file più grande di 5 MB |
| Aggiungi la chiave di emissione | prepare-commit-msg | Inizia ogni messaggio con la chiave di emissione nel nome del ramo, ad esempio ABC-123 |
| Conventional Commits | commit-msg | Richiede riepiloghi come feat(parser): accept empty lines |
| Eseguire i test prima del push | pre-push | Esegue npm test, cargo test, go test, pytest o make test e interrompe il push quando falliscono |
| Proteggi i rami remoti | pre-push | Interrompe le pressioni direttamente su Main o Master sul remoto |
| Promemoria di dipendenza | post-merge | Indica quando un file di blocco è stato modificato dopo un pull o un merge |
Ogni modello è uno script normale con le sue impostazioni in alto, come PROTECTED="main master" o TEST_COMMAND="". Modificali nell'editor per adattarli al tuo progetto.
Cosa fa una corsa di prova
GitTree esegue l'hook attraverso git hook run, quindi Git lo trova e lo avvia esattamente come farebbe durante l'azione reale, incluso core.hooksPath. L'hook riceve un input inventato:
- pre-commit, pre-merge-commit, post-commit e pre-auto-gc: nessun argomento.
- commit-msg e prepare-commit-msg: un file temporaneo con il messaggio che hai digitato, rimosso successivamente.
- pre-push: il nome e l'URL del tuo remoto push, senza rami nel suo input.
- post-merge:
0, come dopo una normale unione.
Condividi gli hook con la tua squadra
Gli hook in .git/hooks non vengono mai confermati, quindi ogni clone ha il proprio. Share Through .githooks li copia in una cartella .githooks nel repository e imposta core.hooksPath su di essa nella configurazione di questo repository. Conferma la cartella; ogni compagno di squadra lo esegue quindi una volta dopo la clonazione:
git config core.hooksPath .githooksUse This Clone’s Own Hooks rimuove nuovamente l'impostazione. La cartella .githooks e i tuoi hook in .git/hooks rimangono dove sono.
Salta gli hook per un commit
Apri Commit Options nella casella di commit e attiva Skip Hooks (--no-verify). Git quindi salta pre-commit e commit-msg per quel commit; prepare-commit-msg e post-commit continuano a funzionare e la riga sotto il pulsante di commit lo dice. Per fermare un hook più a lungo, disattivalo nella pagina Hooks.
Se qualcosa va storto
Un hook mostra Not executable e non viene mai eseguito.
Su macOS e Linux Git salta un file hook senza il permesso di esecuzione. Premi Make Executable; GitTree lo aggiunge solo dove il file è leggibile.
"L'hook è cambiato sul disco da quando è stato aperto; riaprilo per vedere il nuovo contenuto."
Un altro programma o un gestore hook ha riscritto il file. Chiudi l'editor, riaprilo e applica la modifica al nuovo contenuto.
"Questo hook è un collegamento. GitTree non scrive mai attraverso un collegamento; modifica il file a cui punta."
L'hook è un collegamento simbolico, spesso creato da un gestore di hook. Modifica il file a cui punta o la configurazione di quello strumento.
Lo script funziona su macOS ma fallisce su Linux con errori di "interprete errato" o \
.
Il file ha Windows terminazioni di riga (CRLF). L'editore li mette in guardia; salva lo script con terminazioni di riga LF.
Test Run è disattivato.
Il motivo è accanto al pulsante: fidati del repository, attiva l'hook, rendilo eseguibile o nota che questo hook riceve input solo durante la vera operazione Git.
Domande
Gli hook fanno parte del piano gratuito?
SÌ. La gestione, la modifica, l'esecuzione dei test e la condivisione degli hook avviene tramite Git locale e non necessita di un account di hosting.
GitTree elimina un hook quando lo spengo?
No. La disattivazione rinomina il file in <name>.disabled; l'accensione lo rinomina di nuovo. GitTree non elimina mai un hook.
Un hook che creo verrà confermato?
Non mentre è in .git/hooks. Utilizza Share Through .githooks per mantenere gli hook nel repository, dove vengono confermati come qualsiasi altro file.
Un hook può essere scritto in Node.js o Python?
SÌ. Git esegue il file con il programma nella prima riga, come #!/usr/bin/env node; l'editor mostra quel programma come Runs with node. Il programma deve essere installato su ogni computer che esegue l'hook.