Petit mémo d'utilisation de git

Git est un logiciel de gestion de source distribué. Le site principal de référence est git-scm.com.

Cet article est là pour me servir de référence rapide. Il n'est pas prévu pour se substituer à l'excellent livre "Pro Git".

Deux autres ressources très courtes et très pratiques :

Installation, configuration initiale

L'installation de git se fait de façon habituelle pour la disri. Par exemple, pour Debian & co. :

apt-get install git

Avant toute utilisation, il faut configurer le nom d'utilisateur, l'adresse email et l'éditeur de texte. Cela peut se faire avec les trois commandes :

git config --global user.name "Manu"
git config --global user.email "manu@bernat.me"
git config --global core.editor gedit

Pour voir tous les paramètres configurés, il suffit de faire :

git config --list

Les bases de Git

Créer ou cloner un dépôt

L'élément de travail de Git est le dépôt. Un dépôt rassemble les sources d'un projet.

On peut créer un dépôt dans un répertoire (vide ou non) avec la commande :

git init
<code>

On peut également cloner un dépôt existant avec la commande :

<code>
git clone <url du depot>

Le principe de fonctionnement de Git

Le flux de travail avec Git est décomposé en trois emplacements :

  • Le répertoire de travail (working directory) : c'est le répertoire de base dans lequel a été exécuté la commande git init ou git clone. C'est dans ce répertoire que l'on modifie les sources du projet.
  • L'aire de transit (staging area) : c'est l'endroit où sont rassemblés tous les éléments du répertoire de travail qui ont été modifiés et qui seront pris en compte dans la prochaine version.
  • Les versions (commits) : ce sont les versions successives du projet, chacune est identifiée par un commentaire (et par un identifiant unique).

Chaque fichier peut prendre quatre états :

  • Non suivi (untracked) : le fichier n'est pas soumi au contrôle de version. Ses modifications ne sont pas prises en compte.
  • Non modifié (unmodified) : le fichier n'a pas été modifié depuis le dernier commit.
  • Modifié (modified) : le fichier a été modifié depuis le dernier commit mais n'est pas sélectionné pour le prochain commit.
  • En transit (staged) : le fichier a été modifié depuis le dernier commit et il est sélectionné pour le prochain commit.

Ce flux est résumable par le diagramme suivant (tiré du livre “Pro Git”) :

Connaître l'état d'un dépôt

Pour connaître l'état d'un dépôt, il faut utiliser la commande :

git status

Cette commande affiche la liste des fichiers non suivis et des fichiers modifiés (mais pas en transit).

Ajouter des fichiers dans le contrôle de source et placer des fichiers en zone de transit

Pour ajouter des fichiers untracked dans le contrôle de source, la commande est :

git add <nom des fichiers>

Cette même commande indique que le fichier sera pris en compte dans le prochain commit (s'il est déjà sous contrôle et qu'il a été modifié).

Note : il est possible d'ajouter tous les fichiers avec git add * et d'en ignorer automatiquement certains en créant un fichier .gitignore contenant des patterns de chemins à ignorer.

Retirer des fichiers de la zone de transit

A l'inverse de git add, la commande :

git reset <nom de fichier>

permet de retirer un fichier de la zone de transit. Il ne sera donc pas pris en compte lors du prochain commit.

Comparer les fichiers de la zone de transit avec le dernier commit

Il est possible de savoir ce qui a été modifié dans les fichiers présents dans la zone de transit par rapport au dernier commit avec la commande :

git diff --staged

et de comparer la zone de travail et la zone de transit avec :

git diff

Créer une version

L'enregistrement des fichiers dans la zone de transit crée une nouvelle version du projet. Cet enregistrement se fait avec la commande :

git commit

ou

git commit -m "Commentaire du commit"

Si le commentaire n'est pas précisé, Git ouvrira automatiquement l'éditeur de texte pour saisir un commentaire.

Il est possible de créer une version directement depuis la zone de travail avec tous les fichiers modfifiés (pour peu qu'ils soient déjà sous contrôle de Git) avec la commande :

git commit -a -m "Commentaire du commit"

Enfin, l'option –amend permet de refaire le commit en ajoutant des fichiers oubliés ou en modifiant le message.

Retirer un fichier du contrôle de version

Pour cesser de suivre les versions d'un fichier, il suffit de faire :

git rm <chemin du fichier>

L'option –cached permet de conserver la copie de travail (pour le cas d'un fichier que l'on aurait oublié d'inclure dans de .gitignore).

Renommer ou déplacer un fichier dans Git

De façon similaire, il est facile de renommer un fichier qui est suivi par Git ou même de le déplacer avec la commande :

git mv <source> <destination>

Voir l'historique des modifications

Pour consulter les modifications réalisées au fil des commits successifs, la commande est :

git log

Toutefois, il est probablement plus agréable d'utiliser une interface graphique pour visualiser les évolutions d'un dépôt. Sous Windows, une interface très complète et intégrée à l'explorateur est disponible : TortoiseGit. Pour les systèmes Linux, on a par exemple gitk ou git-webui.

Annuler les modifications sur un fichier

Pour restaurer un fichier à l'état du dernier commit, il faut utiliser la commande :

git checkout -- <liste des fichiers>

Attention : cette commande efface irrémédiablement les modifications réalisées sur le fichier.

Les dépôts distants

En plus d'être un contrôle de versions local, Git est également distribué. C'est à dire qu'il permet de manipuler des dépôts à distance. Les dépôts distants peuvent être multiples, avec des droits d'accès divers.

Lister les dépôts distants

Le listage se fait avec la commande :

git remote

Le flag -v permet de voir en plus l'URL de chaque dépôt distant.

Ajouter un dépôt distant

Pour ajouter un nouveau dépôt distant, il suffit d'utiliser :

git remote add <nom court> <URL>

Le nom court est le nom sous lequel le dépôt distant sera référencé dans les autres commandes. Il est préférable de le choisir simple, explicite (et sans espace). L'URL indique l'emplacement du dépôt distant.

Récupérer les commits d'un dépôt distant

La récupération des modifications d'un dépôt distant se fait soit avec :

git fetch <nom court>

qui récupère les modifications mais ne les fusionne pas avec les éléments locaux ou bien :

git pull <nom court>

qui tente en plus de fusionner automatiquement les modifications distantes dans la zone de travail locale.

Pousser les commits dans un dépôt distant

Cette opération se fait avec la commande :

git push <nom court> <branche locale>

Pour pousser des modifications, il faut :

  • avoir les droits d'écriture sur le dépôt distant
  • que personne n'ait poussé d'autre modifications depuis le dernier pull

Modifier la liste des dépôts distants

Les deux commandes :

git remote rename <nom court> <nouveau nom court>

et

git remote rm <nom court>

permettent de modifier le nom court d'un dépôt distant ou bien de supprimer la référence à ce dépôt.

Gestion des étiquettes

Il est possible de poser des étiquettes (tags) sur certains commits afin de les différencier. Celà permet par exemple de marquer facilement les versions publiées d'un logiciel.

Les différentes commandes de gestion des tags sont les suivantes :

  • Lister les tags : git tag
  • Créer un tag : git tag -a <tag> -m <commentaire>
  • Créer un tag signé (par GPG) : git tag -s <tag> -m <commentaire> (il est bien sûr nécessaire d'avoir GPG avec une clé privée installée)
  • Vérifier un tag signé : git tag -v <tag> (la clé publique du signataire doit être présente dans le trousseau)