Cours au département INFO - IUT - UNS

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== TD sur le contrôle de version (Hands-on Git) ======
Basé sur le TD élaboré par** Cyril Cecchinel** 

Et l'aide de [[https://openclassrooms.com/courses/gerez-vos-codes-source-avec-git|Open Classroom]]
pour gérer les configurations.

===== Objectifs du TD : =====
  * Découvrir les concepts du contrôle de version
  * Développer de manière collaborative
  * Utiliser Git comme outil de contrôle de version

Un logiciel de contrôle de version permet de conserver un historique des modifications apportées sur des fichiers tout en offrant la possibilité de revenir à une version antérieure. Il existe des logiciels de contrôle de version centralisés et décentralisés.

Dans le cadre des cours de //Conception et de Méthodologie de la production d’applications//, nous allons utiliser Git.



====== AVANT TOUT======
En ligne de commande avec l'outil Git: Lancez la commande:
<code> git config --global http.sslVerify false </code>

Retrouver le fichier de configuration ''.gitconfig'' situé dans votre répertoire personnel.

Visualiser son contenu.
Si besoin, configurer GIT pour que les commits se fassent bien à votre nom : 
<code> git config --global user.name "prenom Nom"</code>

Puis votre e-mail :
<code> git config --global user.email moi@email.fr</code>

===== Créer un nouveau dépôt =====

Pour commencer à travailler avec Git, il y a deux solutions :
  * soit vous créez un nouveau dépôt vide, si vous souhaitez commencer un nouveau projet ; 
  * soit vous clonez un dépôt existant, c’est-à-dire que vous récupérez tout l’historique des changements d’un projet pour pouvoir travailler dessus.

Pour l'instant, nous allons prendre la 1e option. Mais par la suite, vous travaillerez de manière collaborative et donc nous prendrons la 2e option.

A Noter, que si vous travaillez sous Github ou BitBucket, en général, on crée le dépôt sur le site puis on le clone.

  - Créer un répertoire '' myRepo'' (c'est le répertoire où vous voulez travailler).
  - Initialiser le dépôt : <code> git init </code>


===== Git comme historique des modifications =====

   -  	Créer un fichier ''Menu.txt'' contenant les plats de votre restaurant favori, ligne par ligne. <code>
Salade norvégienne
Œufs fauchés
Steak tartare
Filet de dorade
Profiteroles
</code>
  - Comment interprétez-vous le résultat de la commande suivante <code> git status </code> 
  - Ajoutez le fichier ''Menu.txt'' comme git vous l'a dit : <code> git add Menu.txt</code> 
  - Réinterprétez le résultat de la commande ''git status''.
  - Le fichier ''Menu.txt'' est maintenant prêt à être versionné. <code> git commit -m "construction de la carte" </code> **ou** <code> git commit </code> ((Un éditeur s'ouvre qui dépend de votre configuration. S'il ne vous convient pas, vous pouvez le configurer par exemple <code> git config --global core.editor emacs </code>)) Quel message avez-vous en retour?
  - Que donne la commande git status ? 
  - 	Apportez quelques modifications au fichier ''Menu.txt''. Essayez de commiter ces modifications. Que se passe-t-il ? En vous aidant de la documentation accessible en tapant git help commit, versionnez ces modifications (avec un message décrivant le changement) (( Au lieu d'un git add suivi d'un git commit vous pouvez préférer <code> git commit -a -m "ajout des aubergines"</code> ))
  - 	Affichez l’historique des modifications du dépôt. <code> git log </code> Et pour voir les modifications apportées par le dernier commit <code> git log -p  -1 </code> et savoir qui fait quoi <code> git log --stat </code> ou <code> git log --pretty=format:"%h - %an, %ar : %s"</code> **etc.**
  - 	En utilisant ''git diff'' , visualisez les modifications effectuées entre le premier commit et le second commit. Par exemple <code> git diff 71cfcd6 0c24491 </code>. Attention l'ordre des commits modifie le résultats (un- devient un +).
  - 	Modifiez plusieurs fois le Menu afin d’en plusieurs versions. 
  - Le dernier plat ajouté ne vous plait finalement pas. Il existe deux manières de revenir à une version antérieure : de manière temporaire ou définitive.
  - Exécuter ''git log'' et récupérez le hash (HASH) du commit où vous souhaitez revenir en arrière.
         - Pour revenir en arrière de manière temporaire, exécutez <code> git checkout HASH</code>
              -  Vérifiez que votre fichier Menu.txt est dans son état antérieur. 
               - Revenez au dernier commit (HEAD) en exécutant <code> git checkout master</code>
         - Pour revenir en arrière de manière définitive, et donc supprimer tout ce que vous avez fait depuis ce moment : <code> git reset --hard HASH </code>
               - Dans git log, vérifiez que tout ce que vous aviez effectué depuis ce commit a été effacé. 



===== Branches de développement =====

Sauf indication contraire, vous ajouterez les plats séquentiellement dans le menu (les uns après les autres).

Vous êtes chargé(e) d’introduire des plats végétariens dans le menu du restaurant. Ces plats n’ayant pas encore été validés par la cuisine et la direction du restaurant, vous souhaitez travailler sur la carte sans casser la carte existante. La notion de branche permet de passer instantanément d’une version « stable » (branche « master » créée par défaut) du projet à une « version en cours de développement » (n’importe quelle autre branche que « master »)

  - Jusqu'ici vous avez travaillé sur une seule branche « master » : c’est la branche principale, celle qui en général contient le « vrai » code source de votre projet. Pour voir toutes vos branches <code>git branch </code> ((Vous vous demandez quand créer des branches, regardez [[https://openclassrooms.com/courses/gerez-vos-codes-source-avec-git#/id/r-1234195|ici]] ))
  - Créez une branche « vegetarien » dans votre dépôt Git. <code> git branch vegetarien </code> 
  - Vérifiez que vous êtes bien dans la branche Master par la commande <code>git branch </code> 
  - Basculez dans la branche vegetarien <code> git checkout vegetarien</code> 
  - Vérifiez dans quelle branche vous êtes
  - Ajoutez deux/trois plats végétariens au menu et commitez au fur et à mesure les modifications. 
  - Fermer votre fichier.
  -	 Observez l’historique des modifications du dépôt, que remarquez-vous ?
  -	 Revenez à la carte principale (branche « master ») et observez l’historique des modifications, que remarquez-vous ?
  -	 Ajoutez un plat non-végétarien au menu de la branche master. Commitez la modification.
  -	 Le cuisinier et le directeur du restaurant sont satisfaits de vos propositions de plat et souhaitent maintenant les ajouter au menu principal. Fusionnez (« merge ») la branche « vegetarien » à la branche « master ». <code>git merge vegetarien </code>  Que se passe-t-il ? Ouvrez le fichier Menu.txt et vérifiez que la fusion s'est bien passée.
  -  Créez une branche « japonais » <code> git checkout -b japonais </code>
  - Ajoutez des plats japonais en commitant au fur et à mesure les modifications et retirer des plats de viande.
  - Revenez sur la branche « master » et fusionnez la branche « japonais ». Regardez le contenu du fichier Menu.txt et l’historique de modifications du dépôt. Y a-t-il eu un conflit ? Pourquoi ?
  - Si vous avez un conflit,  résolvez le conflit de manière à ajouter tous les plats situés entre les balises de conflit (<<<<< et >>>>>). Commitez le changement (et donc la fusion) en tapant « git commit –a »
  - Modifiez le contenu de la branche japonais.
  - Supprimer la branche japonais. Que se passe-t-il? <code> git branch -d japonais </code>
    - Supprimez les branches « vegetarien » et « japonais ».

===== Synchronisation de votre répertoire =====


Jusqu’à présent, vous avez pu expérimenter Git pour gérer localement vos versions. Nous allons maintenant nous intéresser au développement collaboratif de fichier sources. Pour cette partie, mettez vous avec votre groupe de méthodologie.

  -	Si votre dépôt est vide, UN étudiant : 
       -  Récupérer l'adresse **https** de votre dépôt (onglet dépôt à droite) 
       - En vous plaçant dans le bon répertoire :   <code> 
git init
touch readme.txt
git add readme.txt
git commit -m 'Initializing depot repository'
git remote add origin URL
git push -u origin master
</code>
     - Visualisez les références distantes <code> git remote </code> La nouvelle référence à ''origin'' vient de la ligne de commande ''git remote add [nomcourt] [url]''
     - Visualisez les URL associées aux références distantes <code>git remote -v </code>
  -	(TOUS) En suivant les[[ https://forge-iutinfo.unice.fr/|instructions de la Forge IUT]], clonez le dépôt git associé à votre groupe. 
                - Récupérer l'adresse **https** de votre dépôt (onglet dépôt à droite) 
                - Cloner <code> git clone URL</code>
  -  Placez vous dans le dépot.
  -	Chaque personne du groupe participe : 
       - **(Personne A)** 
             - Créez un fichier index.html reprenant le code ci-dessous : <code html>
<html>
<head>
<title>Demo</demo>
</head>
<body>
</body>
</html>
</code>
             - Ajoutez le fichier au dépôt git et commitez le fichier. Envoyez ensuite le commit vers le dépôt distant : <code> git push origin master</code>
       - **(Tous sauf  A)** 
            - Visualiser l'état du dépôt distant <code> git remote show origin </code>
            - Synchroniser votre dépôt git avec la commande <code> git pull </code>
  -	(Un développeur autre que A) 
        - Modifiez le fichier index.html afin d’ajouter du texte entre les balises body. 
        - Commitez les modifications et envoyez-les vers le dépôt distant.
  -	(TOUS) Synchroniser votre dépôt git avec la commande ''git pull''.
  -	 (Personne A) 
        - Modifiez le titre de la page Web et 
        - commitez/envoyez les modifications.
  -	(Personne B) (SANS SYNCHRONISER LE DEPOT) 
        - Modifiez le titre de la page Web 
        - commitez/envoyez les modifications. Que se passe-t-il ? Remédiez au conflit.

===== Tags =====

Git donne la possibilité d’étiqueter un certain état dans l’historique comme important grâce à un « tag ». Ces tags sont couramment utilisés pour marquer des états de publication (//e.g//. v1.0, v1.1, …). 
Deux types de tags sont disponibles :
   * Les tags légers : un pointeur sur un commit spécifique
   * Les tags annotés : stockés sous forme d’objets, ils contiennent une somme de contrôle, le nom et l’email du créateur, la date de création, un message et éventuellement une signature GPG.
Dans le cadre de cette matière, nous utiliserons que des tags légers. Pour plus d’informations sur le mécanisme de tags annotés, voir les ressources.

  -	Reprenez votre fichier « Menu.txt » et apportez-y des modifications. La nouvelle version obtenue correspondra à la carte qui sera publiée au guide Michelin 2017. Pour marquer cette importance, nous allons associer le tag « michelin » au prochain commit : Créez une étiquette ‘michelin17’ <code> git tag michelin17</code>
  -	 Listez les étiquettes disponibles <code> git tag </code>

Attention !  Les tags ne sont pas poussés automatiquement sur un serveur distant. Il faut demander explicitement à pousser les étiquettes après les avoir créées localement (cf. cheat sheet) ou utiliser l’option –-tags 

===== Cheat-Sheet =====

==== Création/Synchronisation ====

  * Création d’un repo Git local
<code> $ git init myRepo 
Initialized empty Git repository in /private/tmp/myRepo/.git/
</code> 
  * Cloner un repo Git distant
<code>  $git clone <URL du repo Git à cloner> </code>
  * Ajouter une cible (ie. Un serveur distant) – cette opération est implicite si le repo a été initialisé avec git init
<code>$ git remote add origin <URL du repo Git></code>
  * Pousser les commits locaux de la branche master sur un serveur distant (origin)
<code> $ git push master origin</code>
  * Se synchroniser avec un serveur distant (ie. Récupérer les commits distants)
<code> $ git pull</code>

==== Commiter des modifications ====


  * Afficher l’état courant du repo local
<code> $ git status </code>

   * Versionner un nouveau fichier
<code> $ git add <Fichier à ajouter> </code>

   * Commiter un état courant avec un message de commit
<code> $ git commit -m "Premier commit"
[master (root-commit) b992814] Premier commit
 1 file changed, 5 insertions(+)
 create mode 100644 Menu.txt
</code>
   * Afficher l’historique du repo
<code> $ git log
 </code>
==== Utiliser des branches ====

  - Créer une branche
$ git checkout -b vegetarien
Switched to a new branch 'vegetarien'

  - Basculer sur une branche existante
$ git checkout  master
Switched to branch 'master'


  - Supprimer une branche existante
$ git branch –d japonais

  - Lister les branches existantes
$ git branch
  master
* vegetarien

  - Merger (i.e. fusionner) une branche dans la branche courante
$ git merge vegetarien

==== Les tags ====


  * Créer un tag léger
<code> $ git tag michelin17 </code>

  * Lister les tags
<code> $ git tag
michelin17
</code>

  * Pousser un tag sur un serveur distant
<code> $ git push origin michelin17
Total 0 (delta 0), reused 0 (delta 0)
To https://github.com/ulrich06/TD_Git.git
  - [new tag]         michelin17 -> michelin17
</code>
  * Pousser tous les tags sur un serveur distant
<code> git push origin --tags </code>

==== Ressources ====


  * Pro Git, Scoot Chacon and Ben Straub https://git-scm.com/book/fr/v1
  * Prise en main de Git : http://www-igm.univ-mlv.fr/~dr/XPOSE2008/git/
  * Learning Git in 15 minutes : https://try.github.io/levels/1/challenges/1
  * A successful git branching model : http://nvie.com/posts/a-successful-git-branching-model/
  * L’étiquetage : https://git-scm.com/book/fr/v1/Les-bases-de-Git-%C3%89tiquetage
  * [[https://stackoverflow.com/questions/2745076/what-are-the-differences-between-git-commit-and-git-push/2745097#2745097|What are the differences between “git commit” and “git push”?]]

// That’s all folks