<style>
#doc>div, #doc>p, #doc>ul {
text-align: justify;
}
</style>
<center>
Introduction au versioning avec Git
===
</center>
Git est un outil de versioning développé par Linus Torvalds, le papa du noyau Linux. Il s'agit d'un logiciel libre, disponible sur tout les systèmes d'exploitation.
Il existe de nombreux autres logiciels de versioning. Mais Git a l'avantage d'être libre. Il est également parmi les solutions de versioning les plus utilisées. Il suffit de jeter un coup d'oeil sur la liste des librairies et des logiciels en développement sur Github pour s'en convaincre. Il dispose d'une importante documentation que vous trouverez à l'adresse suivante : [documentation git](https://git-scm.com/documentation).
## Le versioning
Le versioning consiste à figer le code source d'un projet à un instant donné. On dit qu'on réalise des versions de notre code. Vous savez les 0.6.8 ou 1.2.8.a qu'on a parfois après le nom des logiciels. Cette notion est associée au terme de **commit** dans le vocabulaire de Git.
Git permet d'éviter ce genre de choses :
<div style="text-align:center">
</div>
Mais l'utilisation de Git ne se limite pas à l'archivage des différentes versions du code. Il permet également de réaliser plusieurs versions à un même instant, ce qu'on appelle généralement un **fork**. Cela permet de développer en parallèle plusieurs versions différentes du même projet. Cette notion est associée au terme de **branch** dans Git.
## Installation
### Sous Linux
Servez vous du gestionnaire de paquet associé à votre distribution. Par exemple, pour les dérivés de Debian, comme Ubuntu, il suffit de rentrer dans la console :
```bash
sudo apt-get install git
```
### Sous Mac Os
Pour l'installation sur Mac, vous pouvez utiliser l'installeur suivant : http://sourceforge.net/projects/git-osx-installer/
Il est également possible d'utiliser les MacPorts avec la commande :
```bash
sudo port install git-core +svn +doc +bash_completion +gitweb
```
### Sous Windows
Enfin pour Windows, il existe également un installeur à l'adresse suivante : http://msysgit.github.io. Cette installeur prend en charge différents outils comme un client ssh et sa propre console Unix. Vous n'aurez donc pas à utiliser la console Windows. Pour l'utilisation de git vous devrez seulement ouvrir la nouvelle console que vous avez installée et rentrer les commandes décrites dans ce tutoriel.
## Démarrer Git
Pour commencer on va configurer Git, pour cela on va enregistrer notre nom et notre adresse mail dans git. Cela est très important lorsqu'on travail à plusieurs sur un même projet. Ça permet de savoir qui a fait telle modification. Donc pour ce faire, vous rentrerez les commandes suivantes :
```bash
git config --global user.name "Prénom NOM"
git config --global user.email prenom.nom@ensta-paristech.fr
```
Pour initialiser Git et lui demander de suivre un projet, vous devez vous placer dans le repertoire où se situe le projet et taper la commande :
```b
git init
```
Voilà, Git est initialisé et est près à suivre votre projet. Pour vous en convaincre, vous pouvez taper dans la console : `ls -al`. Vous verrez que git a créé un dossier caché nommé .git qui enregistrera les informations sur votre projet.
Il est également possible de recupérer le projet Git de quelqu'un d'autre via Github ou un Gitlab, mais nous en parlerons dans le paragraphe sur la mise en ligne des repositories Git (ce qu'on appelle repository est l'ensemble du projet git qui contient les fichiers / dossiers du projet ainsi que toutes leurs versions).
## Vers un premier commit
Comme je vous l'ai expliqué, un commit représente l'état du projet à un instant donné. Ainsi, les commits représentent une progression linéaire de votre projet.
<div style="text-align:center">
</div>
Mais avant de faire un commit, il faut impérativement demander à git de surveiller les fichiers que l'on a modifiés ou créés. Pour faire cela, on va utiliser la commande :
```bash
git add nomDeMonSuperFichier
```
Il faut procéder de même pour tous les fichiers du projet. Pour aller plus vite, on peut rentrer les noms de différents fichiers à la suite : `git add monFichier1 monFichier2 monFichier3`. On peut également ajouter tous les fichiers, les dossiers et les sous dossiers du repertoire courant avec la commande
```
git add .
```
Cependant, il faut faire attention avec cette commande car elle ajoute TOUS les fichiers et dossiers dont d'éventuels fichiers de cache et de configuration qu'on ne veut ni archiver ni partager. Lorsqu'on utilise cette commande, le mieux est de créer un fichier `.gitignore` à la racine du projet dans lequel on va indiquer les fichiers qui ne seront pas suivis par git.
Après avoir demandé à git de suivre nos fichiers, il est temps de faire notre commit. C'est à dire notre première version du projet. Pour cela on va utiliser la commande :
```
git commit -m "message du commit"
```
Comme vous pouvez le constater cette commande reçoit l'option "-m" qui permet d'inclure le message de commit dans la ligne de commande. En effet, chaque commit doit être accompagné d'un message. En ne mettant pas cette option : `git commit` Git lance un editeur de texte pour ecrire le message de commit, par default il lance nano sur linux.
## Savoir où on en est
Il peut arriver que l'on ne sache plus trop où on en est, qu'est ce qu'il y a été commit, qu'est ce qui ne l'est pas, quels fichiers sont suivis. Pas de panique on a la commande :
```
git status
```
On dispose également de la commande :
```
git log
```
Qui nous permet d'obtenir un historique des commits.
```
commit dc39b7b453cec8205311515bbcf6b05178a1f2d7
Author: Guillaume LEROY
Date: Sat Feb 6 11:14:37 2016 +0100
worked on profile design
commit 2001a2486feddc96a3095d0b7ad7d8b8961c51e7
Author: Guillaume LEROY
Date: Sat Feb 6 10:13:29 2016 +0100
Add cssgram effect on banner
commit 21921dc2f8df47eac424a8cf25482020a732bf36
Author: Guillaume LEROY
Date: Thu Feb 4 19:12:36 2016 +0100
add image
commit d6e433ab7420c099e1835a0fdb230f912c8fd468
Author: Guillaume LEROY
Date: Thu Feb 4 18:41:42 2016 +0100
add some design improvement
commit cb8eb2dc3f4fbe77ca67008ac8fed2936237b1a7
Author: Guillaume LEROY
Date: Thu Feb 4 18:31:26 2016 +0100
event design
```
## Naviguer dans les commits
Vous avez du remarquer avec la commande `git log` mais à chaque commit est associé un identifiant unique. Cette identifiant va nous être utile pour nous placer sur un commit en particulier avec la commande :
```
git checkout identifiant_du_commit
```
Cette commande nous permet de retrouver notre projet tel qu'il était après le commit en question.
Pour revenir au commit le plus récent, utilisez :
```
git checkout master
```
## Les branches : un workflow en parallèle.
Je vous avez parlé en introduction de la possibilité de développer plusieurs versions du projet en parallèle. Cela est particulièrement utile lorsqu'on travail à plusieurs sur des fonctionnalités différentes. Cela permet de travailler chacun de son coté sans déranger son colègue.
Pour créer une nouvelle branche, on va utiliser la commande :
```
git branch nomDeMaBranche
```
On peut alors naviguer de branche en branche avec :
```
git checkout nomDeMaBranche
```
Pour connaitre le nom des branches disponibles :
```
git branch
```
## La fusion des branches
Lorsque chacun a fini de travailler sur sa branche, il faut remettre en commun le travail. Pour cela on procède à une fusion des branches.
On se place sur la branche où on veut que le travail commun soit enregistré, ici master :
```
git checkout master
```
Et on procède à la fusion :
```
git merge nomDeMaBranche
```
Si tout se passe bien il procède à la fusion et vous signal que tout s'est bien déroulé. Mais il peut arriver qu'il vous annonce qu'il y a eu un conflit lors de la fusion. Il faut alors résoudre ces conflits à la main. Vous devez vous rendre dans tous les fichiers où des conflits ont été signalés et choisir la bonne solution.
Lorsqu'on edit un fichier où il y a eu un conflit, on a :
```
<<<<<<< HEAD:index.html
<div id="footer"> contact : email.support@github.com </div>
=======
<div id="footer">
please contact us at support@github.com
</div>
>>>>>>> prob53:index.html
```
On fait alors notre choix en effaçant ce qui ne nous convient pas, par exemple :
```
<div id="footer" >contact : email.support@github.com </div>
```
## Partager votre code avec github ou gitlab
Je vous avais annoncé que Git nous permet de partager notre code avec d'autres personnes. Mais pour l'instant je vous ai juste présenté une utilisation de git en local. Nous allons maintenant voir comment partager notre travail, comment récupérer le travail de quelqu'un d'autre ...
Le travail effectué sur git est partagé via des plateformes en ligne disponibles sous la forme de site web. La plus connue est github. Dans ce tutoriel, je détaillerais l'utilisation du serveur gitlab de DaTA.
Pourquoi le serveur gitlab ? Je pourrais en effet vous présenter github mais cette plateforme propose de n'héberger gratuitement que des projets libres. Ainsi tout le code que vous enregistrerez sur github pourra être lu par tout le monde. Il est possible d'héberger un projet sans le laisser ouvert à tout le monde mais il faut pour cela payer un abonnement. C'est pour cette raison que nous favoriserons le serveur gitlab de DaTA qui nous permet d'héberger gratuitement nos projets et d'en controler l'accès.
Vous pouvez vous connecter au gitlab à l'adresse : gitlab.data-ensta.fr
<div style="text-align:center">
</div>
Pour s'identifier il suffit alors de cliquer sur le bouton connexion. Vous arrivez alors sur le dashboard où se trouve un historique de toutes les dernières modifications qui ont été faites. Vous pouvez également vous rendre sur la page de chaque projet auquel vous avez accès.
Il existe deux protocoles pour échanger des fichiers entre votre PC et le serveur gitlab : le HTTPS et le SSH : c'est le SSH que je vais utiliser car il est beaucoup plus pratique : en effet, une fois configuré, il permet de ne pas avoir à entrer son identifiant et son mot de passe à chaque opération.
### Création d'une clé SSH
Vous allez donc dans un premier temps créer une clé SSH sur votre PC (sauf si vous en avez déjà créé une...) en exécutant la commande suivante :
```
ssh-keygen -t rsa
```
Laissez toutes les options par défaut en validant 3 fois par entrée.
Exécutez ensuite la commande suivante pour afficher votre clé SSH :
```
cat ~/.ssh/id_rsa.pub
```
La clé SSH doit ressembler à ça, sélectionnez-là en entier et copiez-là (clic droit -> copier) :
```
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDNTf4vaeP1RQOocLtYjqpSWqzep/19hqR7yD0Td5MA92e0rKy55A5MktgrWi84S5Y8B16O6RxMkQzbC++2+UxSAxWOZwnTd1kmMHvP8Ch/h8L/C1UAH8BhOtMNYrxi5JtKk3836/BJv5arMkutVK2Op67SIbxknzRNesWVIEqDax11FVVyFcjtly0CxXurmzdzWEe+E7k0mlFpisWLw4gsiV9B8fT2QlTNYoZtX4S7zg7u/FmXcuu0te0m2c9zePjKwLfoP3TL4uPkwm/18b2zbLsvaqtQW0hlPu39PF7btoHgy9dhCOy+eYouWkt8TwM0FtGv22xaCWUyp1XvHfuN moi@mon_pc
```
Rendez-vous ensuite sur le gitlab de DaTA dans les paramètres de votre profil pour ajouter votre clé SSH (celle-ci permettra de vous identifier). Donnez-lui un titre et collez la clé SSH précédemment copiée :
<div style="text-align:center">
</div>
Cliquez enfin sur `Add key`.
Voilà ! Votre clé SSH est maintenant configurée, vous êtes tranquille pour la suite !
### Échanger des fichiers avec le serveur gitlab
Pour récupérer un projet sur votre PC depuis le serveur gitlab, et pouvoir travailler dessus, vous devez utiliser l'adresse SSH de celui-ci et entrer la commande :
```
git clone git@gitlab.ensta.fr:user/mon_projet.git
```
Il peut aussi, dans certains cas, être intéressant de ne cloner qu'une branche particulière avec la commande :
```
git clone -b maBranch git@gitlab.ensta.fr:user/mon_projet.git
```
Vous pouvez alors travailler sur le projet, modifier vos fichiers, faire vos commits ... Une fois que vous avez fini votre travail, vous pouvez envoyer toutes vos modifications sur le serveur avec la commande :
```
git push
```
De façon similaire, vous pouvez récupérer le travail de quelqu'un d'autre avec la commande :
```
git pull
```
Il peut arriver qu'un push ou un pull provoque un conflit comme lors d'un merge. Il faut alors résoudre ce conflit à la main comme on l'a déjà vu.