Gestion de version avec git

Avant-propos

Pour suivre en live…​

http://bit.ly/jmb-git

http://jmbhome.github.io/teaching/topics/git.html

Environnement

sourcetree
https://www.sourcetreeapp.com
git term

Principes généraux

git branching
http://nvie.com/posts/a-successful-git-branching-model/

Avant de commencer

On initialise certaine variables (une fois pour toute en général) :

$ git config --global user.name "JM Bruel"
$ git config --global user.email jbruel@gmail.com
$ git config --global alias.co checkout

 

Ces informations sont stockées dans le fichier ~/.gitcongif.

Voici un extrait du mien :

[user]
        name = Jean-Michel Bruel
        email = jbruel@gmail.com
[alias]
        co = checkout
        st = status

Ce qui donne :

$ git co
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)
$ git checkout
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

Scénario classique (et idéal)

Etape 1 : création du repository local

On démarre la gestion de version :

$ git init

Génération d’un répertoire .git dans le répertoire courant.

$ git init
Initialized empty Git repository in /tmp/.git/

$ ll
total 0
drwxr-xr-x   3 bruel  admin   102 21 jul 17:29 ./
drwxr-xr-x  35 bruel  admin  1190 21 jul 17:29 ../
drwxr-xr-x  10 bruel  admin   340 21 jul 17:29 .git/

Etape 2 : ajout des fichiers

On ajoute les fichiers courants au dépôt :

$ git add .
  • Ne pas forcément tout ajouter (git add *.c par exemple pour ne versionner que les sources).
  • Pensez à créer un fichier .gitignore pour éviter d’ajouter les fichiers indésirables (comme les fichiers de log).

Etape 2 (suite) : vérification

On peut visualiser les actions en vérifiant l'état courant du dépôt :

$ git status
# On branch master
# Your branch is ahead of 'origin/master' by 1 commit.
#
# Changes not staged for commit:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   Generalites.txt
#	deleted:    S3/128056_56.d
...

Etape 3 : Commit

Pour entériner les changements :

$ git commit -m "First draft"
[master (root-commit) 4f40f5d] First draft
 0 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 titi.txt
 create mode 100644 toto.txt
  • Retenez que le commit est uniquement local!
  • Mais même en local, il est bien utile en cas de problème.

Etape 3 (suite) : Gestion "locale"

Exemple de scénario type (suppression exceptionnelle et rattrapage) :

$ rm titi.txt
$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	deleted:    titi.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

$ git checkout -f
$ ls titi.txt
titi.txt

Etape 4 : Trouver un hébergement distant

Il existe de nombreux endroits disponibles pour héberger du code libre. Les plus connus sont GitHub et GitLab.

github

Etape 4 (suite) : déclarer le dépôt distant

Après avoir créé un dépôt distant, il n’y a plus qu’à associer ce dépôt distant avec le notre.

$ git remote add origin git@github.com:jmbruel/first_app.git (1)
$ git push -u origin master (2)
Counting objects: 3, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 225 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To git@github.com:jmbruel/first_app.git
 * [new branch]      master -> master
Branch master set up to track remote branch master from origin.
1Il est possible d’avoir plusieurs dépôts distants, celui-ci sera référencé par origin.
2L’option -u origin master permet d’associer une fois pour toute les git push suivants au fait de "pousser" sur la branche master du dépôt origin (comme l’indique la dernière ligne).

Etape 5 : branch, edit, commit, merge

En cas d’édition et de commit local :

$ git checkout
Your branch is ahead of 'origin/master' by 1 commit.

Etape 5 (suite) : branching

est très bon pour créer des branches :

$ git checkout -b testModifTiti
Switched to a new branch 'testModifTiti'
$ git branch
  master
* testModifTiti (1)
1La branche courante est repérée par un *.

Etape 5 (suite) : edit

Après modification :

$ git status
# On branch testModifTiti
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   titi.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

Etape 5 (suite) : commit

On "sauvegarde" les changements :

$ git commit -am "modif de titi"
[testModifTiti 4515b5d] modif de titi
 1 files changed, 7 insertions(+), 0 deletions(-)
  • On ne "sauvegarde" qu’en local!

Etape 5 (suite) : utilisation des branches

On peut "zapper" d’une branche à l’autre à volonté :

$ ll titi*
-rw-rw-r--    1 bruel  staff   331 12 nov 12:39 titi.txt

$ git co master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 1 commit.

$ ll titi*
-rw-rw-r--    1 bruel  staff     0 12 nov 12:40 titi.txt

Etape 5 (suite) : merge

Maintenant que la branche a été développée (testée, etc.) on peut l’intégrer à la branche principale :

$ git co master
Switched to branch 'master'

$ git merge testModifTiti
Merge made by recursive.
 titi.txt |    7 +++++++
 1 files changed, 7 insertions(+), 0 deletions(-)

 

  • On peut ensuite détruire la branche devenue inutile git branch -d testModifTiti.
  • C’est une bonne habitude à prendre.
  • Notez que l’historique des modifications (ainsi que les messages de commits successifs ne sont pas perdus).

Etape 6 : push

Maintenant que notre dépôt est satisfaisant, on peut le synchroniser avec le dépôt distant :

$ git push
Counting objects: 11, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (9/9), done.
Writing objects: 100% (9/9), 977 bytes, done.
Total 9 (delta 2), reused 0 (delta 0)
To git@github.com:jmbruel/first_app.git
   6103463..3aae48a  master -> master

Etape 7 : pull request (demande)

Etape 7 (suite) : pull request (acceptation)

$ git checkout -b develop origin/develop
$ ...                       (1)
$ git checkout master
$ git merge --no-ff develop (2)
$ git push origin master    (3)
1Vérifiez ce qui va être intégré
2On merge localement pour gérer les problèmes
3On pousse sur master

Dépôts existants

Si vous devez partir d’un dépôt existant :

$ git clone git@github.com:jmbruel/first_app.git
  • Pour obtenir le nom du dépôt distant : git remote -v.
  • Vous avez aussi le nom du dépôt distant dans le fichier .git/config.

Illustration des branches

Voici une illustration de l’utilisation des branches (tirée de git-scm).

On part d’une situation type :

gf1

Illustration des branches (suite)

On crée une branche (appelée iss53 ici pour indiquer qu’elle traite de l'issue numéro 53) :

$ git checkout -b iss53
gf2
  • n’a créé qu’un pointeur ⇒ aucun espace mémoire perdu.

Illustration des branches (suite)

On modifie et on commit :

$ edit ...
$ git commit -m " blabla iss53"
gf3
On commence à diverger de master

Illustration des branches (suite)

On revient à la branche maître pour tester une autre solution :

$ git checkout master
$ git checkout -b hotfix
$ edit ...
$ git commit -m " blabla hotfix"
gf4

Illustration des branches (suite)

On intègre cette solution à la branche principale :

$ git checkout master
$ git merge hotfix
gf5
Il manque le pointeur HEAD sur mes illustrations
  • utilise ici le fast-forward

Illustration des branches (suite)

On continue à travailler sur la branche iss53 :

$ git branch -d hotfix (1)
$ git checkout iss53
$ edit ...
$ git commit -m " blabla iss53"
1Destruction de la branche devenue redondante avec master.
gf6
On retravaille sur iss53

Illustration des branches (suite)

On intègre cette branche :

$ git checkout master
$ git merge iss53
gf7
Merge sans fast-forward

Illustration des branches (suite)

gf8
Situation finale
  • On part du principe qu’il n’y a pas eu de Gestion des conflits
  • On peut maintenant supprimer iss53

Bonne utilisation

Avoir une procédure concertée

Revenons sur l’exemple type :

git branching

Ne pas versionner n’importe quoi!

Ce qu’il ne faut pas versionner :

Les "releases"

En on peut taguer des branches et c’est ce mécanisme qui permet de gérer simplement les releases.

$ git tag -a v1.0 -m "Release 1.0 as required by client"
$ git tag
v1.0

 

On peut voir les détails d’un commit tagué :

$ git show v1.0
tag v1.0
Tagger: Jean-Michel Bruel <jbruel@gmail.com>
Date:   Fri Sep 16 14:27:20 2016 +0200

Release 1.0 as required by client

commit 47da474098d95f8ef5c3ca838be8b87d7a7ed729
Author: Jean-Michel Bruel <jbruel@gmail.com>
Date:   Fri Sep 16 12:38:20 2016 +0200

 

On peut aussi taguer a posteriori :

$ git tag -a v1.2 9fceb02 (1)
1ajoute le tag v1.2 au commit dont le [SHA-1] commence par 9fceb02

Par défaut les tags ne sont pas poussés sur le dépôt distant.

$ git push origin v1.5

La gestion de version n’est pas un long fleuve tranquille

Oups! j’ai oublié un truc

$ git commit -m 'initial commit'
$ git add forgotten_file
$ git commit --amend

Oups! j’ai mis trop de truc

$ git add *.*
$ git reset *.class
Aucun danger

CTRL+Z

$ working on some file README.adoc ...
$ git checkout -- REAME.adoc
Danger!

Où j’en suis

$ git status

 

gitbash1

 

gitbash2

 

gitbash3

 

gitbash4

Gestion des branches

 

La principale difficulté de vient de la liberté en termes de branches.

Pour faire simple, je vous conseille une gestion qui marche bien pour les petites équipes, tiré de l’excellent livre Pro Git :

 

 

 

Ce qui donne le flot suivant dès que vous devez faire une amélioration (corriger un bug ou ajouter une fonctionnalités) :

Les différents merge

 

Les exemples suivants sont tirés de :

https://developer.atlassian.com/blog/2014/12/pull-request-merge-strategies-the-great-debate/?utm_source=twitter&utm_medium=social&utm_campaign=atlassian_pull-request-merge-strategies-the-great-debate

Explicit merge

what is a merge
https://developer.atlassian.com/blog/2014/12/pull-request-merge-strategies-the-great-debate/?utm_source=twitter&utm_medium=social&utm_campaign=atlassian_pull-request-merge-strategies-the-great-debate

Implicit merge via rebase or fast-forward

what is a rebase
https://developer.atlassian.com/blog/2014/12/pull-request-merge-strategies-the-great-debate/?utm_source=twitter&utm_medium=social&utm_campaign=atlassian_pull-request-merge-strategies-the-great-debate

Implicit merge via fast-forward

what is a fast forward
https://developer.atlassian.com/blog/2014/12/pull-request-merge-strategies-the-great-debate/?utm_source=twitter&utm_medium=social&utm_campaign=atlassian_pull-request-merge-strategies-the-great-debate

Squash on merge

squash on merge
https://developer.atlassian.com/blog/2014/12/pull-request-merge-strategies-the-great-debate/?utm_source=twitter&utm_medium=social&utm_campaign=atlassian_pull-request-merge-strategies-the-great-debate

Gestion des conflits

 

La principale activité du programmeur qui utilise en équipe vient de la gestion des conflits.

À la main

$ git checkout master
$ git merge other_branch
Auto-merging toto.txt
CONFLICT (content): Merge conflict in toto.txt
Automatic merge failed; fix conflicts and then commit the result.
$ more toto.txt
<<<<<<< HEAD (1)
Salut monde
======= (2)
hello world!

>>>>>>> other_branch (3)
$ vi toto.txt (4)
$ git commit (5)
1Voilà où commence la différence entre la branche courante (HEAD) et la branche qu’on essaye de merger (other_branch)
2Séparation
3Voilà où se termine cette différence
4on édite le fichier à la main pour choisir la bonne version
5on commit pour valider la modif
Il est déconseillé d’en profiter pour faire une nouvelle modif dans le fichier…​

Avec un peu d’aide

Git avancé : Git-Flow

 

http://danielkummer.github.io/git-flow-cheatsheet/

Wrap-up

Résumé des commandes

Voici un schéma pour résumer la philosophie (tiré de http://osteele.com) :

git resume

The End    (for now)