Usage des outils de versionnement | Exercices corrigés

Concepts & Exercices

Version_{efficace} = \frac{Historique + Collaboration + Sécurité}{Temps × Complexité}

Calcul de l'efficacité du versionnement

Initialisation

🔄

Création du dépôt

Commit

💾

Sauvegarde des modifications

Branches

/Branches

Développement parallèle

Merge

🔗

Fusion des modifications

Concepts clés :

Repository : Dossier contenant le code source et l'historique
Commit : Instantané des modifications
Branch : Ligne de développement indépendante
Remote : Dépôt distant (GitHub, GitLab)
Push/Pull : Synchronisation avec le serveur

Exercice 1

Initialisation d'un dépôt Git

Exercice 2

Gestion des commits

Exercice 3

Utilisation des branches

Exercice 4

Fusion des modifications

Exercice 5

Synchronisation avec un serveur distant

Corrigé : Exercices 1 à 3

1 Initialisation d'un dépôt

Définition :

Problème : Initialiser un dépôt Git pour un nouveau projet

Étapes d'initialisation :

Créer un répertoire pour le projet
Initialiser le dépôt Git
Configurer les identifiants
Créer le premier fichier
Effectuer le premier commit

Création du répertoire

Initialisation Git

Configuration

Premier commit

Étape 1 : Configuration globale de Git

# Configuration des identifiants utilisateur
git config --global user.name "Élève NSI"
git config --global user.email "eleve.nsi@etablissement.fr"

# Vérification de la configuration
git config --list

Étape 2 : Création du dépôt

# Création du répertoire du projet
mkdir projet-calculatrice
cd projet-calculatrice

# Initialisation du dépôt Git
git init

# Vérification de l'état du dépôt
git status

# Résultat:
# On branch main
# No commits yet
# nothing to commit (create/copy files and use "git add" to track)

Étape 3 : Premier commit

# Création du fichier README
echo "# Projet Calculatrice" > README.md
echo "Ce projet implémente une calculatrice basique en Python" >> README.md

# Ajout du fichier au suivi
git add README.md

# Vérification de l'état
git status

# Premier commit
git commit -m "Initial commit: Ajout du README"

Dépôt Git initialisé avec succès

Initialisation terminée :

Le dépôt est correctement initialisé avec un premier commit contenant le fichier README.

Règles d'initialisation :

• Configuration globale : git config --global pour les identifiants

• Initialisation : git init dans le répertoire du projet

• Commit initial : Toujours commencer par un README

2 Gestion des commits

Définition :

Problème : Gérer les commits de manière organisée et descriptive

Ajouter des fichiers

Créer un commit

Inspecter l'historique

Annuler si nécessaire

Étape 1 : Ajout de fichiers au suivi

# Création d'un fichier Python pour la calculatrice
cat > calculatrice.py << EOF
def addition(a, b):
    """Fonction pour additionner deux nombres"""
    return a + b

def multiplication(a, b):
    """Fonction pour multiplier deux nombres"""
    return a * b

# Test des fonctions
print(addition(5, 3))
print(multiplication(4, 6))
EOF

# Ajout du fichier au suivi
git add calculatrice.py

# Vérification de l'état
git status

Étape 2 : Création de commits organisés

# Commit des modifications
git commit -m "feat: Ajouter les fonctions d'addition et multiplication"

# Création d'autres modifications
echo "def soustraction(a, b):
    \"\"\"Fonction pour soustraire deux nombres\"\"\"
    return a - b" >> calculatrice.py

git add calculatrice.py
git commit -m "feat: Ajouter la fonction de soustraction"

# Vérification de l'historique
git log --oneline

Étape 3 : Inspection de l'historique

# Affichage de l'historique des commits
git log --oneline -5

# Affichage des différences entre commits
git show HEAD

# Comparaison avec le commit précédent
git diff HEAD~1

# Format personnalisé
git log --pretty=format:"%h %an %ar - %s"

Étape 4 : Annulation de commits (si nécessaire)

# Annuler le dernier commit (sans perdre les modifications)
git reset --soft HEAD~1

# Annuler le dernier commit (en perdant les modifications)
git reset --hard HEAD~1

# Annuler un commit spécifique (sans affecter les suivants)
git revert COMMIT_HASH

# Exemple de message de commit conventionnel:
# feat: nouvelle fonctionnalité
# fix: correction de bogue
# docs: modifications de documentation
# style: changements cosmétiques
# refactor: refactoring sans changement de fonctionnalité
# test: ajout de tests
# chore: tâches diverses

Gestion des commits organisée et conventionnelle

Commits bien organisés :

Les commits sont descriptifs et suivent les conventions pour une meilleure lisibilité de l'historique.

Règles de gestion des commits :

• Messages clairs : Utiliser des verbes à l'impératif

• Commits atomiques : Chaque commit représente une modification logique

• Convention : Utiliser des préfixes comme feat:, fix:, etc.

3 Utilisation des branches

Définition :

Problème : Gérer les branches pour un développement parallèle

Branches = \frac{Fonctionnalités_{simultanées}}{Développeurs}

Divergence = \frac{Commits_{différents}}{Temps_{séparation}}

Étape 1 : Création et gestion des branches

# Vérification des branches existantes
git branch

# Création d'une nouvelle branche pour une fonctionnalité
git checkout -b feature/division

# Ou en une seule commande (Git 2.23+)
git switch -c feature/division

# Liste des branches
git branch -a  # -a pour voir les branches distantes aussi

Étape 2 : Développement sur la branche

# Ajout de la fonction division
echo "def division(a, b):
    \"\"\"Fonction pour diviser deux nombres\"\"\"
    if b == 0:
        raise ValueError(\"Division par zéro impossible\")
    return a / b" >> calculatrice.py

# Ajout et commit sur la branche feature/division
git add calculatrice.py
git commit -m "feat: Ajouter la fonction de division avec gestion d'erreur"

# Vérification de l'état de la branche
git log --oneline -3

Étape 3 : Navigation entre branches

# Retour à la branche principale
git checkout main

# Ou avec la nouvelle syntaxe
git switch main

# Vérification que le fichier n'a pas encore la fonction division
cat calculatrice.py  # La fonction division n'est pas présente

# Retour sur la branche de fonctionnalité
git checkout feature/division
cat calculatrice.py  # La fonction division est présente

Étape 4 : Gestion avancée des branches

# Création d'une autre branche pour un bug fix
git checkout -b bugfix/correction-nom-fonction

# Correction dans la branche bugfix
sed -i 's/def multiplication/def multiply/g' calculatrice.py
git add calculatrice.py
git commit -m "fix: Renommer multiplication en multiply"

# Fusion de la branche de correction dans main
git checkout main
git merge bugfix/correction-nom-fonction

# Suppression de la branche de correction
git branch -d bugfix/correction-nom-fonction

# Vérification des branches existantes
git branch

Branches créées et gérées avec succès

Gestion des branches :

Les branches permettent un développement parallèle sans interférence entre les différentes fonctionnalités.

Règles de gestion des branches :

• Nommage clair : Utiliser des noms descriptifs comme feature/nom

• Brassage régulier : git merge main pour intégrer les modifications récentes

• Nettoyage : Supprimer les branches inutiles après fusion

Corrigé : Exercices 4 à 5

4 Fusion des modifications

Définition :

Problème : Fusionner des modifications de différentes branches

Fast-forward

⏩

Fusion simple

Merge-commit

🔄

Fusion avec commit

Rebase

🔀

Réécriture d'historique

Conflit

⚠️

Résolution manuelle

Étape 1 : Préparation à la fusion

# Assurer que la branche principale est à jour
git checkout main
git pull origin main  # Si travail collaboratif

# Vérification des branches
git branch -v

# Supposons que nous avons deux branches:
# main avec les commits A-B-C
# feature/division avec les commits D-E

Étape 2 : Fusion avec merge

# Basculement sur la branche principale
git checkout main

# Fusion de la branche de fonctionnalité
git merge feature/division

# Vérification de l'historique
git log --graph --oneline --all

# Résultat: main contient maintenant A-B-C-D-E-F
# où F est le commit de fusion

Étape 3 : Gestion des conflits

# Supposons un conflit dans calculatrice.py
# Lors de la fusion, Git indique:
# Auto-merging calculatrice.py
# CONFLICT (content): Merge conflict in calculatrice.py

# Contenu du fichier avec conflit:
<<<<<<< HEAD
def multiply(a, b):
    return a * b
=======
def multiplication(a, b):
    return a * b
>>>>>>> feature/division

# Résolution manuelle:
def multiply(a, b):
    return a * b

# Après résolution:
git add calculatrice.py
git commit -m "Resolve merge conflict: Keep multiply function name"

Étape 4 : Alternatives à merge

# Option 1: Rebase pour un historique linéaire
git checkout feature/division
git rebase main  # Applique les commits de feature après ceux de main
git checkout main
git merge feature/division  # Fast-forward possible

# Option 2: Squash pour regrouper les commits
git checkout main
git merge --squash feature/division  # Combine tous les commits en un seul
git commit -m "feat: Ajouter la fonction de division"

# Option 3: Suppression de la branche après fusion
git branch -d feature/division

Fusion des modifications réussie

Fusion réussie :

Les modifications de la branche de fonctionnalité ont été intégrées dans la branche principale.

Règles de fusion :

• Mise à jour préalable : git pull avant de fusionner

• Résolution des conflits : Vérifier et tester après résolution

• Choix de la stratégie : merge vs rebase selon le contexte

5 Synchronisation avec serveur distant

Définition :

Problème : Synchroniser le dépôt local avec un serveur distant

Connexion au serveur

Envoi des modifications

Récupération des modifications

Collaboration

Étape 1 : Configuration du dépôt distant

# Création d'un dépôt sur GitHub/GitLab
# Copie de l'URL HTTPS ou SSH

# Ajout du dépôt distant
git remote add origin https://github.com/utilisateur/calculatrice.git

# Vérification des dépôts distants
git remote -v

# Résultat:
# origin  https://github.com/utilisateur/calculatrice.git (fetch)
# origin  https://github.com/utilisateur/calculatrice.git (push)

Étape 2 : Première synchronisation

# Pousser la branche principale vers le serveur
git branch -M main  # Renomme la branche par défaut en main
git push -u origin main

# -u pour suivre la branche distante
# Ensuite, git push seul suffira

# Pour pousser une branche spécifique
git push origin feature/division

Étape 3 : Récupération des modifications distantes

# Récupération des modifications distantes (sans fusion)
git fetch origin

# Récupération et fusion (équivalent à fetch + merge)
git pull origin main

# Récupération et rebasage (alternative à merge)
git pull --rebase origin main

# Vérification des branches distantes
git branch -r  # branches distantes
git branch -a  # toutes les branches

Étape 4 : Workflow collaboratif

# Workflow quotidien
# 1. Récupérer les dernières modifications
git checkout main
git pull origin main

# 2. Créer une nouvelle branche de travail
git checkout -b feature/nouvelle-fonction

# 3. Faire les modifications
# ... développement ...

# 4. Commit des modifications
git add .
git commit -m "feat: Ajouter nouvelle fonctionnalité"

# 5. Pousser la branche vers le serveur
git push origin feature/nouvelle-fonction

# 6. Créer une Pull Request/Merge Request sur GitHub/GitLab

# 7. Après approbation et fusion, revenir sur main
git checkout main
git pull origin main  # Récupérer la fusion

# 8. Supprimer la branche locale
git branch -d feature/nouvelle-fonction

Synchronisation avec le serveur distante réussie

Synchronisation établie :

Le dépôt local est maintenant synchronisé avec le serveur distant pour le travail collaboratif.

Règles de synchronisation :

• Pull avant de push : Toujours récupérer les modifications avant de pousser

• Protection des branches : Utiliser des règles pour protéger la branche principale

• Communication : Coordonner les changements avec les autres collaborateurs

Cours bien détaillé

Qualité_{versionnement} = \frac{Historique_{complet} × Collaboration_{facilitée}}{Complexité_{gestion}}

Calcul de la qualité du versionnement

💾

Historique : Conservation complète des modifications.

👥

Collaboration : Travail simultané de plusieurs développeurs.

🔄

Sécurité : Sauvegarde des versions et possibilité de retour arrière.

⚡

Productivité : Accélération du développement grâce aux outils.

💡

Conseil : Utilisez des messages de commit descriptifs et conventionnels

🔍

Attention : Faites toujours un git pull avant de pousser vos modifications

⚡

Astuce : Utilisez les alias Git pour gagner du temps

📋

Méthode : Utilisez des branches pour chaque fonctionnalité

✅

Vérification : Testez toujours après une fusion de branches

Meilleures pratiques Git :

Commits atomiques : Chaque commit représente une modification logique
Messages clairs : Utiliser des verbes à l'impératif
Branches sémantiques : Noms descriptifs pour les branches
Fréquence de commit : Commiter régulièrement sans attendre la perfection
Workflow défini : Suivre un modèle de développement (Git Flow, etc.)

Règles importantes :

Ne jamais pousser directement sur la branche principale sans review
Toujours vérifier l'état du dépôt avant de commencer à travailler
Utiliser des branches pour isoler les développements
Ne pas ajouter de fichiers binaires volumineux au dépôt

Points clés à retenir :

Historique : Git conserve un historique complet de toutes les modifications
Collaboration : Permet à plusieurs développeurs de travailler simultanément
Sécurité : Possibilité de revenir à n'importe quelle version du code
Flexibilité : Branches pour développer sans impacter le code principal

Usage des outils de versionnementExercices corrigés

Usage des outils de versionnement
Exercices corrigés