Arc 2 Quête 07

Le Conflit des Royaumes

Merge, conflits et résolution

Introduction

La salle des archives tremble légèrement. Sur la grande table de chêne, deux parchemins sont déroulés côte à côte - deux chroniques du même événement, mais avec des récits contradictoires. Le Maître Archiviste pose une main sur chaque parchemin, le regard grave.

« Apprenti, tu as appris à ouvrir des lignes temporelles parallèles - les branches. Mais que se passe-t-il quand ces lignes doivent converger ? Quand deux royaumes racontent la même bataille, mais avec des versions différentes ? C'est là qu'intervient le merge - la fusion des chroniques. Parfois, la fusion se fait naturellement. Parfois, les récits se contredisent, et il faut un Archiviste pour réconcilier les versions. C'est ta mission aujourd'hui. »

Qu'est-ce qu'un merge ?

Un merge (fusion) est l'opération qui réunit deux branches en une seule. C'est comme rassembler les chroniques de deux archivistes qui ont travaillé en parallèle sur des sujets différents - ou parfois sur le même sujet.

Imagine deux chroniqueurs envoyés dans des royaumes différents :

  • L'un part à l'Est et consigne l'histoire du Royaume de l'Aurore.
  • L'autre part à l'Ouest et consigne l'histoire du Royaume du Couchant.

Quand ils reviennent, il faut fusionner leurs chroniques en un seul grand registre. Si chacun a écrit sur des sujets différents, c'est simple. Mais s'ils ont écrit sur la même bataille avec des versions contradictoires... il y a conflit.

Fusionner une branche : git merge

Pour fusionner une branche dans la branche courante :

git merge <branche>

Important : tu dois d'abord te placer sur la branche qui reçoit les modifications. En général, on se met sur main avant de fusionner une branche de travail :

git switch main
git merge ma-branche

Cela prend les commits de ma-branche et les intègre dans main.

Les types de merge

Le fast-forward - La fusion simple

Quand la branche cible (main) n'a reçu aucun nouveau commit depuis la création de la branche de travail, Git peut simplement "avancer" le pointeur main jusqu'au dernier commit de la branche. C'est le fast-forward.

Avant :
main:        A --- B
                    \
ma-branche:          C --- D

Après git merge ma-branche (depuis main) :
main:        A --- B --- C --- D

Pas de commit de merge créé - Git se contente de déplacer main en avant. C'est le cas le plus simple.

Le merge à trois voies (three-way merge)

Quand les deux branches ont évolué depuis leur point de divergence, Git ne peut pas simplement avancer un pointeur. Il doit combiner les modifications des deux côtés. Si les modifications touchent des fichiers ou des lignes différentes, Git s'en sort tout seul et crée un commit de merge :

Avant :
main:        A --- B --- E
                    \
ma-branche:          C --- D

Après git merge ma-branche (depuis main) :
main:        A --- B --- E --- M
                    \         /
ma-branche:          C --- D

Le commit M est un commit de merge - il a deux parents (E et D). Git l'a créé automatiquement parce que les modifications ne se chevauchaient pas.

Les conflits de merge

Quand deux branches ont modifié les mêmes lignes du même fichier, Git ne peut pas décider tout seul quelle version garder. Il s'arrête et te demande de trancher. C'est un conflit de merge.

Anatomie d'un conflit

Quand un conflit survient, Git modifie le fichier concerné en y insérant des marqueurs de conflit :

<<<<<<< HEAD
Le roi Aldric a remporté la bataille grâce à sa cavalerie.
=======
Le roi Aldric a perdu la bataille face aux archers ennemis.
>>>>>>> chroniques-est

Voici ce que signifient ces marqueurs :

  • <<<<<<< HEAD : début de ta version (la branche courante)
  • ======= : séparateur entre les deux versions
  • >>>>>>> chroniques-est : fin de la version de l'autre branche

Les marqueurs de conflit doivent tous être supprimés avant de pouvoir commiter. Si tu en laisses un seul, ton fichier sera corrompu et Git ne considèrera pas le conflit comme résolu.

Résoudre un conflit

Pour résoudre un conflit, suis ces étapes :

  1. Ouvre le fichier contenant le conflit dans ton éditeur
  2. Choisis quelle version garder, ou combine les deux versions en un récit cohérent
  3. Supprime tous les marqueurs de conflit (<<<<<<<, =======, >>>>>>>)
  4. Sauvegarde le fichier
  5. Marque le conflit comme résolu avec git add
  6. Crée le commit de merge avec git commit
# Après avoir édité le fichier manuellement :
git add chroniques.txt
git commit -m "Fusionner chroniques-est : réconcilier les récits de la bataille"

Annuler un merge en cours

Si tu te retrouves dépassé par un conflit et que tu veux revenir en arrière :

git merge --abort

Cela annule le merge et remet tout dans l'état d'avant. Tu peux recommencer plus tard quand tu seras prêt.

git merge --abort est ton filet de sécurité. N'hésite pas à l'utiliser si tu t'es emmêlé les pinceaux dans la résolution d'un conflit - mieux vaut recommencer proprement que de commiter un fichier mal résolu.

Conseils pour éviter les conflits

  1. Fais des merges fréquents : plus tu attends, plus les branches divergent, plus les conflits sont nombreux et complexes.
  2. Communique avec ton équipe : si quelqu'un travaille sur le même fichier que toi, coordonnez-vous.
  3. Découpe bien tes fichiers : un fichier de 1000 lignes crée plus de conflits qu'une dizaine de fichiers bien organisés.
  4. Garde tes branches courtes : une branche qui vit 2 jours crée moins de conflits qu'une branche qui vit 2 mois.

Exercice pratique - Le Conflit des Royaumes

Deux chroniqueurs ont été envoyés aux frontières du royaume. Elowen est partie à l'Est, au Royaume de l'Aurore. Gareth est parti à l'Ouest, au Royaume du Couchant. Chacun a consigné sa version de la Bataille du Pont de Pierre. Malheureusement, leurs récits se contredisent. Tu dois réconcilier leurs chroniques.

Étape 1 - Récupérer l'archive

git clone archive.bundle le-conflit-des-royaumes
cd le-conflit-des-royaumes

Étape 2 - Explorer les branches

git branch -a
git log --oneline --all --graph

Tu devrais voir la branche main et les branches distantes origin/chroniques-est et origin/chroniques-ouest. Comme le dépôt a été cloné depuis un bundle, les branches des chroniqueurs sont des branches distantes - on les référence avec le préfixe origin/.

Étape 3 - Premier merge (sans conflit)

Fusionne d'abord la branche origin/chroniques-ouest dans main :

git switch main
git merge origin/chroniques-ouest

Ce merge devrait se passer sans problème - Gareth a ajouté son rapport et écrit sa version de la bataille. Comme main a aussi évolué de son côté, Git va créer un commit de merge automatiquement.

Vérifie le résultat avec git log --oneline --graph. Tu devrais voir les deux branches se rejoindre dans un commit de merge.

Étape 4 - Deuxième merge (avec conflit !)

Maintenant, fusionne la branche origin/chroniques-est :

git merge origin/chroniques-est

Cette fois, Git s'arrête avec un message de conflit ! Elowen et Gareth ont écrit des versions différentes de la même section dans chroniques.txt. Git ne peut pas choisir tout seul.

Pas de panique ! C'est normal et c'est exactement ce qu'on va apprendre à gérer. Le fichier rapport-est.txt a été fusionné sans problème (pas de conflit dessus), seul chroniques.txt pose problème.

Étape 5 - Résoudre le conflit

  1. Ouvre chroniques.txt dans ton éditeur de texte
  2. Cherche les marqueurs <<<<<<<, ======= et >>>>>>>
  3. Lis les deux versions du récit de la bataille
  4. Écris un récit qui combine les deux perspectives en une version cohérente et équilibrée - en bon Archiviste, tu ne prends pas parti !
  5. Supprime tous les marqueurs de conflit
  6. Sauvegarde le fichier

Il n'y a pas qu'une seule bonne réponse ! L'important est que le résultat soit cohérent, que les deux perspectives soient représentées, et qu'il ne reste aucun marqueur de conflit dans le fichier.

Étape 6 - Finaliser le merge

git add chroniques.txt
git commit -m "Fusionner chroniques-est : réconcilier les récits de la bataille"

Étape 7 - Vérifier

Lance le script de vérification pour valider ta quête :

Bash (Linux / macOS / Git Bash sur Windows) :

bash verifier.sh

PowerShell (Windows) :

.\verifier.ps1

Le script vérifie :

  1. Tu es dans un dépôt Git
  2. Un merge a été effectué (commit de merge présent)
  3. Aucun marqueur de conflit ne reste dans les fichiers
  4. Aucun merge n'est en cours (pas de conflit non résolu)
  5. Le commit de merge a un message descriptif (au moins 10 caractères)

Récapitulatif des commandes

Commande Description
git merge <branche> Fusionne la branche indiquée dans la branche courante
git merge --abort Annule un merge en cours et revient à l'état d'avant
git log --oneline --graph Visualise l'historique avec les branches et les merges
git add <fichier> Marque un fichier en conflit comme résolu
git commit Finalise le commit de merge après résolution des conflits

Le Maître Archiviste examine le registre unifié, où les deux versions de la bataille coexistent enfin en un récit cohérent.

« Tu as accompli quelque chose de remarquable, apprenti. Réconcilier des versions contradictoires est l'une des tâches les plus délicates d'un Archiviste. Dans le monde réel, les conflits sont inévitables quand plusieurs personnes travaillent ensemble. Ce qui compte, c'est de savoir les résoudre avec soin et discernement. Tu maîtrises maintenant l'art de la fusion. »