Comprendre les hooks Git

Bienvenue dans l'univers des hooks Git ! Les hooks Git sont des scripts puissants et personnalisables que Git exécute automatiquement avant ou après des événements tels que la création d'un commit, un envoi ou la réception de commits envoyés.

Considérez-les comme des points de contrôle ou des actions automatisés dans votre flux de travail Git. Ils contribuent à faire respecter les normes du projet, à automatiser des tâches et à s'intégrer à d'autres systèmes.

Chaque dépôt Git contient un répertoire .git/hooks. Vous y trouverez des scripts d'exemple pour les hooks, qui se terminent généralement par .sample.

Pour activer un hook, il vous suffit de supprimer l'extension .sample et de rendre le fichier exécutable. Git l'exécutera alors au moment approprié.

• Emplacement : .git/hooks/
• Fichiers : scripts Shell (Bash, Python, Ruby, etc.)
• Activation : renommer et rendre exécutable

Les hooks Git sont répartis en deux grandes catégories selon l'endroit où ils s'exécutent :

• Hooks côté client : ils s'exécutent sur votre machine locale (par exemple, avant la création d'un commit ou un rebase). Ils servent à automatiser votre flux de travail personnel et à faire respecter les règles locales.
• Hooks côté serveur : ils s'exécutent sur le serveur Git distant (par exemple, lorsque vous envoyez du code vers un dépôt partagé). Ils font respecter les règles du projet pour tout le monde.

Le hook pre-commit est l'un des hooks côté client les plus courants. Il s'exécute *avant* que Git ne crée officiellement un commit.

Si le script pre-commit se termine avec un statut différent de zéro, Git annule le commit. C'est idéal pour des tâches comme :

• analyser le code (pour détecter les erreurs de style)
• exécuter des tests unitaires
• vérifier la présence de fichiers volumineux ou de données sensibles

Le hook commit-msg s'exécute *après* la saisie du message de commit, mais *avant* la finalisation du commit.

Ce hook est utile pour vérifier que les messages de commit respectent certaines conventions ou certains formats. Par exemple, il peut vérifier :

• que le message commence par un identifiant de ticket (par exemple, [JIRA-123])
• que la longueur du message respecte les limites
• que certains mots-clés sont présents ou absents

Le hook post-commit s'exécute *immédiatement après* la création réussie d'un commit.

Contrairement à pre-commit ou commit-msg, ce hook ne peut pas modifier le résultat du commit. Il est souvent utilisé pour les notifications ou les intégrations, notamment pour :

• notifier les membres de l'équipe
• mettre à jour un outil de gestion de projet
• déclencher une compilation d'intégration continue (CI), même si cela est plus courant avec les hooks côté serveur

En passant aux crochets côté serveur, pre-receive est exécuté avant la mise à jour des références (comme les branches ou les étiquettes) sur le dépôt distant.

Ce crochet est très puissant pour faire respecter des règles essentielles du dépôt, notamment :

• Empêcher les envois directs vers la branche main
• Vérifier que toutes les validations sont signées
• Valider l’identité de l’auteur de la validation

Si ce crochet se termine avec un code différent de zéro, l’intégralité de l’envoi est refusée.

Le crochet post-receive s’exécute après qu’un envoi a correctement mis à jour les références sur le dépôt distant.

Comme post-commit, ce crochet ne peut pas refuser l’envoi. Il est couramment utilisé pour :

• Déclencher des chaînes d’intégration et de déploiement continus
• Mettre à jour des outils externes de suivi des problèmes
• Envoyer des notifications par courriel à l’équipe
• Déployer le code dans un environnement de préproduction

Pour créer un crochet, il suffit de créer un fichier portant le nom du crochet (par exemple pre-commit) dans votre répertoire .git/hooks/. Créons-en un très simple :

Après avoir créé le script de votre crochet, vous devez le rendre exécutable. Git ne l’exécutera pas dans le cas contraire. Utilisez la commande chmod dans votre terminal :

chmod +x .git/hooks/pre-commit

Désormais, chaque fois que vous tenterez d’effectuer une validation, Git exécutera ce script !

Les crochets Git s’exécutent à des moments précis de votre flux de travail. Comprendre leur moment d’exécution est essentiel pour les utiliser efficacement.

Vous avez fait vos premiers pas dans l’univers puissant des crochets Git !

• Les crochets Git sont des scripts qui automatisent des actions lors des événements Git.
• Ils se trouvent dans le répertoire .git/hooks/ de votre dépôt.
• Les crochets sont soit côté client (machine locale), soit côté serveur (dépôt distant).
• Des crochets clés comme pre-commit et pre-receive peuvent faire respecter des règles en bloquant certaines opérations.
• Les crochets comme post-commit et post-receive servent aux notifications ou aux intégrations après une action.

Ensuite, nous verrons comment mettre en œuvre des exemples pratiques de crochets spécifiques !