Travailler en local sur un dépôt GitHub

Ce chapitre explique comment travailler en local sur un dépôt GitHub, grâce au clonage du dépôt distant. Nous verrons aussi comment pousser des modifications vers le dépôt distant et comment voir les dernières modifications. Enfin, nous apprendrons à mettre à jour un dépôt local à partir des données du dépôt distant.

I. Cloner un dépôt GitHub

Maintenant que nous avons un dépôt distant, nous allons le cloner pour en avoir une copie sur notre poste de travail. Pour faire cette opération, appuyez sur le bouton « Code » et copiez l'URL HTTPS indiquée.

Il existe d'autres manières de cloner un dépôt distant, notamment en utilisant SSH ou via l'interface en ligne de commandes GitHub CLI. Sur Windows, l'application GitHub Desktop peut aussi effectuer cette action. Ces fonctionnalités dépassent le cadre du présent cours, mais l'option SSH est généralement privilégiée puisqu'elle ne nécessite pas d'authentification.

Revenez ensuite dans votre terminal Visual Studio Code, créez un nouveau répertoire au besoin ou déplacez-vous à un emplacement où vous souhaitez copier votre dépôt distant. Pour cloner ce dernier, vous devez utiliser la commande « git clone » suivie de l'URL que vous venez de copier sur GitHub :

# Cloner un dépôt distant
$ git clone https://github.com/utilisateur-git-hub/cours-git.git

Comme le dépôt est « public », il va se copier automatiquement sur votre poste de travail et vous le verrez s'ajouter à l'emplacement sélectionné. Dans le cas d'un dépôt « privé », vous devez vous authentifier à GitHub. Vous pouvez ouvrir le fichier « README » pour confirmer que les modifications que vous avez faites sur GitHub sont bien présentes localement.

Dans la capture suivante, nous voyons que nous avions écrit « # Cours git », puis « Test Git ». Il s'agissait de notre premier commit sur GitLab.

Vous pouvez maintenant travailler localement dans votre dépôt issu de GitHub. Éventuellement, vous voudrez envoyer ces modifications vers votre dépôt distant, c'est ce que nous allons voir dans la partie suivante.

II. « Pousser » des modifications vers un dépôt distant

Pour « pousser » vos dernières modifications (commits) vers un dépôt distant, vous devez utiliser la commande « git push ». Dans la terminologie de Git, le dépôt distant vers lequel vous allez envoyer vos commits se nomme « origin » par défaut. Lorsque vous faites un clone, la branche « origin » est référencée automatiquement dans votre dépôt local. Pour la voir, exécutez la commande « git remote » :

# Afficher le nom de la branche "remote" ou "origin"
$ git remote -v
origin  https://github.com/utilisateur-git-hub/cours-git.git (fetch)
origin  https://github.com/utilisateur-git-hub/cours-git.git (push)

Nous voyons que nous obtenons également l'URL de la branche « origin » avec les mentions « fetch » et « push » qui indiquent que notre dépôt local peut faire des opérations qui consistent à « aller chercher » (« to fetch ») du contenu depuis le dépôt distant ou en envoyer (« push »).

Pour distinguer les branches d'un dépôt distant, Git y fait référence localement en indiquant « origin » suivi d'une barre oblique (slash). Par exemple, nous pourrions avoir les branches suivantes hébergées dans un dépôt GitHub : « origin/main » et « origin/feature ».

Après avoir fait un ou plusieurs commits, exécutez la commande « git push » dans VS Code suivie de l'URL de votre dépôt GitHub :

VS Code ouvrira une fenêtre pour vous demander si vous souhaitez vous authentifier à GitHub, appuyez sur « Allow ».

Authentifiez-vous et autorisez VS Code à interagir avec GitHub en appuyant sur « Authorize Visual-Studio-Code ».

Après avoir complété ces étapes, vous n'aurez plus à spécifier l'URL de votre dépôt distant lorsque vous faites un « git push ».

III. Voir localement les modifications effectuées sur un dépôt distant

Nous venons d'apprendre comment faire un « push » de nos modifications locales vers GitHub, voyons maintenant comment faire l'opération inverse avec un « fetch  » ou un « pull ». Lorsque vous contribuez à un dépôt partagé, vous aurez souvent besoin de mettre à jour votre dépôt local avant de pouvoir « pousser » vos derniers commits. Cette opération peut se faire de deux manières, soit avec la commande « git fetch » ou « git push ». Commençons par la première, nous verrons la seconde dans la section suivante.

Pour faire l'essai de « git fetch », faites des modifications au le fichier « README » suivi de commits directement sur votre dépôt dans GitHub. Ensuite, revenez dans VS Code et exécutez la commande « git fetch » :

# Récupérer les derniers "commits" d'un dépôt distant
$ git fetch
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 951 bytes | 73.00 KiB/s, done.
From https://github.com/utilisateur-git-hub/cours-git
   b3dae52..9191f9f  main       -> origin/main

Cette opération va récupérer les derniers commits, mais ne va pas les fusionner avec la branche locale. La commande « git fetch » permet de visualiser ce qui a été modifié avant de mettre à jour son dépôt local. Comme nous avons modifié le fichier « README », nous pouvons constater qu'un « M » s'est ajouté à droite du fichier dans VS Code :

La commande « git fetch » ne permet pas de voir les changements directement, elle indique seulement les fichiers modifiés. Pour voir ces changements, nous allons d'abord exécuter la commande « git log » en spécifiant les paramètres « HEAD..origin/main » :

# Voir les "commits" effectués sur la branche origin
$ git log HEAD..origin/main
commit 9191f9f67ec39bb80ce1449973f13bf4005f2f2c (origin/main, origin/HEAD)
Author: utilisateur-git-hub <[email protected]>
Date:   Sat Aug 10 12:35:56 2024 -0400

    Update README.md

Nous voyons maintenant la chaîne hexadécimale de notre dernier commit sur GitHub qui inclut les modifications apportées au fichier « README ». Pour visualiser ce qui a été changé, vous devez faire un « git checkout » non pas d'une branche comme nous l'avons vu dans le module précédent, mais d'un commit :

# Faire un "git checkout" d'un commit (il n'est pas nécessaire de recopier le hash complet) 
$ git checkout 9191f9f67
Note: switching to '9191f9f67'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -c with the switch command. Example:

  git switch -c <new-branch-name>

Or undo this operation with:

  git switch -

Turn off this advice by setting config variable advice.detachedHead to false

HEAD is now at 9191f9f Update README.md

Pour visualiser les commits dans un dépôt GitHub, il suffit d'appuyer sur « Commits » sous le bouton « Code » :

Vous verrez la liste des commits effectuées pour la branche en cours de votre dépôt distant ainsi que leur chaîne hexadécimale :

Une fois à l'intérieur du commit, vous pouvez voir le changement dans le fichier « README » qui n'est plus à l'état modifié. Dans notre exemple, la phrase « Test pour faire un git fetch » avait été ajoutée dans GitHub :

Nous pouvons sortir du commit avec la commande « git switch - » (tel qu'indiqué) ou « git checkout main » pour revenir à notre dépôt.

$ git switch -
Previous HEAD position was 9191f9f Update README.md
Switched to branch 'main'
Your branch is behind 'origin/main' by 1 commit, and can be fast-forwarded.
  (use "git pull" to update your local branch)

Utilisateur@my-laptop MINGW64 ~/local/cours-git (main)

Si vous souhaitez conserver ces changements, vous devrez faire un merge (ou rebase, voir chapitre précédent) avec la branche « origin/main ».

N'oubliez pas que vous travaillez avec deux dépôts, un local et l'autre distant. Vous avez donc une branche « main » locale et une branche « origin/main » sur le dépôt GitHub. Pour rappel, la branche principale d'un dépôt distant se nomme « origin » par défaut.

$ git merge origin/main
Updating b3dae52..9191f9f
Fast-forward
 README.md | 1 +
 1 file changed, 1 insertion(+)

Votre dépôt local sera maintenant synchronisé avec le dépôt distant. La commande « git fetch » est plus souvent utilisée dans un contexte de développement avec plusieurs contributeurs, ce qui permet de voir ce qui a été changé et éviter des conflits.

IV. Mettre à jour un dépôt local à partir d'un dépôt distant

De manière générale, vous utiliserez plus souvent « git pull » qui fait un fast-forward merge par défaut de la branche « origin/main » (ou autre) avec la branche cible locale. Si vous modifiez à nouveau le fichier « README » sur votre dépôt GitHub et que vous faites un « git pull », vous verrez que Git indique qu'il exécute automatiquement un fast-forward merge :

$ git pull
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 928 bytes | 154.00 KiB/s, done.
From https://github.com/utilisateur-git-hub/cours-git
   9191f9f..89cf00f  main       -> origin/main
Updating 9191f9f..89cf00f
Fast-forward
 README.md | 2 ++
 1 file changed, 2 insertions(+)

Un « pull » est utilisé pour mettre à jour votre branche locale avec les dernières modifications de la branche distante correspondante. Voici ce qui se produit lorsque vous exécutez la commande « git pull » :

• Récupération : Elle récupère les commits et les modifications de la branche distante.
• Fusion (merge) : Elle fusionne ces modifications dans votre branche locale.

En fait, un « git pull » est une combinaison de « git fetch » (pour récupérer les modifications) et de « git merge »  (pour les fusionner). Ceci vous permet de garder votre branche locale à jour avec les dernières modifications du dépôt distant.

# Récapitulatif des commandes pour ce chapitre

git clone <url_dépôt_distant> Copier localement le contenu d'un dépôt distant
git push <url_dépôt_distant>  Envoyer les derniers commits locaux vers un dépôt distant
git fetch                     Récupérer les derniers "commits" d'un dépôt distant
git pull                      Récupérer localement les dernières modifications d'un dépôt distant