Utilisation de Git pour travailler en commun sur des documents

Le contrôle des révisions

Git est un gestionnaire de révision développé initialement par les développeurs du noyau Linux pour leur propre usage.

Un gestionnaire de révisions est un outil permettant :
– de garder facilement une trace de toutes les modifications apportées à des fichiers, et de pouvoir reprendre une ancienne version d’un fichier, de comparer deux versions...
– de travailler en commun sur des fichiers, de partager son travail à travers internet avec les autres, de fusionner facilement les versions venant de plusieurs personnes...

Les outils historiques de gestion des révisions sont RCS et CVS.

Particularités de Git

RCS ne sait versionner des fichiers qu’en local : les utilisateurs doivent travailler sur le même serveur pour partager leur travail.

CVS (ou SVN) permet que chacun travaille sur sa machine, mais repose sur l’idée qu’il existe un serveur central pour le projet, auquel les utilisateurs devront toujours accéder pour tout ce qui touche au projet.

Git est un gestionnaire de révisions distribué. Tous les utilisateurs possèdent tout l’historique du projet sur leur machine locale, et peuvent travailler dans leur coin. Quand ils le décident, ils peuvent partager leurs modifications entre eux. Ils ne sont pas obligés de passer par un serveur centralisé. Dans le cadre de GUTenberg, vu la nature de nos projets, on utilise quand même un serveur central, mais Git apporte une souplesse bien pratique pour travailler sans être connecté en permanence à internet.

Ceux qui veulent avoir une introduction générale peuvent consulter http://gitref.org/. Le reste de ce document donnera les indications de base pour s’en servir sur notre serveur.

Utilisation de Git sur le serveur de GUTenberg

Tous les projets du CA sont regroupés dans le répertoire /var/git/ sur le serveur GUTenberg.

Récupérer un projet

Pour récupérer l’ensemble du projet "gut_lettre37", par exemple :

$ git clone ssh://gutenberg.eu.org/var/git/gut_lettre37.git

Git crée alors un répertoire local gut_lettre37 (le nom du dépôt sans le suffixe .git), récupère tout l’historique du projet, et construit une arborescence avec tous les fichiers dans leur dernière version.

Ensuite, pour récupérer les modifications faites par les autres personnes et suivre les versions successives des fichiers, il suffit de se mettre dans le répertoire du projet, et de faire un pull

$ cd gut_lettre37

$ git pull

En cas de conflit (si un fichier a été modifié à la fois dans le répertoire local et dans le dépôt du serveur), Git prévient et donne des instructions pour corriger le problème.

Travailler sur un projet

Quand on a fait des modifications en local, on a plusieurs actions à faire l’une après l’autre, en fonction des cas :
– un add pour signaler à Git quels fichiers sont à prendre en compte,
– un commit que Git ajoute les modifications à l’historique local,
– un push pour remonter ces modifications sur le serveur les partager avec les autres personnes.

Typiquement, pour chaque fichier sur lequel on travaille, il faut faire :

$ git add mon_fichier.tex

Si on a modifié plusieurs fichiers, Git peut rechercher lui-même tous ceux qui ont été changés, avec :

$ git add -A

Dans ce cas, il est bon de vérifier que Git n’a bien détecté que les fichiers utiles, en faisant :

$ git commit --dry-run

Si on s’aperçoit que Git a pris des fichiers inutiles en compte (par exemple les fichiers .aux de LaTeX), on peut les retirer du contrôle :

$ git reset mon_fichier.aux

Une fois qu’on a fait les modifications que l’on voulait et que la liste des fichiers est bonne, on enregistre tout dans l’historique local :

$ git commit

Git demande que l’on mette un petit commentaire pour décrire les modifications. Les modifications font maintenant partie de l’historique du projet, par contre, elles ne sont visibles qu’en local.

Quand on estime que les modifications sont dignes d’être partagées avec les autres personnes, on les remonte vers le serveur :

$ git push

Ce n’est qu’à ce moment que les autres personnes peuvent faire un pull pour les récupérer.

Créer un nouveau projet

Pour créer un nouveau projet en local, il suffit d’initialiser un dépôt, puis de s’en servir :

$ mkdir gut_lettre38

$ cd gut_lettre38

$ git init

Pour le déposer ensuite sur le serveur, il faut initialiser un dépôt « nu » sur le serveur (traditionnellement, le nom de ce dépôt porte l’extension .git) :

[zapf]$ cd /var/git

[zapf]$ mkdir gut_lettre38.git

[zapf]$ cd gut_lettre38.git

[zapf]$ git init --bare

Avant d’envoyer le contenu du dépôt depuis la machine locale vers le serveur, il convient d’y ajouter au moins un fichier et de l’enregistrer dans l’historique local (« commit ») :

$ cd gut_lettre38

$ git add mon_fichier.tex

$ git commit

On peut alors envoyer le contenu du dépôt depuis la machine locale vers le serveur :

$ git push ssh://identifiant@gutenberg.eu.org/var/git/gut_lettre38.git master

où identifiant est votre identifiant sur le site GUTenberg. Le mot de passe demandé est celui que vous utilisez sur le site. En bref, cette paire identifiant / mot de passe est celle qui vous a permis de venir lire ceci.

Ensuite, le mieux est de faire immédiatement un nouveau clone local du dépôt distant. Comme ça, le dépôt local gardera trace qu’il vient du serveur, et on pourra faire des push et des pull sans avoir à préciser le nom complet du serveur. Donc en détail :