Objectifs

Comprendre Git et le pratiquer 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 à 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

Les états du système de fichiers

É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 :

GIT est une commande (1)

Ces commandes doivent être invoquées avec git. Par exemple :

Important

git commit -m « Ajouter des variables d’ajustement »

add/stage : Place un fichier dans la zone index/stage

rm : Supprime un fichier (du répertoire de travail ainsi que de la zone d’indexation)

init : Créer un nouveau dépôt Git vide

clone : Créer une copie locale d’un dépôt distant

fork : Créer une réplique privée du dépôt d’un autre utilisateur

GIT est une commande (2)

commit : enregistre les modifications dans le dépôt local

status : fournit un instantané de l’état actuel du dépôt

log : Consulter l’historique des modifications d’un dépôt Git

checkout : Passer d’une branche à l’autre ou restaurer les fichiers de notre répertoire de travail à l’état où ils se trouvaient dans une branche ou un commit spécifique

pull/push : traiter avec un dépôt distant

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” (nous verrons une autre méthode plus pragmatique) :

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.

Initiatialisation 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

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 :

*.txt
*.back
ce_fichier_a_ignorer.data
/logs/
temp/
  • Pour créer le fichier vide .gitignore en ligne de commande :
touch .gitignore

  • Avec VS Code il faut créer un fichier .gitignore à la racine de votre projet.

  • Il est possible de créer un fichier .gitignore dans les sous-dossiers

  • Sur 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

Suivre des fichiers et leurs modifications dans le dépôt

Rappel des états

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.

Tip

git commit -am "Message de commit"

permet de commiter avec un add implicite sur toutes les modifications

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"

On peut ensuite relancer le 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>

Git permet aussi aussi de suivre les suppressions et renommages de fichiers :

# 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"


Pour annuler les modifications non commitées sur un fichier, on peut utiliser la commande suivante :

git restore <nom du fichier>

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 non commitées et indexées.
git reset -- mon_fichier.txt
  • Pour annuler les modifications non commitées et non indexées (retrouver le fichier de l’index ou d’un autre commit).
git checkout -- mon_fichier.txt
# ou
git restore 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

Étiquetage

Définition

Tag en anglais

Fonctionnalité de Git : étiqueter un certain état dans l’historique comme important.

Exemple

On souhaite marquer les états de publication (v1.0 et ainsi de suite)

Les différents types d’étiquettes

Deux types principaux d’étiquettes :

  • étiquettes légères :
    • pointe sur un commit spécifique
    • suffit si aucune information supplémentaire n’est pas désirée ou l’étiquette doit rester temporaire.
  • étiquettes annotées :
    • objets à part entière dans la base de données de Git :
      • une somme de contrôle,
      • le nom et l’adresse courriel du créateur,
      • la date,
      • un message d’étiquetage,
      • peuvent être signées et vérifiées avec GNU Privacy Guard (GPG).
    • recommandées pour générer toute cette information

Les étiquettes avec R

Attention

L’interface RStudio ne permet pas de créer d’étiquette, il faut passer par la ligne de commandes.

Les étiquettes en ligne de commande

Lister les étiquettes existantes (par ordre alphabétique) :

git tag
v0.1
v1.3

Rechercher les étiquettes correspondant à un motif particulier

git tag -l 'v1.*'
v1.3

Pour créer une étiquette légère :

git tag v1.4-lg

Pour la visualiser :

git show v1.4-lg
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <schacon@gee-mail.com>
Date:   Mon Mar 17 21:52:11 2008 -0700

    changed the version number

Pour créer une étiquette annotée :

git tag -a v1.4 -m 'ma version 1.4'

Pour la visualiser :

git show v1.4
tag v1.4
Tagger: Ben Straub <ben@straub.cc>
Date:   Sat May 3 20:19:12 2014 -0700

ma version 1.4

commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <schacon@gee-mail.com>
Date:   Mon Mar 17 21:52:11 2008 -0700

    changed the version number

Pour supprimer une étiquette

git tag -d v1.4-lw
Deleted tag 'v1.4-lw' (was e7d5add)

Pour voir les versions de fichiers qu’une étiquette pointe.

git checkout v2.29.2

Important

Votre dépôt sera dans un état « HEAD détachée ».

Si vous modifiez puis créez un commit, l’étiquette restera identique, mais votre nouveau commit n’appartiendra à aucune branche et sera non joignable, à part avec son empreinte de commit exacte.

Les étiquettes avec VS Code

Lister les étiquettes existantes : dans le menu, cliquer sur Basculer sur…

… et choisir parmi les étiquettes proposées

Rechercher les étiquettes correspondant à un motif particulier

Important

VS Code ne propose que des étiquettes annotées. Il faut utiliser la ligne de commande.

Tip

On peut cependant ne saisir que le nom de l’étiquette et taper enter pour les autres informations demandées et ainsi créer une étiquette légère.

Pour créer une étiquette annotée : dans le menu, cliquer sur Étiquettes > Créer une étiquette.

Important

VS Code ne propose pas de visualiser les données d’une étiquette. Il faut utiliser la ligne de commande.

Dans le menu, cliquer sur Étiquettes > Supprimer l’étiquette.

Pour se positionner sur une étiquette particulière, après avoir cliqué dans le menu sur Basculer sur…, choisir l’étiquette.

L’extension GitLens disponible dans VS Code propose un accès direct aux fonctionnalités de création d’étiquette et à la liste des étiquettes disponibles

Pratique

Utiliser l’étiquettage

  1. Créer une étiquette v1.0 dans l’état actuel du dépôt
  2. Ajouter un fichier “test_etiquette.txt” dans le dépôt et commit
  3. Créer une nouvelle étiquette v2.0
  4. Lister les étiquettes sur le dépôt (constater les numéros de commit associés)

Supplément en avance de phase sur la session 2

  1. Avec la commande “git checkout v1.0” constater que le fichier “disparaît” du dépôt
  2. Revenir à la version v2.0 avec “git checkout v2.0” et constater le retour du fichier “test_etiquette.txt”
  3. Supprimer l’étiquette v1.0

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

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