Comment résoudre le cas où la branche Git est en avance sur l'origine (Origin)

Introduction

Dans ce laboratoire, vous apprendrez à gérer un scénario Git courant : lorsque votre branche locale est en avance sur le dépôt distant (remote repository). Cette situation se produit lorsque vous effectuez des commits localement mais que vous ne les avez pas encore poussés vers le dépôt distant. À la fin de ce laboratoire, vous comprendrez comment identifier quand votre branche est en avance sur le distant et comment synchroniser correctement vos dépôts locaux et distants.

Effectuer des modifications locales

Dans cette étape, vous allez effectuer des modifications dans votre dépôt local qui n'ont pas encore été poussées vers le dépôt distant, créant ainsi le scénario où la branche est "en avance sur origin".

Configuration du dépôt

Tout d'abord, nous devons configurer un dépôt avec lequel travailler. Nous utiliserons le dépôt git-playground comme point de départ. Comme vous avez besoin des permissions de push pour réaliser ce laboratoire, vous devrez d'abord forker (créer une copie) le dépôt.

Forker le dépôt

1. Visitez https://github.com/labex-labs/git-playground dans votre navigateur
2. Cliquez sur le bouton "Fork" (Forger) dans le coin supérieur droit pour créer votre propre copie du dépôt
3. Une fois le fork créé, notez votre nom d'utilisateur GitHub - vous en aurez besoin pour l'étape suivante

Cloner votre dépôt forké

Maintenant, clonons votre dépôt forké sur votre machine locale. Remplacez YOUR_USERNAME par votre nom d'utilisateur GitHub réel :

cd ~/project
git clone https://github.com/YOUR_USERNAME/git-playground.git
cd git-playground

Après le clonage, vérifiez que le dépôt distant est correctement configuré :

git remote -v

Vous devriez voir un résultat affichant votre dépôt forké comme étant la télécommande (remote) origin :

origin  https://github.com/YOUR_USERNAME/git-playground.git (fetch)
origin  https://github.com/YOUR_USERNAME/git-playground.git (push)

Comprendre les dépôts locaux et distants

Git fonctionne avec un modèle distribué où chaque développeur possède une copie complète du dépôt sur sa machine locale. Les modifications effectuées localement doivent être explicitement synchronisées avec le dépôt distant.

Vérifions maintenant l'état actuel de notre dépôt :

git status

Vous devriez voir un résultat similaire à ceci :

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Cela signifie que votre dépôt local est actuellement synchronisé avec le dépôt distant.

Créer un nouveau fichier

Créons un nouveau fichier dans notre dépôt :

echo "This is a new file for our project." > new_file.txt

Après avoir créé le fichier, nous devons l'ajouter à la zone de staging (zone de préparation) de Git :

git add new_file.txt

Maintenant, validons (commit) ce fichier dans notre dépôt local :

git commit -m "Add new_file.txt"

Vous devriez voir un résultat confirmant votre commit :

[master 1a2b3c4] Add new_file.txt
 1 file changed, 1 insertion(+)
 create mode 100644 new_file.txt

Vérifier l'état de la branche

Maintenant que nous avons effectué un commit local, vérifions à nouveau l'état de notre dépôt :

git status

Cette fois, vous devriez voir :

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

Ce message indique que votre branche locale contient un commit qui n'a pas encore été poussé vers le dépôt distant. C'est exactement la situation que nous voulions créer : votre branche est maintenant "en avance sur origin".

Visualiser les différences de branche

Maintenant que votre branche locale est en avance sur la branche distante, explorons comment visualiser les différences spécifiques entre vos branches locale et distante.

Comprendre les références de branche

Dans Git, vous faites référence à la branche distante en utilisant le format origin/nom-de-la-branche. Le terme origin est le nom par défaut du dépôt distant, et nom-de-la-branche est le nom de la branche (dans notre cas, c'est master).

Visualiser les différences de commits

Pour voir les commits qui existent dans votre branche locale mais pas dans la branche distante, utilisez la commande suivante :

git log origin/master..HEAD

Le résultat vous montrera le(s) commit(s) qui se trouvent dans votre branche locale (HEAD) mais pas dans la branche distante (origin/master) :

commit 1a2b3c4d... (HEAD -> master)
Author: LabEx User <labex@example.com>
Date:   ...

    Add new_file.txt

Visualiser les différences de fichiers

Pour voir quels fichiers diffèrent entre vos branches locale et distante, utilisez :

git diff --name-status origin/master..HEAD

Le résultat devrait afficher :

A       new_file.txt

Ceci indique que new_file.txt a été ajouté dans votre branche locale mais n'existe pas dans la branche distante.

Comprendre la visualisation des différences

Pour voir les différences de contenu réelles, vous pouvez utiliser :

git diff origin/master..HEAD

Ceci affichera les modifications spécifiques apportées à chaque fichier :

diff --git a/new_file.txt b/new_file.txt
new file mode 100644
index 0000000..3b2aed8
--- /dev/null
+++ b/new_file.txt
@@ -0,0 +1 @@
+This is a new file for our project.

Ces commandes vous aident à comprendre exactement quelles modifications se trouvent dans votre branche locale et qui n'ont pas encore été poussées vers le dépôt distant.

Pousser les modifications vers le distant

Maintenant que vous comprenez quelles modifications sont présentes dans votre branche locale, il est temps de synchroniser votre dépôt local avec le dépôt distant en poussant vos modifications.

Comprendre git push

La commande git push envoie vos commits locaux au dépôt distant. Lorsque vous poussez, vous synchronisez la branche distante avec votre branche locale, rendant les deux branches identiques.

Pousser vos modifications

Pour pousser vos commits locaux vers le dépôt distant, utilisez :

git push origin master

Vous devriez voir un résultat similaire à ceci :

Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 324 bytes | 324.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/YOUR_USERNAME/git-playground.git
   abcd123..1a2b3c4  master -> master

Le résultat montre :

• Git a compté et compressé les objets de votre commit
• Les modifications ont été envoyées avec succès au dépôt distant
• Les identifiants de commit (hash) anciens et nouveaux
• La branche qui a été mise à jour (master -> master)

Vérifier le push

Vérifions à nouveau le statut de notre dépôt :

git status

Vous devriez maintenant voir :

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Ceci confirme que votre branche locale est maintenant synchronisée avec la branche distante. Le message "ahead of origin" a disparu car les deux branches contiennent désormais les mêmes commits.

Vérifier le contenu du dépôt distant

Nous pouvons vérifier que nos modifications sont maintenant dans le dépôt distant en examinant l'historique (log) de la branche distante :

git log origin/master -1

Cette commande affiche le commit le plus récent sur la branche distante, qui devrait maintenant inclure notre nouveau fichier :

commit 1a2b3c4d... (HEAD -> master, origin/master)
Author: LabEx User <labex@example.com>
Date:   ...

    Add new_file.txt

Notez que HEAD -> master et origin/master pointent maintenant vers le même commit, confirmant que les deux branches sont synchronisées.

Créer et résoudre plusieurs commits d'avance

Dans les scénarios réels, vous pourriez avoir plusieurs commits d'avance sur votre branche distante. Créons cette situation et apprenons à la résoudre.

Effectuer plusieurs commits locaux

Créons et committons plusieurs modifications :

## Create a second file
echo "This is the second file." > second_file.txt
git add second_file.txt
git commit -m "Add second_file.txt"

## Modify the README
echo "### Additional Information" >> README.md
echo "This project demonstrates Git branch synchronization." >> README.md
git add README.md
git commit -m "Update README with additional information"

Vérifions maintenant notre statut :

git status

Vous devriez voir :

On branch master
Your branch is ahead of 'origin/master' by 2 commits.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

Visualiser les différences de multiples commits

Voyons quels commits nous avons localement qui ne sont pas sur le distant :

git log origin/master..HEAD --oneline

Vous devriez voir vos deux nouveaux commits :

abcd123 Update README with additional information
efgh456 Add second_file.txt

Pousser de multiples commits

Pour synchroniser tous vos commits locaux avec le dépôt distant, utilisez la même commande push :

git push origin master

Le résultat montrera les deux commits en cours de poussée :

Enumerating objects: 7, done.
Counting objects: 100% (7/7), done.
Delta compression using up to 2 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 574 bytes | 574.00 KiB/s, done.
Total 5 (delta 1), reused 0 (delta 0), pack-reused 0
To https://github.com/YOUR_USERNAME/git-playground.git
   1a2b3c4..abcd123  master -> master

Vérifier que tous les commits sont poussés

Vérifions à nouveau notre statut :

git status

Vous devriez voir :

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Ceci confirme que tous vos commits locaux ont été poussés avec succès vers le dépôt distant.

Résumé

Dans ce laboratoire, vous avez appris à gérer les situations où votre branche Git locale est en avance sur la branche distante. Vous avez réussi à :

1. Créer un commit local qui a mis votre branche en avance sur la branche distante.
2. Utiliser les commandes Git pour visualiser les différences spécifiques entre vos branches locale et distante.
3. Pousser vos modifications pour synchroniser vos dépôts local et distant.
4. Créer plusieurs commits localement et les pousser tous en une seule fois vers la branche distante.

Ces compétences sont essentielles pour le flux de travail Git quotidien, car elles vous aident à maintenir la synchronisation entre vos dépôts local et distant, ce qui est crucial pour une collaboration efficace dans les projets de développement logiciel. N'oubliez pas que maintenir vos branches synchronisées régulièrement aide à prévenir les conflits et rend la collaboration plus fluide.