
L'objectif est de vous initier à l'utilisation minimaliste d'un gestionnaire de version. Ici git.
Un gestionnaire de version permet à plusieurs personnes de contribuer sur un code ou un document partagé sans avoir à gérer d'échange de fichiers et de changement de version à la main.

Un gestionnaire de version permet:
1- De sauver l'intégralité des modifications d'un projet et de toujours pouvoir revenir en arrière si nécessaire.
2- De partager l'édition d'un code entre plusieurs personnes par le biais d'un serveur en ligne.

Par rapport aux outils classiques de partages existants les avantages sont les suivants:
- Par rapport à un répertoire partagé (type dropbox, mega, etc), la mise en commun est réalisée automatiquement et un même fichier peut être édité par plusieurs personnes en même temps. Pas de risque d'écrasement d'une version par une autre personne.
- Par rapport à un outil d'édition de document collaboratif (google doc, framadoc, etc), il est possible de gérer un nombre quelconque de fichier de type générique (code, image, texte, etc...) et non pas sur un unique document de type Word/LibreOffice. De plus, chaque personne peut travailler sur une version locale et propager ses modifications uniquement lorsqu'il le souhaite et non pas forcément en temps réel.

Les outils de gestion de version git (ou svn) sont la essentiels pour le travail en commun sur les projets informatiques.


Afin d'utiliser tous les avantages de git, il est intéressant de pouvoir placer son code en ligne sur un serveur.
Plusieurs solutions "clés en main" existent. L'une est particulièrement rependue actuellement: "github"
Github permet de placer ces projet git en ligne de manière publique gratuitement, et permet de collaborer à plusieurs sans avoir à gérer soit même son serveur.

Ce tutoriel vous propose d'utiliser github pour placer un code avec gestion de version en ligne. Gardez à l'esprit que bien que github soit particulièrement populaire pour les projets opensource, vous n'avez pas d'obligation à passer par ce service, surtout pour des données critiques. Tout comme de nombreux services collaboratifs gratuits, une entreprise gère vos code et les informations que vous lui fournissez.




======================================
=== Création d'un dépot git local  ===
======================================

- Initialisez un nouveau répertoire pour votre projet.
git init project

> Cela initialise un dépôt git locale sur votre machine.

- Créez un fichier main.cpp dans ce répertoire project/, et placez y un code minimaliste affichant un message en ligne de commande.

- Ajoutez ce fichier à git
git add main.cpp

- Mettez à jour votre dépôt git par un commit afin de prendre en compte l'ajout du fichier main.cpp.
git commit -a -m "mon premier commit"

Notez que cette étape de commit sera à réaliser à chaque fois que vous souhaitez sauvegarder dans la base du suivi de version vos modifications.

Au bout de cette étape, vous disposez d'un projet suivi par git localement. Nous allons placer ce projet en ligne afin que plusieurs utilisateurs puissent y accéder depuis des comptes ou des machines différentes.

=========================================
=== Création d'un dépot git en ligne  ===
=========================================

- A l'aide d'un navigateur internet, créez un compte (si vous n'en avez pas) sur github: https://github.com

Rem. Une documentation sur le "ba-ba" de la création de dépot sous github est disponible ici:
Aide github: https://guides.github.com/activities/hello-world/

- Creez un nouveau projet publique (new repository) avec les options par défauts.

- Indiquez l'adresse de votre projet en ligne sur github
git remote add origin https://github.com/[LOGIN_GIT]/[DIRECTORY].git
(l'adresse étant celle de votre navigateur)

- Envoyez votre projet git en ligne:
git push -u origin master
(vous aurez besoin de votre login et mot de passe)

> Vérifiez que votre projet apparaît bien en ligne dans votre répertoire sur github.



============================================
=== Mise en ligne de modification (Push) ===
============================================

- Modifiez votre main.cpp en ajoutant une nouvelle ligne affichée en ligne de commande.

- Mettez à jour votre dépot git locale sur la machine
git commit -a -m "ma seconde modification"

> Notez qu'à ce moment, votre dépôt git locale est à jour, mais que celui en ligne sur github est toujours à la version précédente.

- Envoyez vos modifications sur le dépot en ligne
git push

> Vérifiez désormais en ligne que votre modification a été prise en compte.

==================================================
=== Récupération de la version en ligne (Pull) ===
==================================================

- Editez désormais en ligne votre fichier (icone en forme de stylo) en modifiant une des phrase affichée.
Puis réalisez un commit (dans le navigateur avec le bouton en bas de la fenêtre après avoir indiqué un commentaire)

> Notez que le fichier en ligne est différent de votre fichier main.cpp en locale sur votre machine.

- Récupérez la version en ligne de votre projet
git pull

> Vérifiez que désormais, votre fichier main.cpp a été modifié.

==================================================
=== Modification par une autre personne        ===
==================================================

- Créez un compte autre github pour votre binome.

- Dans l'ongle Settings de votre projet, dans l'option Collaborators: ajoutez votre binome.

- Déloguez vous de votre compte à CPE, et faite en sorte que votre binome se logue avec son compte.

- Récupérer le projet existant sous le nouveau compte:
git clone https://github.com/[LOGIN_GIT]/[DIRECTORY].git (avec l'adresse du projet déjà créé)

- Modifiez le fichier main.cpp, ou créez un nouveau fichier et ajoutez le au dépot git (git add ...)

- Réalisez un commit sur le dépot git locale.

- Uploadez la version modifié du code
git push


A ce stade, les deux comptes peuvent accéder, travailler et mettre à jour en parallèle les fichiers de ce dépôt depuis des postes différents.

Rappels des commandes:

# Mettre à jour le dépot git locale sur la machine (a faire après chaque modification de code, ou ajout/suppression de fichier).
git commit -a -m "message de commentaire" 

# Mettre à jour le dépot git en ligne
git push

# Récupérez la version du code en ligne
git pull


Généralement, une édition se déroule de la manière suivante:
1- On s'assure que son code soit à jour (git pull)
2- On modifie le code localement
3- On commit les modifications sur la base locale (git commit)
4- On envoie les modifications sur le dépot en ligne (git push)



Les modifications peuvent avoir lieu en même temps si les zones modifiées sont différentes (typiquement fichier différent, fonctions différentes).
La mise en commun se réalise automatique lors des push/pull successifs.

Si par contre, une ou plusieurs zone commune a été modifié par plusieurs personnes, un conflit apparaît lors du push/pull.
Il est alors nécessaire de décider si:
1- Sa propre modification est gardée à la place de celle du dépôt en ligne.
2- La modification du dépôt en ligne est gardée à la place de la sienne.
3- Un mix est réalisé avec les deux propositions fusionnées.

Plus de documentation est disponible pour la gestion des conflits.
Des gides spécifiques à github sont disponible ici: https://guides.github.com/

