TP4 : Voyage dans le temps

Objectifs¶

Le but de ce TP est de comprendre les commandes suivantes :

• git checkout

• git stash

• git reset

• git revert

Une petite révision¶

Le voyage dans le temps¶

Nous avons appris que Git utilise un graphe de commits pour représenter les différentes versions de notre projet au cours du temps. Maintenant, nous allons apprendre comment naviguer dans ce graphe.

Checkout¶

Nous pouvons naviguer à travers les différents sommets de ce graphe, ce qui signifie que nous pouvons revenir à différents états de notre dépôt dans le passé, enregistrés par les commits. Avant de commencer, vérifiez que votre dépôt est bien propre (toutes les modifications sont dans un commit).

1. Exécutez git checkout <commit hash> avec le commit hash d’un ancien commit. Votre commande pourrait ressembler à git checkout abc0123 par exemple.

2. Observez l’état de votre (ancien) Repo.

3. Revenez au sommet le plus récent (et quittez l’état detached HEAD) en exécutant git checkout main.

4. Vous pouvez aussi utiliser git diff <commit hash> pour voir les différences entre votre Working Tree courant et l’état de votre Repo après un ancien commit.

5. Voyagez dans le graphe de vos commits et observez l’état de votre Repo (avec checkout, diff, status et graph), puis revenez au présent lorsque vous maîtrisez ce voyage dans le temps.

Stash¶

Pour préparer notre voyage dans le temps, nous allons apprendre à conserver les modifications courantes du présent qui ne sont pas encore dans notre graphe de commits, car revenir dans le passé modifiera la réalité observée dans notre Working Tree.

1. Avant de commencer, vérifiez l’état de votre graphe de commits avec git graph.

2. Créez un répertoire TP4/ avec un fichier time-travel.txt contenant le contenu de votre choix.

3. Exécutez git add et git commit pour enregistrer ces changements.

4. Observez avec git graph qu’un nouveau sommet a bien été ajouté avec votre message de commit.

5. Modifiez le contenu du fichier time-travel.txt sans faire git add ni git commit.

6. Exécutez git stash et observez le contenu de ce fichier.

7. Exécutez git stash pop et observez le contenu de time-travel.txt.

8. Créez trois fichiers modified-time-travel.txt, staged-time-travel.txt et ignored-time-travel (sans extension) contenant le contenu de votre choix.

9. Add, commit, push et vérifiez que les modifications sont sur le Remote Repo, sauf pour ignored-time-travel qui est ignoré (si vous avez bien configuré votre .gitignore pour ignorer les fichiers sans extension, sinon il faut corriger votre .gitignore, nettoyer votre Remote Repo et reprendre à partir de 8).

10. Créez un nouveau fichier untracked-time-travel.txt dans TP4/ avec le contenu que vous voulez sans faire git add.

11. Modifiez le contenu de modified-time-travel.txt sans faire git add.

12. Modifiez le contenu de staged-time-travel.txt et faites git add staged-time-travel.txt sans faire git commit.

13. Modifiez le contenu de ignored-time-travel.

À ce stade, vérifiez bien que vous avez un nouveau fichier non suivi (untracked-time-travel.txt), un fichier modifié qui était déjà suivi (modified-time-travel.txt), un fichier modifié et ajouté à la staging area (staged-time-travel.txt) et un fichier modifié mais ignoré (ignored-time-travel).

10. Exécutez git stash et observez le contenu des quatre fichiers. Quelles sont les modifications qui ont disparu et celles qui sont restées ?

11. Exécutez git stash pop pour récupérer toutes vos modifications.

12. Exécutez git stash -u et observez le contenu des quatre fichiers. Quelles sont les modifications qui ont disparu et celles qui sont restées ?

13. Exécutez git stash pop pour récupérer toutes vos modifications.

14. Cette fois, exécutez git stash -a et observez le contenu des quatre fichiers. Quelles sont les modifications qui ont disparu et celles qui sont restées ?

15. Exécutez git stash pop pour récupérer toutes vos modifications.

Maintenant, vous devez savoir quelles modifications sont enregistrées dans la pile de git stash.

16. Exécutez git checkout <ancien commit hash> et observez le message d’erreur.

17. Add, commit et push toutes vos modifications.

Reset¶

Le voyage dans le temps nous rend parfois nostalgiques d’un meilleur passé.
Malheureusement, nous ne pouvons que l’observer avec une tête détachée.
Si seulement nous pouvions changer la réalité et réinitialiser...

1. Créez un fichier reset.txt contenant une ligne de votre choix, puis add et commit sans push.

2. Ajoutez une deuxième ligne à reset.txt, puis add et commit sans push.

3. Observez git graph et git status.

4. Exécutez git reset HEAD~1 pour supprimer le dernier commit.

5. Observez git graph, git status et le contenu de reset.txt.

6. Add et commit sans push vos changements encore une fois. Puis faites des modifications dans reset.txt sur les lignes suivantes en effectuant un commit différent sans push pour chaque ligne.

Maintenant, vous devez avoir plusieurs commits à la suite qui modifient le contenu de reset.txt.

7. Choisissez un commit dans le passé (après la création de reset.txt) et exécutez git reset <commit hash>. Puis observez git graph et git status.

8. Effectuez de nouveau quelques commits en modifiant reset.txt sans push.

9. Exécutez git reset --soft avec HEAD~<nombre> ou <commit hash> et observez git graph et git status. Quelle est la différence entre --soft et le comportement par défaut de reset ?

10. Refaites des commits sans push.

11. Exécutez git reset --hard avec HEAD~<nombre> ou <commit hash> et observez git graph et git status. Quelle est la différence ?

Nous insistons sur le fait que les commits et suppressions doivent être faits localement avant d’être poussés vers le Remote Repo. Pourquoi ?

Est-ce que cela veut dire qu’un commit synchronisé ne peut jamais être “annulé” ? Nous allons voir comment annuler un commit qui est déjà sur le Remote Repo.

12. Add, commit et push toutes vos modifications.

Revert¶

Et je croyais pouvoir modifier la réalité...
Alors que ce n’est que ma réalité...
Comment puis-je annuler mes commits erronés ?
Si je les ai déjà partagés avec le monde entier.

1. Créez un fichier revert.txt avec une ligne de texte et effectuez un commit avec push.

2. Ajoutez une deuxième ligne à revert.txt et effectuez un commit avec push.

Imaginons que la deuxième ligne ajoutée soit une erreur. Nous allons revert ce commit tout en conservant l’historique.

3. Exécutez git revert HEAD. Entrez un message dans l’éditeur, comme pour un message de commit.

4. Vérifiez le contenu de revert.txt, git status et git graph.

5. Expérimentez avec un nouveau commit et git revert HEAD --no-edit, puis vérifiez le contenu de revert.txt, git status et git graph.

6. Effectuez au moins trois changements dans revert.txt avec add, commit et push pour chaque ligne séparément.

Nous pouvons également effectuer un revert de plusieurs commits. Chaque commit annulé sera accompagné d’un commit de revert.

7. Exécutez git revert HEAD~3..HEAD --no-edit pour revert les trois derniers commits. Vérifiez le contenu de revert.txt, git status et git graph.

8. Expérimentez avec plusieurs commits puis git revert -n HEAD~3..HEAD et git commit -m "<message>", tout en vérifiant le contenu de revert.txt, git status et git graph.

Vu que vous ne supprimez aucun commit mais que vous effectuez de nouveaux commits qui annulent les anciens, il n’y a pas de risque pour l’historique du Remote Repo.

9. Vérifiez que votre dépôt est bien propre. Revenez aux objectifs et cochez les points que vous avez maîtrisés. Entraînez-vous sur les commandes et les notions que vous n’avez pas encore bien comprises. Faites appel à votre encadrant si besoin.