Les Outils de l'Archiviste

Alias, hooks et configuration Git

Les alias Git - Incantations raccourcies

Certaines commandes Git sont longues à taper et tu les utilises des dizaines de fois par jour. Les alias te permettent de créer des raccourcis personnalisés.

Créer des alias

La syntaxe est simple :

git config --global alias.RACCOURCI "COMMANDE"

Voici les alias les plus courants :

# Status en raccourci
git config --global alias.st status

# Checkout en raccourci
git config --global alias.co checkout

# Branch en raccourci
git config --global alias.br branch

# Commit en raccourci
git config --global alias.ci commit

# Log avec graphe - le plus utile !
git config --global alias.lg "log --oneline --graph --all"

Utiliser les alias

Une fois configurés, tu peux les utiliser immédiatement :

# Au lieu de "git status"
git st

# Au lieu de "git checkout main"
git co main

# Au lieu de "git branch"
git br

# Au lieu de "git commit -m 'message'"
git ci -m "message"

# Au lieu de "git log --oneline --graph --all"
git lg

Vérifier les alias existants

# Voir tous les alias configurés
git config --get-regexp alias

Les hooks Git - Les plumes gardiennes

Les hooks (crochets) sont des scripts qui s'exécutent automatiquement à des moments clés du workflow Git. Ce sont des gardiens silencieux qui vérifient, valident et protègent ton travail.

Où vivent les hooks ?

Chaque dépôt Git contient un dossier .git/hooks/ avec des exemples de hooks :

ls .git/hooks/

Tu verras des fichiers comme pre-commit.sample, commit-msg.sample, etc. Pour activer un hook, il suffit de créer un fichier avec le bon nom (sans .sample) et de le rendre exécutable.

Les hooks les plus utiles

Créer un hook pre-commit

Un hook est simplement un script. Voici un exemple qui vérifie la présence de "TODO" dans les fichiers stagés :

#!/bin/bash
# .git/hooks/pre-commit
# Vérifie qu'aucun fichier stagé ne contient "TODO"

fichiers=$(git diff --cached --name-only)

if [ -z "$fichiers" ]; then
    exit 0
fi

if git diff --cached --diff-filter=ACM | grep -q "TODO"; then
    echo "⚠ ATTENTION : Un ou plusieurs fichiers contiennent 'TODO' !"
    echo "Fichiers concernés :"
    git diff --cached --name-only | while read f; do
        if git show ":$f" 2>/dev/null | grep -q "TODO"; then
            echo "  - $f"
        fi
    done
    echo ""
    echo "Le commit est autorisé, mais pense à traiter ces TODO."
fi

exit 0

chmod +x .git/hooks/pre-commit

Créer un hook commit-msg

Ce hook vérifie que le message de commit respecte un format minimum :

#!/bin/bash
# .git/hooks/commit-msg
# Rejette les messages de commit de moins de 10 caractères

message=$(cat "$1")
longueur=${#message}

if [ "$longueur" -lt 10 ]; then
    echo "✗ REJETÉ : Le message de commit est trop court ($longueur caractères)."
    echo "  Minimum requis : 10 caractères."
    echo "  Message reçu : \"$message\""
    exit 1
fi

exit 0

chmod +x .git/hooks/commit-msg

Configuration avancée de Git

Au-delà des alias et des hooks, Git offre de nombreuses options de configuration qui améliorent ton confort de travail.

L'éditeur par défaut

# Visual Studio Code
git config --global core.editor "code --wait"

# Vim
git config --global core.editor "vim"

# Nano (le plus simple)
git config --global core.editor "nano"

La branche par défaut

git config --global init.defaultBranch main

Tous tes nouveaux dépôts utiliseront main au lieu de master comme branche par défaut.

Le comportement du pull

# Rebase au lieu de merge lors d'un pull (recommandé)
git config --global pull.rebase true

# Ou forcer le merge classique
git config --global pull.rebase false

Avec pull.rebase true, un git pull fera automatiquement un rebase au lieu de créer un commit de merge. Ça garde l'historique plus propre.

Le style des conflits

git config --global merge.conflictstyle diff3

Le style diff3 ajoute une section supplémentaire dans les conflits de merge : en plus de "la version de gauche" et "la version de droite", tu vois aussi la version commune d'origine. C'est beaucoup plus facile pour comprendre ce qui a changé de chaque côté.

<<<<<<< HEAD
Version de ta branche
||||||| merged common ancestors
Version originale (avant les deux modifications)
>>>>>>> feature
Version de l'autre branche

Le fichier .gitconfig - La vue d'ensemble

Toutes ces configurations sont stockées dans un fichier ~/.gitconfig (sur Linux/macOS) ou C:\Users\TON_NOM\.gitconfig (sur Windows).

Tu peux le consulter directement :

# Voir toute la configuration
git config --global --list

# Ou ouvrir le fichier dans ton éditeur
git config --global --edit

Le fichier ressemble à ça :

[user]
    name = Ton Nom
    email = ton@email.com
[alias]
    st = status
    co = checkout
    br = branch
    ci = commit
    lg = log --oneline --graph --all
[core]
    editor = code --wait
[init]
    defaultBranch = main
[pull]
    rebase = true
[merge]
    conflictstyle = diff3

Exercice pratique - Forger tes outils

Étape 1 - Créer le dépôt

mkdir outils-archiviste
cd outils-archiviste
git init -b main

Étape 2 - Configurer les alias

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.lg "log --oneline --graph --all"

Étape 3 - Tester les alias

# Vérifie que les alias fonctionnent
git st
git lg

git st devrait afficher le status du dépôt et git lg devrait afficher le graphe (vide pour l'instant).

Étape 4 - Créer le hook pre-commit

cat > .git/hooks/pre-commit << 'HOOK'
#!/bin/bash
# Hook pre-commit : avertit si des fichiers stagés contiennent "TODO"

fichiers=$(git diff --cached --name-only)

if [ -z "$fichiers" ]; then
    exit 0
fi

if git diff --cached --diff-filter=ACM | grep -q "TODO"; then
    echo "⚠ ATTENTION : Un ou plusieurs fichiers contiennent 'TODO' !"
    echo "Fichiers concernés :"
    git diff --cached --name-only | while read f; do
        if git show ":$f" 2>/dev/null | grep -q "TODO"; then
            echo "  - $f"
        fi
    done
    echo ""
    echo "Le commit est autorisé, mais pense à traiter ces TODO."
fi

exit 0
HOOK

Rends-le exécutable :

chmod +x .git/hooks/pre-commit

Étape 5 - Tester le hook pre-commit

echo "# Liste des tâches" > taches.txt
echo "TODO: Ajouter la validation" >> taches.txt
git add taches.txt
git commit -m "Ajouter la liste des tâches avec TODO"

Tu devrais voir l'avertissement du hook avant que le commit ne soit créé.

Étape 6 - Créer le hook commit-msg

cat > .git/hooks/commit-msg << 'HOOK'
#!/bin/bash
# Hook commit-msg : rejette les messages de moins de 10 caractères

message=$(cat "$1")
longueur=${#message}

if [ "$longueur" -lt 10 ]; then
    echo "✗ REJETÉ : Le message de commit est trop court ($longueur caractères)."
    echo "  Minimum requis : 10 caractères."
    echo "  Message reçu : \"$message\""
    exit 1
fi

exit 0
HOOK

Rends-le exécutable :

chmod +x .git/hooks/commit-msg

Étape 7 - Tester le hook commit-msg

D'abord, teste avec un message trop court (il doit être rejeté) :

echo "Test du hook commit-msg" > test-hook.txt
git add test-hook.txt
git commit -m "test"

Le commit devrait être rejeté car "test" fait moins de 10 caractères.

Maintenant, refais avec un bon message :

git commit -m "Ajouter le fichier de test pour les hooks"

Cette fois, le commit devrait passer.

Étape 8 - Lancer la vérification

bash verifier.sh

.\verifier.ps1

Récapitulatif des commandes