Cycle quotidien du développeur : Commit, Push et .gitignore

1. Démarrage : clonage du projet

Commençons là où nous nous sommes arrêtés lors de la leçon précédente. Vous avez un dépôt créé sur GitHub et vous devez maintenant en récupérer une copie locale sur votre ordinateur pour commencer à travailler. Ce processus s’appelle le clonage.

Étape 1. Lancez votre IDE. Si un projet est ouvert, fermez-le via File -> Close Project. Dans l’écran d’accueil, choisissez Clone Repository ou Get from VCS.

Étape 2. Dans la fenêtre qui s’ouvre, collez l’URL de votre dépôt. Cette méthode est utile si vous clonez le dépôt de quelqu’un. L’URL peut être copiée depuis la page du dépôt sur GitHub.

Si vous clonez votre propre dépôt (notre cas), le plus simple est de vous connecter à votre compte GitHub directement depuis l’IDE. Pour cela, choisissez l’option Log in to GitHub. Votre IDE ouvrira le navigateur pour l’autorisation.

Sur la page qui s’ouvre, cliquez sans hésiter sur le bouton vert Authorize JetBrains. Après cela, vous pourrez choisir vos dépôts directement dans la liste de l’IDE. Sélectionnez le projet souhaité et cliquez sur Clone.

Étape 3. Votre IDE vous demandera si vous faites confiance à ce projet. Comme il s’agit de votre propre dépôt, cliquez sur Trust Project.

Étape 4. Configuration de l’antivirus (pour les utilisateurs Windows)

L’antivirus Windows peut avertir que l’IDE tente d’effectuer des actions qui lui sont inconnues. Comme nous allons créer et exécuter des programmes, nous devons autoriser l’IDE à fonctionner sans restrictions. Cliquez sur le bouton « Automatically », afin que l’IDE ajoute elle-même les dossiers nécessaires aux exclusions de l’antivirus.

2. Enregistrement des modifications : Commit

Un commit est un « instantané », ou l’état enregistré de votre projet à un moment donné. Considérez-le comme un point de sauvegarde dans un jeu : vous pouvez toujours y revenir si quelque chose se passe mal. Chaque commit possède un identifiant unique et un message décrivant les modifications effectuées.

        gitGraph
        commit id: "Initial commit"
        commit id: "Add user authentication"
        commit id: "Fix login button bug"
        commit id: "Refactor database connection"
    

Historique des commits. Chaque nouveau commit est construit sur la base du précédent, créant une chronologie de l’évolution du projet.

Étape 1. Apportez des modifications.

Si vous avez cloné un dépôt fraîchement créé, il ne contiendra qu’un seul fichier — README.md

Ouvrez le fichier README.md et ajoutez-y la description de votre projet. Dès que vous commencez à modifier le fichier, l’IDE mettra en surbrillance son nom en bleu dans le panneau du projet. Cela signifie que le fichier a été modifié, mais que les changements ne sont pas encore enregistrés dans Git. L’IDE ajoutera une ligne verte là où vous avez apporté des modifications.

Étape 2. Ouvrez la fenêtre Commit.

À gauche dans l’IDE se trouve l’onglet Commit. En l’ouvrant, vous verrez toutes les modifications prêtes à être enregistrées. Pour le tout premier commit, cette fenêtre mérite une attention particulière.

Voyons ce que nous avons sous les yeux :

• Changes : ici se trouvent les fichiers déjà suivis par Git, mais qui ont été modifiés. Dans notre cas, c’est README.md, dans lequel nous avons ajouté le plan du projet.
• Unversioned Files : ce sont les nouveaux fichiers que Git voit dans le dossier du projet, mais qu’il ne suit pas encore.

Une question peut se poser : faut-il ajouter tous ces fichiers système au dépôt ?

La bonne nouvelle, c’est que lorsque nous avons créé le dépôt sur GitHub, nous avons choisi un modèle .gitignore. Ce fichier contient déjà des règles indiquant à Git d’ignorer les dossiers ou fichiers inutiles. Mais nous en parlerons plus en détail à la fin de la leçon.

En attendant, notre tâche pour le premier commit est d’ajouter tous les fichiers principaux du projet à l’historique et d’écrire le message du commit.

Étape 3. Faites le commit.

Cliquez sur le bouton Commit. Et voilà ! Vous avez enregistré un « instantané » de votre projet dans le dépôt local. Le fichier redevient de couleur normale.

3. Envoi des modifications sur GitHub : Push

Vos commits sont pour l’instant stockés uniquement sur votre ordinateur. Pour les partager avec l’équipe ou les sauvegarder en lieu sûr, vous devez les envoyer vers le dépôt distant sur GitHub.

        sequenceDiagram
        participant Dépôt local (votre ordinateur)
        participant Dépôt distant (GitHub)

        note over Dépôt local (votre ordinateur): Vous avez effectué un ou plusieurs commits.
Ils n’existent qu’ici.

        Dépôt local (votre ordinateur) ->> Dépôt distant (GitHub): git push (envoyer les commits)

        note over Dépôt distant (GitHub): Vos commits ont été copiés
et sont stockés en toute sécurité sur le serveur.
    

Étape 1. Cliquez sur le bouton Push.

Dans le coin supérieur droit de l’IDE se trouve une flèche verte vers le haut — c’est le bouton Push. Cliquez dessus.

Étape 2. Vérifiez et confirmez.

Une fenêtre s’ouvrira, où vous verrez tous les commits prêts à être envoyés. C’est votre dernière chance de vérifier que vous envoyez exactement ce qu’il faut. Cliquez sur Push.

Si tout s’est bien passé, vous verrez les messages : Pushed commits to origin/main. Create pull request

Étape 3. Vérifiez le résultat sur GitHub.

Après l’envoi réussi, ouvrez la page de votre dépôt sur GitHub. Vous verrez que vos modifications y sont apparues.

4. Panneau de contrôle Git

Votre IDE possède un menu spécial Git, que vous pouvez trouver dans la barre supérieure. C’est votre centre de gestion de versions. Découvrons rapidement ses éléments clés.

• Commit : ouvre la fenêtre que nous connaissons déjà pour enregistrer les modifications.
• Push : ouvre la fenêtre pour envoyer vos commits sur GitHub.
• Update Project : une fonctionnalité très importante. Elle télécharge les modifications récentes des autres membres de l’équipe (exécute git pull). Cliquez dessus chaque matin avant de commencer à travailler !
• Branches : ouvre la fenêtre de gestion des branches. Nous l’étudierons en détail dans la prochaine leçon.
• Show Git Log : affiche tout l’historique des commits de votre projet. Votre machine à remonter le temps personnelle.

5. Utilisation des fichiers .gitignore

Si vous avez ajouté des fichiers systèmes à votre projet et que vous ne souhaitez pas qu’ils se retrouvent accidentellement dans le dépôt, vous pouvez les ajouter aux exclusions. Pour cela, il existe un fichier nommé .gitignore. C’est très pratique lorsque le projet contient des fichiers qui ne doivent pas être stockés dans le système de contrôle de versions (par exemple, des fichiers temporaires, des journaux, des mots de passe).

Étape 1. Commencez par créer dans le répertoire du projet un fichier que vous souhaitez ignorer. Par exemple, notes.txt. Après avoir créé le fichier, cliquez sur Cancel si l’IDE propose de l’ajouter à Git.

Étape 2. Cliquez avec le bouton droit sur le fichier créé dans la fenêtre « Project ». Allez à Git --> Add to .gitignore --> Add to .gitignore. Cette option ajoute le fichier sélectionné au fichier .gitignore à la racine de votre projet.

S’il n’y avait pas encore de fichier .gitignore, l’IDE vous proposera de le créer. Acceptez.

Étape 3. Votre IDE ajoutera automatiquement le nom du fichier à .gitignore.

Après l’ajout à .gitignore, les fichiers ignorés s’afficheront en gris ou en brun. Lors d’une tentative de commit, ces fichiers seront ignorés. Le dossier .idea peut être ignoré.

N’oubliez pas de committer le fichier .gitignore lui-même dans le dépôt et d’envoyer les modifications sur GitHub, afin que tous les membres du projet utilisent les mêmes règles d’ignorance des fichiers.

Exclusion locale de fichiers : .git/info/exclude

Outre le fichier .gitignore, utilisé pour exclure des fichiers pour tous les utilisateurs du projet, Git permet de créer des règles d’ignorance locales dans le fichier .git/info/exclude. Elles ne seront pas commitées dans le dépôt et ne s’appliqueront qu’à votre copie locale du projet.

Cela peut être utile, par exemple, pour ignorer des fichiers créés par votre IDE qui ne doivent pas entrer dans le système de contrôle de versions, mais qui vous sont spécifiques.

Important ! Les règles d’ignorance locales ne s’appliquent qu’à votre copie locale du dépôt.

Et si j’ai déjà fait un commit ?

.gitignore ignore uniquement les nouveaux fichiers qui ne sont pas encore suivis. Si vous avez déjà commité un fichier, il se trouve dans l’historique du dépôt et Git continuera à le suivre, même si vous l’ajoutez à .gitignore. Pour ces situations, il existe une commande à exécuter dans le terminal : git rm --cached <file>. Mais il faudra la consulter séparément.

Règles pour .gitignore

Le fichier .gitignore contient des motifs de noms de fichiers et de dossiers que Git doit ignorer.

Les lignes vides sont ignorées. Pour ajouter un commentaire, commencez la ligne par le symbole #.

Modèles :

• * — remplace n’importe quelle suite de caractères. Par exemple, *.log ignore tous les fichiers avec l’extension .log.
• / — en fin de motif indique un répertoire. Par exemple, logs/ ignore tout le contenu du dossier logs.
• ! — en début de ligne inverse la règle. Par exemple, si vous avez la règle *.log mais que vous souhaitez suivre important.log, ajoutez la ligne !important.log.
• ** — correspond à n’importe quel nombre de dossiers imbriqués. Par exemple, **/temp ignore les dossiers temp à n’importe quel niveau d’imbrication.

Exemple de fichier .gitignore

# Code compilé
/bin/
/obj/

# Fichiers temporaires
*.tmp
*.swp

# Journaux
*.log

# Dossiers créés par l’IDE
.idea/
*.user
*.suo

# Environnements virtuels et dépendances
/venv/
/node_modules/

Modèles prêts à l’emploi

Vous n’avez pas besoin d’écrire ces fichiers à partir de zéro. Il existe des modèles prêts à l’emploi, validés par la communauté :

1. Collection .gitignore de GitHub pour différents langages et frameworks : https://github.com/github/gitignore.
2. gitignore.io — un service web pratique qui génère un fichier .gitignore adapté à vos technologies.