Git

Git est un système de contrôle de version. Assez proche de SVN par certains côtés, il présente néanmoins un grand nombre de différences.

Avant de découvrir les spécificités de Git, il est nécessaire de connaître les concepts généraux des systèmes de contrôle de version.

Dépôts

Alors que CVS et SVN sont des systèmes de versionnement centralisés (i.e un serveur contient le dépôt, et chaque utilisateur effectue un checkout depuis ce dépôt), Git est complètement décentralisé.

Pour récupérer une copie du dépôt de Frankiz, par exemple, on utilisera la commande suivante :

git clone git://git.eleves.polytechnique.fr/frankiz.git

On obtient ainsi un clone du dépôt d'origine (i.e une copie conforme), qui peut d'ailleurs servir de backup si le dépôt d'origine était perdu. Notre clone contient tout l'historique du dépôt depuis sa création, toutes les branches, etc.

Git supporte également d'autres protocoles et syntaxes :

• On peut omettre le .git final :

git clone http://git.eleves.polytechnique.fr/frankiz

• Récupération par HTTP :

git clone http://git.eleves.polytechnique.fr/frankiz

• Connexion en SSH :

git clone ssh://user@git.eleves.polytechnique.fr/home/git/frankiz

• Accès à un dépôt sur la machine locale :

git clone /home/git/frankiz.git

• Clone du dépôt d'un autre utilisateur :

git clone /home/2006/xelnor/dev/frankiz/

Opérations standards

Récupérer une copie de travail

Voir la partie Dépôts ci-dessus

Effectuer un commit

L'opération s'effectue en plusieurs étapes :

• Modifier des fichiers
• Vérifier la liste des modifications :

git diff

• Indiquer à git quels fichiers feront partie du commit ; ceci permet de ne committer que les modifications de quelques fichiers

git add path/to/file1 path/to/file2

• Vérifier que l'on a ajouté les fichiers que l'on voulait :

git status

• Faire le commit (le -s ajoute une ligne Signed of by dans le message, pour pouvoir retrouver plus efficacement l'auteur réel du commit)

git commit -s

• Transmettre les commits au dépôt d'origine

git push

La dernière commande provient du fait que git n'est pas centralisé : il n'envoie pas les modifications locales au dépôt parent spontanément.

Ceci permet de faire quelques modifications locales puis de n'envoyer cela au reste des développeurs que lorsque les modifications sont stables et complètes, par exemple.

Gérer les branches

On peut voir la liste des branches accessibles avec :

git branch -a

• La ligne avec une étoile est la branche courante
• Les lignes blanches sont les branches locales (elles suivent généralement une branche distante)
• Les lignes rouges sont les branches distantes.

Pour récupérer une autre branche, il faut d'abord l'ajouter localement :

git checkout -b NomLocal origin/NomDistant

Cela aura également pour effet de basculer sur la branche NomLocal. Les modifications que l'on avait effectuées sont bien entendu conservées.

Une fois la branche ajoutée, on peut basculer de branche en branche à l'aide de :

git checkout NomLocal

Mettre à jour la copie de travail

Git stocke séparément la version du dépôt et la version locale.

Pour mettre à jour sa copie de travail, il faut donc :

1. Récupérer les derniers changements du dépôt d'origine :

git fetch origin

1. rebaser le dépôt : appliquer les éventuelles modifications locales à la suite de celles effectuées sur le dépôt ; si on travaille sur la branche master, on fera :

git rebase origin/master

1. Git essaiera alors d'appliquer les commits locaux successivement, en indiquant chaque fois qu'il y a un problème. Il faudra alors :
   1. Résoudre le problème (les fichiers avec des conflits apparaîssent comme Changed but not updated dans git status)
   2. Ajouter les fichiers (git add)
   3. Indiquer à git de continuer : git rebase --continue

Ceci permet de transformer l'état suivant (les O sont les commits, A le moment où les deux versions ont commencé à diverger, B la version du dépôt, E la version locale, C et D des commits locaux)

      -C--D--E
     /
-O--A--O--B

En l'état plus propre :

-O--A--O--B--C'--D'--E'

Avec C, D et E convertis en C', D' et E' : ils ont été modifiés pour être des modifications relatives à B au lieu de A.

Créer un dépôt

Contrairement à SVN où il faut installer un serveur subversion, créer un dépôt Git est très rapide : dans le dossier que l'on souhaite versionner, il suffit de taper

git init

Et voilà, le dossier est versionné : on peut donc commencer à faire des modifications, des commits, etc. (bien entendu, on ne peut pas pusher ses commits, puisqu'il n'y a pas de serveur distant).

Cette particularité rend Git très efficace pour versionner un petit projet, un exercice de TD, etc.

Structure interne

Git stocke les commits de manière très particulière : un commit correspond à peu près à une sauvegarde de l'état des fichiers, à un message, et à une référence vers le commit parent. Contrairemant à SVN, il n'y a donc pas de notion de numéro de révision : chaque commit est identifié par une chaîne hexadécimale de 40 caractères (par exemple : 04fd02e59b1bdc430c7a7dcc1ca9f4cbc2b04037 )

Un tag est en fait un nom «lisible» donné à un commit ; une branche indique également le commit principal d'une branche.