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

1. Débuter : cloner le projet

Commençons par ce que nous avions laissé dans la leçon précédente. Vous avez un repository créé sur GitHub, et maintenant il faut obtenir 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 la fenêtre de démarrage, choisissez Clone Repository ou Get from VCS.

Étape 2. Dans la fenêtre qui s'ouvre, collez l'URL de votre repository. C'est pratique si vous clonez le repository de quelqu'un d'autre. L'URL se copie depuis la page du repository sur GitHub.

Si vous clonez votre propre repository (notre cas), le plus simple est de vous connecter à votre compte GitHub directement depuis l'IDE. Pour ça, choisissez l'option Log in to GitHub. Votre IDE ouvrira le navigateur pour l'authentification.

Sur la page ouverte, cliquez sans hésiter sur le bouton vert Authorize JetBrains. Après ça vous pourrez choisir vos repositories directement dans la liste de l'IDE. Sélectionnez le projet voulu et cliquez sur Clone.

Étape 3. Votre IDE va demander si vous faites confiance à ce projet. Comme c'est votre propre repository, cliquez sur Trust Project.

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

L'antivirus Windows peut avertir que l'IDE tente d'exécuter des actions inconnues. Comme on va créer et lancer des programmes, il faut permettre à l'IDE de fonctionner sans restrictions. Cliquez sur le bouton «Automatically», pour que l'IDE ajoute elle-même les dossiers nécessaires aux exceptions de l'antivirus.

2. Sauvegarder les changements : Commit

commit — c'est un "instantané", ou l'état sauvegardé de votre projet à un moment donné. Pensez-y comme à un point de sauvegarde dans un jeu : vous pouvez toujours y revenir si quelque chose tourne mal. Chaque commit a un identifiant unique et un message décrivant les changements.

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

Histoire des commits. Chaque nouveau commit se construit sur le précédent, créant la chronologie du projet.

Étape 1. Faites des modifications.

Si vous avez cloné un repository fraîchement créé, il contiendra seulement un fichier — README.md

Ouvrez le fichier README.md et ajoutez la description de votre projet. Dès que vous commencez à éditer le fichier, l'IDE mettra en évidence 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 sauvegardés dans Git. L'IDE ajoutera une ligne verte là où vous avez fait des modifications.

Étape 2. Ouvrez la fenêtre Commit.

À gauche de l'IDE il y a un onglet Commit. En l'ouvrant vous verrez tous les changements prêts à être sauvegardés. Pour le tout premier commit, cette fenêtre mérite une attention particulière.

Décomposons ce que nous voyons :

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

Une question peut se poser : faut-il ajouter tous ces fichiers système dans le repository ?

La bonne nouvelle, c'est que lorsque nous avons créé le repository sur GitHub, nous avons choisi un template .gitignore. Ce fichier contient déjà des règles disant à Git d'ignorer certains dossiers ou fichiers inutiles. Mais on en reparlera plus en détail à la fin de la leçon.

Pour l'instant 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. Faire le commit.

Cliquez sur le bouton Commit. Voilà ! Vous avez sauvegardé un "instantané" de votre projet dans le repository local. Le fichier redeviendra de couleur normale.

3. Envoyer les changements sur GitHub : Push

Vos commits sont pour l'instant stockés seulement sur votre ordinateur. Pour les partager avec l'équipe ou les sauvegarder en lieu sûr, il faut les envoyer sur le remote repository GitHub.

        sequenceDiagram
        participant Répository local (Votre ordinateur)
        participant Répository distant (GitHub)

        note over Répository local (Votre ordinateur): Vous avez fait un ou plusieurs commits.
Ils existent seulement ici.

        Répository local (Votre ordinateur) ->> Répository distant (GitHub): git push (envoyer les commits)

        note over Répository distant (GitHub): Vos commits sont copiés
et sauvegardés de façon fiable sur le serveur.
    

Étape 1. Cliquez sur le bouton Push.

En haut à droite 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 va s'ouvrir où vous verrez tous les commits prêts à être envoyés. C'est votre dernière chance de vérifier que vous envoyez bien 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 un push réussi, ouvrez la page de votre repository sur GitHub. Vous verrez que vos changements y sont apparus.

4. Panneau de contrôle Git

Votre IDE a un menu spécial Git dans la barre supérieure. C'est votre centre de gestion des versions. Voyons rapidement les éléments clés.

• Commit : ouvre la fenêtre connue pour sauvegarder les changements.
• Push : ouvre la fenêtre pour envoyer vos commits sur GitHub.
• Update Project : fonction très importante. Elle télécharge les changements récents des autres membres de l'équipe (effectue git pull). Lancez-la chaque matin avant de commencer à travailler !
• Branches : ouvre la fenêtre de gestion des branches. On détaillera ça dans la prochaine leçon.
• Show Git Log : affiche tout l'historique des commits de votre projet. Votre machine à remonter le temps personnelle.

5. Utiliser les fichiers .gitignore

Si vous avez ajouté des fichiers système au projet et que vous ne voulez pas qu'ils se retrouvent accidentellement dans le repository, vous pouvez les exclure. Pour ça il y a un fichier nommé .gitignore. C'est très pratique quand le projet contient des fichiers qu'on ne veut pas versionner (par exemple des fichiers temporaires, des logs, des mots de passe).

Étape 1. Commencez par créer le fichier dans le répertoire du projet, ou créez le fichier que vous voulez ignorer. Par exemple, notes.txt. Après la création, cliquez sur Cancel si l'IDE propose de l'ajouter à Git.

Étape 2. Faites un clic droit sur le fichier créé dans la fenêtre "Project". Allez dans Git --> Add to .gitignore --> Add to .gitignore. Cette option ajoute le fichier sélectionné dans le .gitignore à la racine de votre projet.

Si vous n'avez pas encore de fichier .gitignore, l'IDE proposera de le créer. Acceptez.

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

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

N'oubliez pas de committer le fichier .gitignore lui-même dans le repository et d'envoyer les changements sur GitHub, afin que tous les membres du projet utilisent les mêmes règles d'ignorance.

Exclusion de fichiers locaux : .git/info/exclude

En plus du fichier .gitignore, qui sert à exclure des fichiers pour tous les utilisateurs du projet, Git permet d'avoir des règles locales d'ignorance dans le fichier .git/info/exclude. Elles ne seront pas committées dans le repository et s'appliqueront seulement à 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 contrôle de version, mais qui sont spécifiques à votre environnement.

Important ! Les règles locales d'ignorance n'agissent que pour votre copie locale du repository.

Et si j'ai déjà committé ?

.gitignore n'ignore que les nouveaux fichiers non suivis. Si vous avez déjà committé un fichier, il fait partie de l'historique du repository, et Git continuera à le suivre même si vous l'ajoutez dans .gitignore. Pour ces cas il existe une commande pour le terminal : git rm --cached <file>. Mais il faudra en lire plus séparément.

Règles pour .gitignore

Dans le fichier .gitignore on indique 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 caractère #.

Motifs :

• * — remplace n'importe quel nombre de caractères. Par exemple, *.log ignore tous les fichiers avec l'extension .log.
• / — à la fin du pattern signifie un dossier. Par exemple, logs/ ignore tout le contenu du dossier logs.
• ! — au début de la ligne inverse la règle. Par exemple, si vous avez la règle *.log, mais que vous voulez 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.

Exemple de fichier .gitignore

# Code compilé
/bin/
/obj/

# Fichiers temporaires
*.tmp
*.swp

# Logs
*.log

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

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

Templates prêts à l'emploi

Vous n'avez pas besoin d'écrire ces fichiers depuis zéro. Il existe des templates vérifiés par la communauté :

1. La 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.