Maîtriser les fichiers et la zone de transit

Introduction

Bon retour parmi nous, futur voyageur du temps ! Il est maintenant temps de perfectionner vos compétences sur Git et d'explorer l'univers fascinant de la zone de transit (staging area).

Dans cet atelier, nous allons approfondir les capacités de gestion de fichiers de Git. Vous apprendrez à ajouter et supprimer des fichiers de votre projet, à ignorer les fichiers que vous ne souhaitez pas suivre, à examiner vos modifications avant de les valider, et même à annuler des changements en cas d'erreur. Ces compétences reviennent à améliorer votre machine à remonter le temps : elles vous offriront plus de contrôle et de flexibilité lors de votre navigation dans l'historique de votre projet.

À la fin de cet atelier, vous aurez une meilleure compréhension de la zone de transit de Git et de la manière dont elle vous aide à créer des commits plus organisés et plus pertinents. Alors, lançons nos terminaux et embarquons pour ce voyage passionnant !

Configuration de votre espace de travail

Commençons par créer un nouveau répertoire pour cet atelier. Ouvrez votre terminal et saisissez les commandes suivantes :

cd ~/project
mkdir git-staging-lab
cd git-staging-lab
git init

Ces commandes créent un nouveau dossier nommé git-staging-lab, vous y déplacent, puis initialisent un nouveau dépôt Git.

Maintenant, créons un script Python simple pour travailler :

echo "print('Hello, Git!')" > hello.py

Cette commande crée un fichier nommé hello.py contenant une simple instruction d'affichage en Python.

Ajout de fichiers à la zone de transit

Maintenant que nous avons notre fichier hello.py, ajoutons-le à la zone de transit. La zone de transit est comme une zone de préparation où vous rassemblez toutes les modifications que vous souhaitez inclure dans votre prochain commit.

Exécutez la commande suivante :

git add hello.py

Cette commande indique à Git de commencer à suivre le fichier hello.py et de l'inclure dans la prochaine validation.

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

git status

Vous devriez voir un résultat similaire à celui-ci :

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.py

Ce message nous indique que hello.py est désormais dans la zone de transit, prêt à être validé.

Pourquoi avons-nous besoin d'une zone de transit ? Imaginez que vous préparez votre valise pour un voyage. La zone de transit est comme votre valise ouverte : vous pouvez y ajouter des objets (vos modifications), en retirer si vous changez d'avis, et quand vous êtes satisfait du contenu, vous fermez la fermeture éclair (vous effectuez le commit). Cela vous permet de sélectionner avec soin ce qui entre dans chaque commit, rendant l'historique de votre projet plus clair et structuré.

Ignorer des fichiers avec .gitignore

Il arrive que certains fichiers ne doivent pas être suivis par Git, comme les fichiers temporaires ou les informations sensibles. Git vous permet d'ignorer ces fichiers à l'aide d'un fichier spécial nommé .gitignore.

Créons un fichier .gitignore :

echo "*.log" > .gitignore

Cette commande crée un fichier .gitignore qui ordonne à Git d'ignorer tout fichier ayant l'extension .log.

Créons maintenant un fichier de log pour tester notre configuration :

echo "This is a log file" > debug.log

Vérifiez l'état de votre dépôt :

git status

Vous constaterez que debug.log n'apparaît pas dans la liste, contrairement au fichier .gitignore :

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore

Le fichier .gitignore est un outil très puissant. Il peut ignorer des fichiers spécifiques, des répertoires entiers ou utiliser des modèles (patterns) pour exclure des fichiers correspondant à certains critères. C'est extrêmement utile dans les projets réels pour écarter les fichiers de compilation, les caches ou les fichiers de configuration locale qui ne doivent pas faire partie du dépôt partagé.

Ajoutons et validons nos modifications :

git add .gitignore
git commit -m "Initial commit with hello.py and .gitignore"

Visualiser les modifications avec git diff

À mesure que votre projet évolue, vous souhaiterez souvent examiner vos modifications avant de les valider. Git propose une commande puissante pour cela : git diff.

Modifions notre fichier hello.py :

echo "print('Hello, Git! Welcome to the staging area.')" > hello.py

Utilisons maintenant git diff pour voir ce qui a changé :

git diff

Vous devriez voir un résultat de ce type :

diff --git a/hello.py b/hello.py
index ed51d3f..1385fe3 100644
--- a/hello.py
+++ b/hello.py
@@ -1 +1 @@
-print('Hello, Git!')
+print('Hello, Git! Welcome to the staging area.')

Cet affichage montre précisément ce qui a été modifié. La ligne précédée d'un - indique ce qui a été supprimé, et la ligne avec un + montre ce qui a été ajouté.

git diff est comparable au journal de bord d'une machine à remonter le temps. Il vous permet de voir les changements exacts effectués, ce qui est crucial pour se remémorer son travail ou réviser le code avant un commit. Une autre variante utile est git diff --staged, qui affiche les modifications déjà indexées (dans la zone de transit) mais pas encore validées.

Appuyez sur q pour quitter la vue git diff.

Retirer des modifications de la zone de transit

Parfois, vous pouvez ajouter un fichier à la zone de transit par erreur ou changer d'avis. Git permet de retirer très facilement des modifications de l'index.

Tout d'abord, ajoutons nos modifications de hello.py à la zone de transit :

git add hello.py

Supposons maintenant que nous ne voulions plus inclure ces changements dans le prochain commit. Nous pouvons "désindexer" le fichier à l'aide de la commande git restore :

git restore --staged hello.py

Vérifions le statut :

git status

Vous verrez que hello.py est maintenant listé sous "Changes not staged for commit" (Modifications non indexées pour la validation) au lieu de "Changes to be committed".

Cette capacité à déplacer des fichiers vers ou hors de la zone de transit vous offre un contrôle granulaire sur vos commits. C'est comme pouvoir faire et défaire votre valise autant de fois que nécessaire avant le départ effectif.

Résumé

Félicitations, explorateur Git ! Vous venez de franchir une nouvelle étape dans la maîtrise du contrôle de version. Récapitulons ce que vous avez appris dans cet atelier :

1. Comment ajouter des fichiers à la zone de transit avec git add.
2. Comment ignorer les fichiers inutiles à l'aide de .gitignore.
3. Comment examiner les modifications de vos fichiers avant de valider avec git diff.
4. Comment retirer des modifications de la zone de transit avec git restore --staged.

Ces compétences vous donnent beaucoup plus de contrôle sur votre flux de travail. La zone de transit, en particulier, est une fonctionnalité puissante qui vous permet de construire des commits cohérents en sélectionnant soigneusement les changements à inclure.

Voici pourquoi ces notions sont essentielles :

1. Commits sélectifs : La zone de transit permet de ne valider qu'une partie de vos changements, facilitant la création de commits petits et ciblés.
2. Propreté du dépôt : Le fichier .gitignore maintient votre projet propre en excluant les fichiers qui n'ont pas besoin d'être versionnés.
3. Révision du code : git diff vous permet de double-vérifier vos modifications, aidant à détecter les erreurs rapidement.
4. Flexibilité : La possibilité de désindexer des fichiers vous donne la liberté de changer d'avis, rendant l'utilisation de Git beaucoup moins intimidante.

Au fil de votre progression avec Git, ces compétences deviendront indispensables. Elles constituent le socle d'une gestion de projet avancée, vous permettant de piloter des développements complexes avec aisance.

N'oubliez pas que la maîtrise de Git vient avec la pratique. N'ayez pas peur d'expérimenter et de faire des erreurs, c'est ainsi que l'on apprend ! Continuez à explorer, continuez à valider vos changements, et regardez vos projets évoluer.

Votre prochaine aventure dans le monde de Git approche à grands pas. Restez curieux et bon code !