MODULE 7 – GIT AVANCÉ (OPTIONNEL) | Faites entrer GIT

Code Opération : OMBRE-ET-VERSIONS-7

OBJECTIFS :

Réécrire l’histoire de manière propre et plausible.
Mettre de côté des travaux sensibles sans les commettre.
Marquer des points stratégiques dans la chronologie.
Gérer des sous-projets à l’intérieur d’une opération principale.

1. git rebase – RÉÉCRIRE LA LIGNE DU TEMPS
Contrairement à merge qui fusionne, rebase rejoue vos commits sur une autre base.

git checkout feature-branch
git rebase main

Vos commits de feature-branch sont rejoués après les derniers commits de main.
Résultat : un historique linéaire, plus propre.
DANGER : Ne jamais rebaser des commits déjà partagés (déjà poussés). C’est une réécriture d’histoire qui brise la synchro des autres agents.

2. REBASE INTERACTIF – SCULPTER L’HISTOIRE
Un outil de précision.

git rebase -i HEAD~3

Ouvre un éditeur avec une liste de vos 3 derniers commits et des actions possibles :

pick : garde le commit tel quel.
reword : change le message du commit.
edit : permet de modifier le contenu du commit.
squash : fusionne le commit avec le précédent.
drop : supprime le commit.
C’est comme nettoyer un enregistrement audio : supprimer les bruits, réorganiser les dialogues.

3. git stash – CACHER DES PREUVES TEMPORAIREMENT
Vous êtes en plein travail, on vous assigne une urgence.
Plutôt que committer à moitié fini :

git stash

Vos modifications disparaissent du working tree, mises de côté dans une pile.
Pour les récupérer plus tard :

git stash pop

pop réapplique et supprime du stash.
apply réapplique mais garde une copie dans le stash.
git stash list montre toutes vos caches.

4. TAGS – MARQUER DES VERSIONS OFFICIELLES
Un tag est un repère immobile dans l’histoire.
Pour marquer une version (ex: v1.0) :

git tag -a v1.0 -m "Version stable, phase 1 terminée"
git push origin v1.0

Les tags ne bougent pas. Ils désignent un commit précis pour toujours.
Utile pour les releases, les déploiements, les points de restauration sûrs.

5. SUBMODULES – DES PROJETS DANS LE PROJET
Parfois, une opération nécessite d’intégrer une autre opération autonome.
Ajouter un sous-module :

git submodule add https://github.com/autre/repo.git sous-dossier

Cela crée un lien vers un commit spécifique de l’autre dépôt.
Attention : cloner un projet avec submodules nécessite :

git clone --recursive https://votre-depot.git

Ou après un clone normal :

git submodule update --init --recursive

Les submodules sont puissants, mais fragiles. À n’utiliser qu’en connaissance de cause.

TRAVAUX PRATIQUES – SCÉNARIO : NETTOYAGE ET MARQUAGE
Opération "Révision Profonde"

Partie 1 : Nettoyage d’historique avec rebase interactif

Créez une branche experiment. Faites 3 commits factices :

echo "test1" >> log.txt && git add . && git commit -m "Premier test"
echo "test2" >> log.txt && git add . && git commit -m "Deuxième test"
echo "test3" >> log.txt && git add . && git commit -m "Troisième test"

Lancez un rebase interactif sur les 3 derniers commits :
```
git rebase -i HEAD~3
```
Dans l’éditeur :
- Changez le deuxième commit de pick à squash.
- Changez le troisième à reword, modifiez son message en "Tests finaux".
  Sauvegardez et quittez.
Résultat : vous n’avez plus que 2 commits (le premier, et un second fusionné + renommé).

Partie 2 : Gestion de versions avec tags

Assurez-vous d’être sur main, avec un état propre.

Créez un tag annoté pour la version 0.1.0 :

git tag -a v0.1.0 -m "Version initiale de l'opération"

Ajoutez une nouvelle fonctionnalité (un fichier protocol.md vide), commitez.
Créez un tag léger pour un snapshot intermédiaire :
```
git tag v0.1.1-dev
```
Listez les tags :
```
git tag -l
```
Poussez les tags vers le distant :
```
git push origin --tags
```

FIN DU MODULE 7.
Vous maîtrisez désormais des techniques avancées pour sculpter l’histoire, cacher du travail en cours, marquer des jalons officiels, et gérer des sous-projets.
Un dernier module vous attend : les bonnes pratiques professionnelles. Là où la technique rencontre la discipline.

Rapport clos.