Automatisez votre flux de travail : un guide pratique des hooks client Git

Les hooks Git sont des outils puissants, bien que souvent sous-utilisés, dans l'écosystème Git. Ils permettent aux développeurs de déclencher automatiquement des scripts personnalisés à des points spécifiques du flux de travail de développement - avant ou après des événements tels que le commit, le push ou le merge. Pour les développeurs individuels travaillant sur un dépôt local, les hooks client sont essentiels pour appliquer la qualité du code, exécuter des tests locaux et standardiser les vérifications avant la soumission sans dépendre de l'application côté serveur.

Ce guide explorera la mécanique des hooks client Git, en se concentrant sur les types les plus courants et les plus utiles : pre-commit et post-merge. En maîtrisant ces hooks, vous pouvez automatiser les tâches répétitives, détecter les erreurs précocement et améliorer considérablement la cohérence et la fiabilité de votre processus de développement quotidien.

Comprendre les Hooks Git

Les hooks Git sont des scripts exécutables que Git exécute automatiquement avant ou après certaines opérations principales. Ils résident dans le répertoire .git/hooks de chaque dépôt Git. Git est livré avec des hooks d'exemple (se terminant généralement par .sample), mais ils ne deviennent actifs que lorsque vous les renommez pour supprimer l'extension .sample.

Hooks Client vs. Hooks Serveur

Il est crucial de distinguer les deux types principaux :

• Hooks Client : S'exécutent sur la machine du développeur local (par exemple, pre-commit, commit-msg). Ils sont excellents pour la validation locale et l'amélioration de l'expérience utilisateur.
• Hooks Serveur : S'exécutent sur le serveur central lorsqu'un push est reçu (par exemple, pre-receive, post-receive). Ils sont généralement utilisés pour les politiques d'application à l'échelle du projet.

Note Importante : Puisque les hooks client sont locaux, ils ne sont pas automatiquement clonés ou partagés lorsque vous clonez un dépôt. Toute configuration doit être effectuée manuellement par chaque développeur, ou gérée via des scripts d'initialisation.

Localisation et Activation des Hooks Client

Tous les hooks client résident dans le répertoire .git/hooks de votre dépôt.

Lorsque vous initialisez un nouveau dépôt, Git fournit des modèles :

git init
# Ceci crée un répertoire .git/hooks peuplé de fichiers d'exemple comme pre-commit.sample

Pour activer un hook, renommez simplement le fichier d'exemple. Par exemple, pour activer le hook pre-commit :

cd .git/hooks
cp pre-commit.sample pre-commit
chmod +x pre-commit

Les scripts placés ici doivent être exécutables (d'où le chmod +x). Ils s'exécutent généralement en tant que scripts shell, mais peuvent être écrits dans n'importe quel langage, à condition que la ligne shebang (#!/bin/bash, #!/usr/bin/env python, etc.) soit présente et que l'interpréteur soit disponible.

Exemple Pratique 1 : Le Hook pre-commit

Le hook pre-commit s'exécute juste avant que Git ne demande un message de commit. C'est l'endroit idéal pour exécuter des vérifications sur le code qui est commit.

Cas d'utilisation courants pour pre-commit :

1. Linting/Vérification de style : S'assurer que le code respecte les guides de style établis (par exemple, ESLint, Black).
2. Exécution de tests unitaires : Exécuter des tests rapides et critiques.
3. Vérification de syntaxe : Vérifier la correction syntaxique de base.
4. Prévention des commits accidentels : S'assurer qu'aucune clé secrète ou instruction de débogage ne reste.

Création d'un Hook pre-commit simple (Exemple Shell)

Ce script d'exemple vérifie si un fichier indexé pour le commit contient le mot TODO: et échoue le commit s'il est trouvé, forçant le développeur à traiter ces espaces réservés.

Créez le fichier .git/hooks/pre-commit et ajoutez le contenu suivant :

#!/bin/bash

# 1. Vérifie les fichiers indexés pour 'TODO:'
STAGED_FILES=$(git diff --cached --name-only)

if grep -q "TODO:" <<< "$STAGED_FILES"; then
    echo "\n[HOOK ÉCHOUE] Marqueurs 'TODO:' trouvés dans les fichiers indexés. Veuillez les résoudre avant de committer."
    # Affiche les fichiers spécifiques contenant les marqueurs (optionnel)
    git diff --cached | grep "TODO:"
    exit 1 # Sortie non nulle pour annuler le commit
fi

# 2. Exécute une vérification de syntaxe de base sur les fichiers Python (nécessite 'python -m py_compile')
for FILE in $(git diff --cached --name-only --diff-filter=ACM | grep '\.py$'); do
    echo "Vérification de la syntaxe pour $FILE..."
    python -m py_compile "$FILE" > /dev/null 2>&1
    if [ $? -ne 0 ]; then
        echo "[HOOK ÉCHOUE] Erreur de syntaxe trouvée dans $FILE."
        exit 1
    fi
done

# Si toutes les vérifications passent
echo "Les vérifications pre-commit ont réussi."
exit 0 # Sortie nulle pour permettre le commit

Si le script se termine avec un statut non nul (comme exit 1), Git annule immédiatement le processus de commit et affiche le message d'erreur.

Meilleure pratique : Pour des tâches complexes de linting et de formatage, envisagez d'utiliser des outils de gestion de hooks externes tels que Husky (pour les écosystèmes JavaScript) ou Pre-commit (un outil indépendant de la plateforme) qui gèrent automatiquement l'installation, le partage et la gestion des dépendances des hooks.

Exemple Pratique 2 : Le Hook post-merge

Le hook post-merge s'exécute immédiatement après qu'une opération git merge réussie soit terminée. Ce hook est utile pour effectuer un nettoyage ou mettre à jour les dépendances locales en fonction du code fraîchement mergé.

Cas d'utilisation courants pour post-merge :

1. Mise à jour des sous-modules : Rafraîchissement automatique des dépôts dépendants.
2. Reconstruction des dépendances : Exécution de npm install ou équivalent si les fichiers de dépendances (package.json, requirements.txt) ont été modifiés.
3. Notification des utilisateurs : Affichage des informations pertinentes de la branche.

Création d'un Hook post-merge simple (Rafraîchissement des dépendances)

Si votre projet utilise Node.js, vous voudrez peut-être vous assurer que node_modules est à jour après avoir mergé une branche qui a modifié package.json ou package-lock.json.

Créez le fichier .git/hooks/post-merge :

#!/bin/bash

echo "Hook post-merge déclenché."

# Vérifie si package.json ou package-lock.json a été modifié dans le merge
if git diff --name-only HEAD@{1} HEAD | grep -Eq "(package\.json|package-lock\.json)"; then
    echo "Fichiers de dépendance modifiés. Exécution de npm install..."
    npm install
    if [ $? -eq 0 ]; then
        echo "Dépendances mises à jour avec succès."
    else
        echo "ATTENTION : npm install a échoué après le merge. Veuillez exécuter 'npm install' manuellement."
    fi
else
    echo "Fichiers de dépendance inchangés. Skipping npm install."
fi

exit 0

Ce hook exploite les capacités du journal de référence de Git (HEAD@{1} fait référence à l'état avant le merge) pour comparer les fichiers, rendant l'action conditionnelle et évitant des exécutions inutiles.

Autres Hooks Client Utiles

Bien que pre-commit et post-merge soient très utilisés, plusieurs autres hooks client peuvent rationaliser votre flux de travail :

• commit-msg : S'exécute après que l'utilisateur ait entré le message de commit mais avant que le commit ne soit finalisé. Utile pour faire respecter les standards de message de commit (par exemple, le format Conventional Commits).
• pre-rebase : S'exécute avant le début d'un rebase. Peut vérifier si certaines branches doivent être protégées contre le rebase.
• post-checkout : S'exécute après qu'un git checkout ait réussi. Utile pour changer les variables d'environnement ou les configurations d'outils en fonction de la branche vérifiée.

Nom du Hook	Point de Déclenchement	Cas d'utilisation Principal
pre-commit	Avant la création du commit	Linting de code, tests locaux, formatage
commit-msg	Après la saisie du message	Application du format du message (par exemple, tickets JIRA)
post-merge	Après un merge réussi	Mise à jour des sous-modules, rafraîchissement des dépendances
post-checkout	Après un checkout réussi	Changement des configurations d'environnement

Résumé et Prochaines Étapes

Les hooks client Git offrent un moyen sans surcharge d'automatiser les tâches répétitives et d'appliquer les normes de qualité locales directement dans votre environnement de développement. Ils servent de première ligne de défense cruciale contre les commits bâclés et les problèmes d'intégration.

Pour les utiliser efficacement :

1. Identifiez les tâches répétitives : Déterminez les vérifications que vous effectuez manuellement avant de committer ou de merger.
2. Localisez .git/hooks : Naviguez vers ce répertoire dans votre projet.
3. Activez et Scriptez : Copiez le fichier .sample, renommez-le, assurez-vous qu'il est exécutable (chmod +x), et écrivez votre logique d'automatisation.
4. Envisagez des outils de gestion : Pour les équipes, explorez des outils comme pre-commit pour synchroniser les installations de hooks entre les développeurs.