Configuration de Git + GitHub dans RStudio

Préambule. Un projet informatique est composé de fichier(s) de codes.

Les standards du travail collaboratif permettent à plusieurs personnes d’intervenir sur les mêmes fichiers. Pour cela on utilise un service nommé “Git”.

En R sous Rstudio, on travaille dans un “projet” : ce “projet” Rstudio est associé à un répertoire, dans lequel il y a tous les fichiers de codes du projet.

Il est recommandé d’utiliser systématiquement les projets RStudio. https://book.utilitr.org/03_Fiches_thematiques/Fiche_rprojects.html

Une notion importante va être éclaircie dans la suite du document :

Il est recommandé de créer un projet RStudio en clonant un dépôt distant [un repo Github ou un projet Gitlab]. https://book.utilitr.org/03_Fiches_thematiques/Fiche_git_utilisation.html

Dans ce document, on va voir comment configurer Git sous Rstudio pour avoir la possibilité de “cloner un dépôt distant”.

Le lead-dev va te demander ton nom de profil github et te filer des accès à un projet : la balle est dans ton camp ensuite.

I. Installer Git

[Si pas encore fait il faut installer Git, sinon passer à l’étape suivante]

Installer le programme “Git” depuis https://git-scm.com
Pendant l’installation, tu peux tout laisser par défaut et dire “oui à tout”… mais faire des recherches autour des termes que tu ne comprends pas ds les nombreux menus qui s’affichent à l’installation de Git ne serait pas du luxe.
Si Rstudio était ouvert : il faut redémarrer Rstudio pour qu’il prenne en compte l’installation de Git.

Vérifier que Git est installé. En console Rstudio :

 system("git --version")

Sinon : installer depuis https://git-scm.com

Vérifier si Git est bien reconnu dans les options globales de Rstudio. Dans le menu Rstudio Tools > Global Options > **Git/SVN**

Vérifier que “Enable version control interface for RStudio projects” est coché dans le menu global, et qu’il y a un chemin vers le git executable.

Spécifier le chemin vers Git s’il n’est pas détecté (il faut pointer vers le “git.exe” sur Windows).

Configurer Git globalement

Associer un user et un mail par défaut. En commandes terminal on peut configurer des options globales de git :

git config --global user.name "Prénom Nom"

git config --global user.email "son@email.com"

L’historique des modifications {scruté par le lead-dev’} propose le user.name et aussi le user.email, pour suivre qui fait quoi sur le projet.

Indiquer un token à Git et Rstudio. Il faut un token (code secret) pour que Rstudio soit capable d’écrire dans les repos Github auxquels le user peut accéder. De même pour lire les repo privés.

Soit le token est stocké dans le fichier .Renviron
Soit via le Git credential store (gitcreds)

Donc on veux un token global, pour accéder à tous les repos auxquels l’utilisateur à accès sur Github.

II. Creer token

Aller¹ sur : https://github.com/settings/tokens
Générer un token simple ‘personal access token’, a minima avec les scopes (portées) repo (le token permet d’accéder aux repos du user) et workflow (si on utilise GitHub Actions).
Copier le token dans un fichier.

III. Reporter le token pour Rstudio

Il y a deux méthodes pour stocker le token du user et pouvoir écrire sur github et donc mettre à jour son travail au fur-et-à-mesure.

Méthode 1. On peut stocker le token au niveau du fichier .Renviron global (généralement au niveau de “Mes documents” sous Windows avec l’installation R et Rstudio par défaut).

Pour ouvrir ce fichier :

 usethis::edit_r_environ()

Et j’y fait une entrée avec le token comme ci-ensuite :

GITHUB_PAT=ghp_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

On peut redémarrer Rstudio et passer aux étapes de création d’un projet.

MAIS. Cette méthode peut empêcher l’accès par défaut de Rstudio au Git credential store, censé reposer sur le magasin de certificats du OS.

Par exemple, usethis::git_sitrep() renvoie un warning expliquant que cette 1ère méthode pourrait interférer avec la 2nde, i.e. ‘can prevent your PAT from being retrieved from the Git credential store’.

 usethis::git_sitrep()


[...]
! C:/Users/CLEM/Documents/.Renviron defines the environment variable: GITHUB_PAT
! This can prevent your PAT from being retrieved from the Git credential store.
ℹ For most use cases, it is better to NOT define the PAT in .Renviron.
☐ Call usethis::edit_r_environ() to edit that file.
☐ Then call gitcreds::gitcreds_set() to put the PAT into the Git credential store.

Méthode 2. Comme le suggère usethis::git_sitrep(), on peut aussi stocker de facon plus sécurisée le token avec :

# install.packages("gitcreds")
gitcreds::gitcreds_set()

S’il y a déjà un token reporté dans le .Renviron, il faut supprimer la ligne du .Renviron avec le token (usethis::edit_r_environ() pour ouvrir ce fichier .Renviron).

S’il y a déjà un “password” (qui correspond en réalité à un token) gitcreds::gitcreds_set() va proposer de les remplacer par d’autres valeurs => option n° 2.

Et tu peux copier-coller le token dans la console donc quand on te le demande, sans guillemets.

À partir de là tu aura accès à certaines commandes :

usethis::git_push()

Ou encore pour voir le token :

gitcreds::gitcreds_get()

Et configurer un token ou github

usethis::create_github_token()
usethis::use_github()

Configurer un projet

Cloner ou créer un projet Git

Il faut toujours créer un repo github ou qu’il y en ai un. Selon si le projet existe déjà localement ou non :

Soit on clône un repo GitHub existant, pour créer un nouveau projet Rstudio (New Project > Version Control > Git). Il ne faut pas créer le projet dans une nouvelle session si Rstudio perd l’accès à internet en redémarrant (p. ex. si l’accès internet nécessite de régler un proxy d’entreprise).
Soit on configure un projet existant, si le projet Rstudio est déjà créé localement (Project Options > Git => et on indique l’adresse du projet au niveau de ‘Origin’).

Projet déjà créé locament + repo Github déjà existant

(p. ex. si le projet est sur un disque partagé)

Selon la config’ associée, il faut ouvrir le projet et faire : (Project Options > Git => et on indique l’adresse du projet au niveau de ‘Origin’)

Ou bien lancer un peu de code R ou terminal pour faire la même chose.

Commencer un nouveau projet à partir de rien

En général, si le projet est nouveau :

On veut commencer par créer un repo sur Github pour l’associer à un projet Rstudio
Et reporter dans Rstudio l’adresse https du projet - ou l’adresse ‘SSH’ si ssh est configuré (sur le github du projet il y a un gros bouton vert <> Code qui déroule l’adresse HTTPS et SSH ; et
on commence par créer un repo sur Github. On laisse tout vide généralement.
on va récupérer l’adresse (gros bouton vert <> Code propose l’adresse HTTPS et SSH). L’adresse HTTPS est aussi déductible comme ‘nom-du-user/repo’.
on veut indiquer cette adresse au niveau du projet sous Rstudio, via les menus Rstudio :

“Nouveau projet” ==> “Version control” ==> “Git”

{et on reporte l’adresse https}

Synchroniser un projet déjà créé localement

Si le projet est déjà créé sur l’ordinateur mais que le repo github est vide, il faut initialiser l’archive git locale avec ce qu’on a et push cette première contribution via :

des commandes terminal,
l’interface ‘git’ de Rstudio
ou encore avec des fonctions de usethis::

Ci-ensuite l’une des possibilités pour initialiser le projet.

En commandes terminal. Depuis le projet Rstudio, le terminal aura déjà placé le curseur au niveau du répertoire du projet. Tu peux donc simplement:

git init
git remote add origin https://github.com/ton-utilisateur/ton-repo.git
git add .
git commit -m "🚀 Initial commit depuis projet local"
git branch -M main
git push -u origin main

Ici c’est une adresse https au niveau de la commande add origin, mais ça peut être une clée ssh.

Dans RStudio, on devrait donc pouvoir accéder à une interface de “contrôle des versions” fonctionnelle => fenêtre de “commit changes” dans laquelle on peut choisir des fichiers, flèches pour “push” vers Github.

Commandes terminal pour bosser avec github

git status # voir les changements
git add . # ajouter tous les fichiers modifiés
git commit -m “Message clair” # créer un commit
git push # envoyer au repo GitHub
git pull # récupérer les changements du repo

Git tricks and treats

Parfois l’archive .git plante dès les premières étapes de “add” des fichiers dans l’archive.

Il faut supprimer le fichier index.lock avec une commande terminal.

rm -f .git/index.lock

E.g., de message d’erreur qui nécessite de supprimer ce fichier.

git add .
fatal: Unable to create 'C:/Users/CLEM/Documents/PROJETS_EN_R/financr/.git/index.lock': File exists.

 Another git process seems to be running in this repository, e.g.
 an editor opened by 'git commit'. Please make sure all processes
 are terminated then try again. If it still fails, a git process
 may have crashed in this repository earlier:
 remove the file manually to continue.

CLEM@DELL MINGW64 ~/Documents/PROJETS_EN_R/financr (main)
rm -f .git/index.lock

[et on recommence : git add . git commit -m “Initial commit” etc.]

Github action

Le token doit souvent être passé directement au niveau d’une action Github.

Ajouter le token comme secret dans ton dépôt.

Aller sur le dépôt → Settings → Secrets and variables → Actions → New repository secret

Choisir un nom et coller le token.

Ou alors via les menus : sous la photo de profil cliquer sur “settings” => et ensuite en bas du menu “Developer Settings” => “Personal access tokens”↩︎