Réconciliation de Branches Divergentes

Comprendre les branches divergentes

Deux branches divergent quand elles ont un ancêtre commun mais ont chacune des commits distincts. Cela crée une situation où les branches ne sont plus en ligne directe l'une avec l'autre.

Main:     A -- B -- C -- D
                \
Feature:         E -- F

Méthodes de réconciliation

1. Fusion (Merge)

La fusion combine les changements de deux branches en créant un commit de fusion.

Fusionner une branche dans la branche courante

# Se placer sur la branche main
git checkout main

# Fusionner la branche feature
git merge feature

Types de fusion

Fusion rapide (Fast-forward) - Utilisée quand la branche courante n'a pas de nouveaux commits depuis le point de divergence - Crée une ligne linéaire d'historique

git merge --ff feature

Fusion avec commit de fusion - Crée toujours un commit de fusion, même si le fast-forward est possible - Préserve l'historique de la branche

git merge --no-ff feature

Fusion sans commit de fusion (Squash) - Combine tous les commits de la branche en un seul - Utile pour nettoyer l'historique

git merge --squash feature
git commit -m "Merge feature"

2. Rebase

Le rebase ré-applique les commits d'une branche sur une autre base, créant une ligne droite d'historique.

# Se placer sur la branche feature
git checkout feature

# Rebaser sur main
git rebase main

Après rebase, il faut fast-forward la branche main :

git checkout main
git merge feature

Avantages du rebase - Historique linéaire et propre - Facile à lire et comprendre - Chaque commit est autonome et testable

Inconvénients du rebase - Réécrit l'historique (problématique en équipe) - Plus difficile à déboguer avec git bisect

3. Rebase interactif

Permet de nettoyer l'historique avant de réconcilier.

git rebase -i main

Options disponibles : - pick : Utiliser le commit - reword : Modifier le message du commit - squash : Fusionner avec le commit précédent - fixup : Fusionner en supprimant le message - drop : Supprimer le commit

Résolution de conflits

Détection des conflits

# Lors d'une fusion
git merge feature

# Git indique les fichiers en conflit
CONFLICT (content): Merge conflict in file.txt

Affichage des conflits

Git marque les zones en conflit :

<<<<<<< HEAD
Votre code (branche actuelle)
=======
Leur code (branche à fusionner)
>>>>>>> feature

Résolution manuelle

  1. Éditer les fichiers pour résoudre les conflits
  2. Sauvegarder les fichiers
  3. Ajouter les fichiers résolus
git add file.txt
  1. Finaliser la fusion/rebase
# Pour une fusion
git commit

# Pour un rebase
git rebase --continue

Outils de résolution

Prévisualiser les conflits

git diff --name-only --diff-filter=U

Utiliser un outil visuel

git mergetool

Abandon de l'opération

# Annuler une fusion
git merge --abort

# Annuler un rebase
git rebase --abort

Bonnes pratiques

Pratique Description
Communiquer en équipe Informer avant de rebaser une branche partagée
Tester avant Vérifier que les tests passent avant de fusionner
Commits atomiques Chaque commit doit avoir un seul objectif
Messages clairs Écrire des messages explicites
Utiliser les branches locales Rebaser les branches locales, fusionner les branches partagées

Workflow recommandé

# 1. Créer une branche
git checkout -b feature/ma-feature

# 2. Développer
git commit -m "Ajout de fonctionnalité X"

# 3. Récupérer les changements de main
git fetch origin
git rebase origin/main

# 4. Résoudre les conflits si nécessaire
# ... éditer les fichiers ...
git add .
git rebase --continue

# 5. Pousser vers le serveur
git push origin feature/ma-feature

# 6. Créer une merge request (GitHub, GitLab, etc.)
# 7. Après approbation, fusionner (via l'interface)

Cas pratiques

Cas 1 : Branche locale en retard

git fetch origin
git rebase origin/main

Cas 2 : Nombreux petits commits à nettoyer

git rebase -i main
# Utiliser 'squash' pour les commits à fusionner

Cas 3 : Fusionner après résolution de conflit

git merge --no-ff feature -m "Merge feature: description"

Références