Objectifs

Pratiquer Git avec les outils suivants :

  • RStudio
  • la ligne de commande
  • VS Code

Présentation de Git

Présentation de Git

  • Créé en 2005 par Linus Torvalds (créateur de Linux)
  • Logiciel libre de gestion de versions
  • Principale tâche : gérer l’évolution du contenu d’une arborescence
  • Gère les différents états d’un code au cours du temps

Comment utiliser Git ?

  • Logiciel client à installer sur le poste (installateur Git)
  • Interaction par une interface graphique ou en ligne de commande
  • Git intégré ou intégrable aux IDE (Eclipse, RStudio, VS Code…)

Du code ?

À quoi sert Git ?

À quoi sert Git ?

  • Suivi et sauvegarde des changements dans le code
  • Mise à disposition / partage
  • Mise en place des outillages logiciels (vérifications automatiques, empaquetage…)

Bénéfices en général

  • Traçabilité des modifications
  • Retour à une version antérieure, reproductibilité
  • Copie de travail locale (pour un travail hors ligne)
  • Synchronisation entre plusieurs postes, accessibilité (session 2)
  • Travail sur des questions en parallèle (session 3)

Cas d’utilisation

Pourquoi aurait-on besoin de Git ?

  • Modifier son code et vouloir faire marche arrière
  • Maintenir plusieurs versions du code
  • Comparer 2 versions du même code
  • Suivre les changements sur mes fichiers
  • Parcourir l’historique d’un bout de code

États

États (session 1)

  • Working directory : dossier de travail
  • Stage : index pour tracer les modifications qui seront validées
  • Repo : ensemble des fichiers (les vôtres et ceux de Git)
  • HEAD : pointeur identifiant le dernier commit

Premières pratiques en local

Généralement, les diapos seront construites avec 3 onglets permettant de faire le lien avec les outils suivants :

  • en ligne de commande
  • avec RStudio
  • avec VS Code

Un logo est présent sur chaque diapo pour rappeler de quel mode il s’agit.

Installation de Git

Installation des interfaces

  • Installation automatique de l’interface graphique Git-Gui (fiche aide)
  • Possibilité d’installer d’autres interfaces graphiques GUI Clients (attention à la maintenance des outils)
  • Interface client (intégrée à l’explorateur de fichiers) : tortoisegit

Important

Nous ne parlerons pas de l’interface graphique Git-Gui directement installée au moment du téléchargement de Git.

D’abord installer R :

Puis RStudio :

Paramétrage de Git

Ouvrir un terminal et saisir les commandes en les adaptant :

  • dans RStudio : Tools > Terminal > New terminal
  • dans VS Code : Terminal > New terminal
# Définir votre identité qui sera associée à vos validations Git
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
# En avance pour la Session 2, définir le nom de la branche principale en accord avec la forge et les derniers usages
git config --global init.defaultBranch main

Opérations de bases

Prérequis : disposer d’un dossier dans lequel on peut écrire.

Pour un dossier vide, on crée un dossier “mon_projet” :

cd
mkdir mon_projet

Pour un dossier contenant déjà des fichiers, on se place dans le dossier :

cd mon_projet

Prérequis : travailler dans un projet RStudio (Documentation RStudio).

Créer un projet

Ouvrir un projet existant

Prérequis : disposer d’un dossier dans lequel on peut écrire

Démarrage de VS Code sur un dossier vide :

Démarrage de VS Code sur un dossier existant :

cd mon_projet
code .

Initialisation d’un dépôt Git − Ligne de commande

Initialiser un dépôt Git “local” pour suivre les fichiers du dossier “mon_projet” :

cd mon_projet
git init .

Un dossier .git est créé dans mon_projet. C’est là que Git stocke les informations dont il a besoin.

Consulter son contenu dans un terminal

Ne pas essayer d’éditer les fichiers du dossier .git.

Initialisation d’un dépôt Git − RStudio

Lors de la création d’un projet :

Menu Tools > Version Control > Project Setup…

Choisir “git” dans le menu “Version control system”

Ou lancer la commande git init dans le terminal.

Après actualisation de RStudio, Git est désormais intégré à RStudio.

Ne pas essayer d’éditer les fichiers du dossier .git.

Initialisation d’un dépôt Git − VS Code

Dans VS Code, sur le dossier à suivre :

  • ouvrir l’outil “Source Control”
  • cliquer sur le bouton “Initialize repository”

Un dossier .git est créé, c’est là que Git stocke les informations dont il a besoin.

Contrôler en ouvrant un terminal et en vérifiant la présence d’un dossier .git.

Ne pas essayer d’éditer les fichiers du dossier .git.

Pratique

Création d’un dépôt Git local

  1. Créer un dossier “mon_projet”
  2. En choisissant votre éditeur préféré ou simplement la ligne de commande, initialiser Git sur ce dossier
  3. Parcourir l’arborescence et constater qu’un dossier .git a été créé

Consultation état du dépôt

Il est souvent très utile de faire le point sur les évolutions en cours :

  • identifier les fichiers qui ont changé
  • identifier ceux qui sont dans l’index et en attente de validation
  • vérifier la branche de développement en cours (session 3)
  • …

Il s’agit donc de connaître le statut du dépôt.

Important

Cette commande est importante à assimiler. Au moindre doute, on doit avoir le réflexe de l’utiliser !

Consultation état du dépôt

Pour vérifier l’état du dépôt :

git status

On obtient la liste :

  • des nouveaux fichiers
  • des fichiers modifiés

L’onglet Git de RStudio vous permet de connaître l’état du dépôt rattaché à votre projet :

Onglet git dans RStudio

État du .gitignore après initialisation dans RStudio

On voit dans l’interface que le fichier .gitignore n’est pas encore suivi par Git : icône orange avec un “?” et état “untracked”.

L’outil “Source Control” permet de connaître l’état du dépôt rattaché au dossier :

On voit donc que :

  • deux fichiers ont évolué depuis le dernier commit
  • le fichier mon_fichier.txt a été modifié (M)
  • le fichier un_autre_fichier.txt a été rajouté (U)

Le fichier .gitignore

Le fichier .gitignore permet de préciser quels fichiers et dossiers doivent être ignorés par Git.

Pour cela, on utilise des modèles (ou patterns) et des noms de fichiers et dossiers explicites :

*~
*.bak
*.txt
ce_fichier_a_ignorer.data
/logs/
temp/
.vscode

Il est possible de créer d’autres fichiers .gitignore dans des sous-dossiers de votre projet.

Par défaut, le fichier .gitignore est à créer à la racine de votre projet :

  • En ligne de commande, pour créer le fichier vide :
touch .gitignore
  • Avec RStudio, le .gitignore est automatiquement créé au moment de l’initialisation de Git dans le projet. Par défaut il contient les fichiers suivants :
.Rproj.user
.Rhistory
.RData
.Ruserdata
  • Avec VS Code, utiliser le menu File > New file… (MAJ+ALT+CTRL+N).

Des exemples de fichiers sont disponibles sur différents sites web, tels que

Ajouter des fichiers et leurs modifications sur le dépôt

Définition d’un commit

Un commit permet :

  • d’ajouter sur le dépôt des fichiers qui ne sont pas encore suivis,
  • d’enregistrer des modifications réalisées sur des fichiers suivis.

Chaque “commit” dispose d’un identifiant unique, géré par Git, et de métadonnées associées (date, auteur, message…).

État des fichiers dans Git

Les fichiers des dossiers peuvent être dans quatre états :

  • Untracked : nouveau fichier
  • Modified : vous avez fait des changements, et il diffère depuis la version stockée dans le dossier .git
  • Staged : le fichier modifié à déposer est marqué pour être enregistré dans le prochain commit
  • Commited : le fichier déposé est stocké dans le dépôt Git

Commiter en ligne de commande

Pour créer un commit, il faut commencer par avoir quelque chose à commiter.

On va donc créer un fichier vide ou travailler avec un fichier déjà existant :

# Création d'un fichier
$ touch mon_fichier.txt

Ensuite, il faut désigner les fichiers qui vont faire l’objet du commit :

# Pour prendre en compte tous les fichiers présents qui ont été modifiés
git add .

# Pour ne prendre en compte que le fichier mon_fichier.txt
git add mon_fichier.txt

Finalement, on déclenche l’opération de commit, avec un message pertinent :

git commit -m "Mon premier commit : initialisation de mon_fichier"

À ce stade, le fichier mon_fichier.txt est enregistré dans les fichiers suivis par Git.

Commiter avec RStudio 1/2

Pour créer un commit, cliquer sur le bouton “Commit” (ou Ctrl+Alt+M) :

Une fenêtre s’ouvre permettant de voir les fichiers non suivis ou les fichiers avec des modifications :

Commiter avec RStudio 2/2

Pour créer un commit contenant le fichier .gitignore :

  1. Sélectionner le fichier .gitignore
  2. Écrire un message de commit
  3. Cliquer sur le bouton “Commit”

Ajouter le .gitignore au dépôt

Commiter avec VS Code 1/2

Pour créer un commit, il faut commencer par avoir quelque chose à “commiter”. On va donc créer un fichier 

Constatez que le fichier est proposé en vert (add) dans “Source Control” 

  • survol puis “+” pour le passer dans la zone “staged”
  • ou prendre toutes les modifications (clic sur le “+” à côté de “changes”)

Commiter avec VS Code 2/2

Finalement, on déclenche l’opération de commit (2), après avoir saisi un message d’accompagnement (1) puis “Ctrl Enter” ou on clique sur la case à cocher dans l’onglet “Source control”

À ce stade, le fichier mon_fichier.txt est enregistré dans les fichiers suivis par Git.

Erreur possible

Si une erreur survient avec le message suivant :

Please tell me who you are

C’est que votre identité n’est pas connue de Git (les commit sont signés par des auteurs).

Utilisez alors les deux commandes suivantes pour configurer Git (à faire une fois) :

git config --global user.email "you@example.com"
git config --global user.name "Your Name"

Utiliser le menu Edit/Options.

Configurer Git dans les paramètres de l’extension GitGraph.

On peut ensuite relancer le commit.

Renommage et suppression de fichiers

  • Il est recommandé de renommer et supprimer des fichiers en utilisant les commandes git plutôt que d’utiliser les outils du système d’exploitation.
  • La principale justification est un meilleur suivi dans l’historique lorsqu’on utilise les commandes git.
# Déplacer un fichier
git mv fichier.txt new_name.txt
git commit -m "Mon message de commit"
# Supprimer un fichier
git rm fichier.txt new_name.txt
git commit -m "Mon message de commit"

Pratique

Ajout d’un fichier de code au dépôt

  1. Créer un fichier .R.
  2. Modifier le fichier avec du code R (exemple : créer une fonction qui permet de calculer la moyenne)
  3. Ajoutez le au dépôt avec un commit et profitez-en pour visualiser l’état du fichier avec git status ou via l’interface de votre IDE.

Ignorer les fichiers avec l’extension .data

  1. Créer un fichier .gitignore.
  2. Modifier le fichier pour qu’il ne prenne pas en compte les fichiers avec l’extension .data.
  3. Ajoutez le au dépôt avec un commit et profitez-en pour visualiser l’état du fichier avec git status ou via l’interface de votre IDE.
  4. Créer un fichier test.data avec un contenu quelconque et constater qu’il n’est pas proposé au suivi

Bonnes pratiques (commit)

Bonnes pratiques pour les commits

  • À intervalle régulier
  • Approche “atomique”
  • Un changement dans le code = un commit

Mauvaises pratiques pour les commits

  • Un commit en fin de journée
  • Commiter toutes les modifications en même temps

Messages de commit :

  • Commentaires courts, informatifs et explicites sur les changements présents dans le commit
  • Mauvaise pratique : Update code.r
  • Mauvaise pratique : Petit rajout
  • Mauvaise pratique : Code réparé

Historique du dépôt

Pratique

Pratique

Prendre le temps de faire quelques commits supplémentaires en ajoutant/modifiant des fichiers sur le dépôt.

Historique des commits (ligne de commande)

Pour voir l’historique des commits sur un dépôt, on peut utiliser les commandes suivantes :

# Affiche l'historique des commits, avec un hash pour chacun
git log

On peut afficher les modifications du commit correspondant à un hash particulier

git show <hash du commit>

Historique des commits (RStudio)

Dons l’onglet Git de RStudio, il y a un bouton “History”.

Ce bouton permet d’accéder à l’historique du dépôt (tous les commits effectués dessus) :

En sélectionnant un commit, on peut voir les informations qui le concernent :

Il est aussi possible de voir un fichier tel qu’il était suite à un commit particulier :

On peut alors parcourir un “instantané” du fichier :

Si l’on souhaite récupérer cet instantané, on peut l’enregistrer comme fichier :

Historique des commits (VS Code)

Pour voir l’historique des commits sur un dépôt

Nécessite d’avoir l’extension “Git history” installée

En cliquant sur une ligne de l’historique on peut accéder aux détails du commit

    1. Visualiser le fichier dans l’état du commit
    1. Comparer le fichier avec celui dans la working copy
  • Comparer le fichier avec la version du commit précédent
    1. Retourner à l’historique complet sur ce fichier

Git dans VS Code permet aussi aussi de suivre les suppressions et renommages de fichiers

Manipuler les commits

Sommaire

Dans cette section :

Annuler des modifications non commitées

Ligne de commande

  • Modifier un fichier sans faire de commit sur les modifications mais penser à sauvegarder le fichier.
  • Pour voir les différences :
git diff
  • Pour annuler les modifications ni indexées ni commitées (ni git add, ni git commit).
git checkout -- mon_fichier.txt
# ou
git restore mon_fichier.txt
  • Pour annuler les modifications indexées (avec git add) mais non commitées (pas de git commit)
git reset -- mon_fichier.txt

Annuler des modifications non commitées

RStudio

Modifier un fichier sans faire de commit sur les modifications mais penser à sauvegarder le fichier :

On peut aller dans l’interface de commit pour voir les modifications :

Si l’on souhaite supprimer toutes les modifications non commitées, on peut faire un clic droit sur le fichier concerné et les annuler avec “revert” :

Attention

Attention, c’est tout ce qui a été modifié dans le fichier depuis le dernier commit qui sera supprimé :

Annuler des modifications non commitées

VS Code

Modifier un fichier sans faire de commit sur les modifications mais penser à sauvegarder le fichier :

On peut aller dans l’interface de commit pour voir les modifications :

Si l’on souhaite supprimer toutes les modifications non commitées, on peut cliquer sur la flèche “discard changes” pour le fichier concerné :

Clic droit sur un fichier en vue d’annuler les modifications

Attention, c’est tout ce qui a été modifié dans le fichier depuis le dernier commit qui sera supprimé :

Confirmation de l’annulation des modifications

Grouper un commit avec un commit précédent

Ligne de commande

Ajouter les nouvelles modifications au commit précédent en passant par le terminal puis

git commit -m "groupement de commit" --amend

Constatez qu’il n’y a pas de nouveau commit dans la liste dans l’historique.

RStudio

Utiliser la case à cocher Amend previous commit

VS Code

Utiliser le menu déroulant du bouton Commit.

Pratique

Annuler une modification

  1. Modifier un fichier du dépôt et sauvegarder
  2. Constater (status) qu’il est proposé à l’enregistrement lors du prochain commit
  3. Utiliser Git pour revenir à la version précédente du fichier
  4. Constater que le fichier n’est plus proposé pour le prochain commit

<!— Etiquetage —>

<!— {{< include 11_etiquetage.qmd >}} —>

Pour aller plus loin avant la session 2

Pour s’exercer sur R

Utilisation du package saperlipopette, 12 exercices pour prendre confiance avec les commandes de Git :

De la lecture

Cheat sheet

Modèles de fichiers .gitignore :

Prochaine session

Objectifs session 2

  • Premiers pas avec GitLab
  • Travailler avec un dépôt Git distant (sur un serveur)
  • Proposer un changement au code de quelqu’un d’autre
  • Projet GitLab et issues
  • Bonnes pratiques