Comprendre les fondamentaux de Git pour gérer efficacement le code source et travailler en équipe.

Module 2 : Gestion de code source et workflows

2.1. Git et ses bases

Objectif : Comprendre les fondamentaux de Git pour gérer efficacement le code source et travailler en équipe.

Cours : Commandes Git essentielles

Initialiser et cloner un dépôt :

Initialiser un dépôt local :
```
git init
```
Cloner un dépôt distant :
```
git clone URL_DU_DEPOT
```

Effectuer des modifications :

Ajouter des fichiers au suivi :
```
git add chemin_du_fichier
```
Vérifier l’état des modifications :
```
git status
```
Créer un commit :
```
git commit -m "Message du commit"
```

Travailler avec des branches :

Lister les branches :
```
git branch
```
Créer une nouvelle branche :
```
git branch nom_branche
```
Changer de branche :
```
git checkout nom_branche
```
Fusionner une branche :
```
git merge nom_branche
```

Résoudre des conflits :

Lorsque des conflits surviennent, Git indique les fichiers en conflit. Modifiez-les pour résoudre les problèmes, puis :
```
git add fichier_modifié
git commit
```

Collaborer avec un dépôt distant :

Vérifier les changements :
```
git fetch
```
Récupérer et fusionner les modifications :
```
git pull
```
Envoyer des modifications :
```
git push
```

Exercice pratique 1 : Cloner et organiser le dépôt TaskManagerPro

Cloner le dépôt :

Clonez le dépôt TaskManagerPro :

git clone https://github.com/TechNovaCorp/TaskManagerPro.git

Vérifier les branches existantes :
- Allez dans le répertoire cloné :
```
cd TaskManagerPro
```
- Listez les branches :
```
git branch -a
```
Créer une branche de développement :
- Créez et basculez sur une nouvelle branche nommée develop :
```
git checkout -b develop
```
Soumettre des modifications :
- Modifiez un fichier (par exemple, ajoutez un commentaire dans le README).
- Ajoutez les modifications et créez un commit :
```
git add README.md
git commit -m "Ajout d'un commentaire au README"
```
- Poussez la branche develop vers le dépôt distant :
```
git push origin develop
```

2.2. Workflows collaboratifs

GitFlow :

Un workflow Git populaire pour structurer les branches :

Branches principales :
- main : contient le code en production.
- develop : contient le code en cours de développement.
Branches secondaires :
- feature/* : pour le développement de nouvelles fonctionnalités.
- hotfix/* : pour corriger des bugs critiques en production.

Trunk-Based Development :

Approche minimaliste :

Les développeurs travaillent directement sur la branche principale (exemple : main) et poussent des modifications en continu.

Exercice pratique 2 : Mettre en place un workflow GitFlow

Configurer les branches principales :

Créez une branche main et develop si elles n’existent pas :

git checkout -b main
git push origin main
git checkout -b develop
git push origin develop

Développer une nouvelle fonctionnalité :
- Créez une branche feature/ma_nouvelle_fonctionnalite à partir de develop :
```
git checkout -b feature/ma_nouvelle_fonctionnalite develop
```
- Apportez des modifications, puis créez un commit :
```
git add fichier
git commit -m "Ajout de ma nouvelle fonctionnalité"
```
- Fusionnez la branche feature dans develop :
```
git checkout develop
git merge feature/ma_nouvelle_fonctionnalite
```
- Poussez les modifications :
```
git push origin develop
```

Corriger un bug critique :

Créez une branche hotfix/correction_bug à partir de main :
```
git checkout -b hotfix/correction_bug main
```

Apportez une correction, puis créez un commit :

git add fichier
git commit -m "Correction du bug critique"

Fusionnez la branche hotfix dans main et develop :

git checkout main
git merge hotfix/correction_bug
git push origin main

git checkout develop
git merge hotfix/correction_bug
git push origin develop

Gestion de code source et workflows