Expériences en toute sécurité : travail avec les branches

1. Que sont les branches et à quoi servent-elles ?

Travailler avec les branches dans Git — c’est l’un des aspects clés de la gestion de versions, qui permet de mener en parallèle plusieurs lignes de développement dans un même dépôt. Le branchement fait de Git un outil puissant pour la collaboration, l’expérimentation et la gestion des différentes versions du projet.

            gitGraph
            commit id: "Initial setup"
            commit id: "Add base features"
            branch feature/new-idea
            checkout feature/new-idea
            commit id: "Implement new logic"
            commit id: "Refactor the logic"
            checkout main
            commit id: "Urgent bugfix on main"
            merge feature/new-idea
            commit id: "Prepare for release"
        

Imaginez que vous vouliez remanier sérieusement votre projet ou tenter une expérience risquée. Que feriez-vous sans Git ? Très probablement, vous copieriez tout le projet dans un nouveau dossier et y travailleriez. Si le résultat vous plaît — vous le déplaceriez dans le dossier principal. Sinon — vous supprimeriez simplement la copie.

Les branches dans Git fonctionnent selon le même principe, mais de façon bien plus élégante. Prenons l’exemple de l’écriture d’un livre :

1. Vous avez un manuscrit prêt (c’est votre branche principale main).
2. Vous souhaitez écrire une fin alternative (vous créez une nouvelle branche, par exemple feature/new-idea).
3. Vous écrivez cette nouvelle fin sans toucher au texte principal du manuscrit (vous travaillez dans la nouvelle branche).
4. Si la nouvelle fin s’avère meilleure, vous remplacez l’ancienne par la nouvelle (vous effectuez une fusion des branches — merge).
5. Le vieux brouillon avec l’ancienne fin peut être supprimé (vous supprimez la branche).

2. Création d’une nouvelle branche et travail dessus

Étape 1. Ouvrez le menu de gestion des branches.

Dans la barre supérieure de l’IDE se trouve un widget qui affiche le nom de la branche actuelle (par défaut — main). Cliquez dessus et choisissez + New Branch.

Étape 2. Nom de la nouvelle branche.

Bonne pratique — nommer les branches en fonction de la tâche que vous résolvez. Par exemple, feature/add-usage-examples.

Après avoir créé la branche, l’IDE basculera automatiquement dessus. Vous verrez le nouveau nom dans le même widget.

Étape 3. Apportez et validez des modifications.

Vous êtes maintenant dans votre « bac à sable ». Ajoutons un nouveau chapitre avec des exemples d’utilisation dans notre fichier README.md. Apportez les changements et effectuez un commit, comme vous l’avez appris dans le cours précédent.

3. Passer d’une branche à l’autre

Vos modifications avec des exemples d’utilisation sont maintenant enregistrées en toute sécurité dans la branche feature/add-usage-examples. Revenons à la branche principale main et voyons ce qu’il s’y passe.

Étape 1. Cliquez à nouveau sur le widget affichant le nom de la branche actuelle.

Étape 2. Dans la liste Local ou Recent, choisissez la branche main, puis dans le sous-menu, cliquez sur Checkout.

Étape 3. Vérifiez le résultat.

Dès que vous aurez basculé, ouvrez le fichier README.md. Vous verrez que la section avec des exemples d’utilisation n’y est pas ! Elle est restée dans l’autre branche. Ainsi, vous pouvez travailler sur une nouvelle fonctionnalité sans toucher à la version stable dans la branche main.

4. Fusion de branches (Merge)

La commande merge prend tous les commits de la branche feature/add-examples (dans notre cas, le commit C3) et les combine avec la branche actuelle main, en créant un nouveau commit de fusion.

            gitGraph
            commit id: "C1"
            commit id: "C2"
            branch feature/add-examples
            checkout feature/add-examples
            commit id: "C3: Add new section"
            checkout main
            merge feature/add-examples
        

Ainsi, vous avez terminé votre tâche dans la branche feature/add-usage-examples et vous souhaitez ajouter ces modifications au projet principal.

Étape 1. Basculez sur la branche cible.

Assurez-vous d’être dans la branche OÙ vous voulez ajouter les changements. Dans notre cas, c’est main.

Étape 2. Exécutez la fusion.

Cliquez à nouveau sur le widget de gestion des branches. Dans la liste, choisissez la branche D’OÙ vous souhaitez prendre les changements (feature/add-usage-examples), puis dans le sous-menu, choisissez Merge feature/add-usage-examples dans main.

Étape 3. Vérifiez le résultat.

Votre nouveau chapitre avec des exemples est maintenant présent dans le fichier README.md de la branche main. Vous avez fusionné votre travail avec la version principale du projet avec succès !

5. Conflits lors d’une fusion : pas de panique, c’est normal !

Il arrive parfois que des conflits surviennent lors d’une fusion. Cela se produit lorsque les mêmes lignes du même fichier ont été modifiées dans les deux branches. Git ne peut pas décider seul quelle version est la bonne et vous demande de l’aide.

            gitGraph
            commit id: "C1: Base commune"
            branch feature/new-title
            checkout main
            commit id: "C2: Modification dans main"
            checkout feature/new-title
            commit id: "C3: Modification dans feature"
        

Simulons un conflit :

1. Assurez-vous d’être sur la branche main et de ne pas avoir de modifications non enregistrées.
2. Créez tout de suite une nouvelle branche feature/new-title, mais n’y basculez pas encore. Assurez-vous que la case Checkout branch n’est pas cochée.
3. Maintenant, en restant sur la branche main, remplacez la première ligne de README.md par « My Awesome Project » et faites un commit.
4. Basculez sur la branche feature/new-title. Vous verrez que la première ligne de README.md y est restée ancienne : c’est l’état du fichier au moment de la création de la branche. Modifiez cette même ligne en « My Super Project » et faites un commit.
5. Revenez sur la branche main et effectuez une fusion avec feature/new-title.

Git verra alors que les deux branches ont des historiques nouveaux et divergents depuis leur ancêtre commun. Dans les deux historiques, la même ligne a été modifiée, donc Git ne pourra pas choisir quelle version est correcte et affichera une fenêtre pour résoudre le conflit.

Merge Revision

Ce que vous voyez ici :

• À gauche (Your changes) : la version du fichier provenant de votre branche actuelle (main).
• À droite (Changes from branch...) : la version du fichier provenant de la branche que vous fusionnez.
• Au centre (Result) : la version finale du fichier, que vous devez composer.

Vous pouvez cliquer sur les flèches >> ou << pour accepter entièrement l’une ou l’autre version.

Lorsque le résultat dans le panneau central vous convient, cliquez sur Apply. L’IDE créera elle-même le commit de fusion et le conflit sera résolu.

Pourquoi aucun conflit ne s’est produit ?

Il peut arriver que vous ayez effectué toutes les étapes, mais qu’aucun conflit ne se produise. Le plus souvent, c’est parce que Git a pu faire un fast-forward merge, l’historique d’une branche ayant simplement prolongé celui de l’autre. Pour garantir un conflit, les historiques des branches doivent diverger à partir de l’ancêtre commun.

Exemple :

1. Vous avez un commit dans main (disons C1).
2. Vous effectuez un nouveau commit dans main avec le texte « My Awesome Project ». La branche main pointe maintenant vers le commit C2 (main -> C1 -> C2).
3. Vous créez la branche feature/new-title à partir de l’état actuel de la branche main. Cela signifie que la nouvelle branche commence elle aussi au commit C2.
4. Vous faites un commit dans feature/new-title avec le texte « My Super Project ». Cette branche « part devant » et pointe désormais vers le commit C3 (feature/new-title -> C1 -> C2 -> C3).
5. Vous revenez dans main (qui est toujours sur le commit C2) et demandez de fusionner feature/new-title.

Git examine la situation et voit que la branche main est un ancêtre direct de la branche feature/new-title. L’historique de main n’a reçu aucun nouveau commit pendant que vous travailliez dans l’autre branche. Git se dit : « Ah, il suffit d’avancer main jusqu’au commit C3. Il n’y a aucune contradiction. » Et il déplace simplement le pointeur main sur le commit C3.

            gitGraph
            commit id: "C1"
            commit id: "C2"
            branch feature/new-title
            checkout feature/new-title
            commit id: "C3"
            checkout main
            merge feature/new-title
        

6. Visualiser l’historique des modifications

Pour mieux comprendre ce qui se passe dans votre projet, il est utile de consulter son historique.

Ouvrez l’onglet Git en bas de l’IDE et sélectionnez Log. Vous verrez une représentation graphique de toutes vos branches et de vos commits. Cela vous aidera à suivre visuellement quelle branche s’est séparée de laquelle et où elles ont été fusionnées.

Ici, vous pouvez cliquer sur n’importe quel commit pour voir quelles modifications il contient, qui l’a fait et quand. C’est une véritable machine à remonter le temps pour le code !