Le système de gestion de version Git et GitHub

dØveloppement, Git hØberge le dØveloppement du noyau Linux.

Git

Les principes de base

Un dØp(cid:244)t Git est une sorte de systŁme de (cid:28)chiers (base de

donnØes), enregistrant les versions de (cid:28)chiers d’un projet (cid:224) des

moments prØcis au cours du temps sous forme d’instantanØs.

Comment fonctionne le processus de versionnement ?

Git

Les principes de base

3 sections d’un projet Git :

(cid:73) Le rØpertoire Git/dØp(cid:244)t :

contient les mØta-donnØes et la

base de donnØes des objets du

projet.

(cid:73) Le rØpertoire de travail :

extraction unique d’une version

du projet depuis la base de

donnØes du dØp(cid:244)t.

(cid:73) La zone de transit/d’index :

simple (cid:28)chier contenant des

informations (cid:224) propos de ce qui

sera pris en compte lors de la

prochaine soumission.

Git

Les principes de base

4 Øtats d’un (cid:28)chier dans Git :

(cid:73) non versionnØ : (cid:28)chier n’Øtant

pas ou plus gØrØ par Git ;

(cid:73) non modi(cid:28)Ø : (cid:28)chier sauvegardØ

de maniŁre sßre dans sa version

courante dans la base de

donnØes du dØp(cid:244)t ;

(cid:73) modi(cid:28)Ø : (cid:28)chier ayant subi des

modi(cid:28)cations depuis la derniŁre

fois qu’il a ØtØ soumis ;

(cid:73) indexØ (staged) : idem, sauf qu’il

en sera pris un instantanØ dans

sa version courante lors de la

prochaine soumission (commit).

Git

Les principes de base

Chaque soumission (commit) donne lieu (cid:224) la crØation d’un objet

(cid:16)commit(cid:17) contenant un pointeur vers un instantanØ du contenu

dont les modi(cid:28)cations Øtaient indexØes au moment de la soumission

(ensemble d’objets permettant de stocker un instantanØ des (cid:28)chiers

concernØs d’une part et de reproduire la structure du rØpertoire

projet et de ses sous-rØpertoires d’autre part), quelques

mØta-donnØes (auteur, message) et un pointeur vers l’objet

(cid:16)commit(cid:17) prØcØdent.

Git

Les commandes de base

Initialiser un dØp(cid:244)t

$ git init

A(cid:30)cher l’Øtat des (cid:28)chiers du rØpertoire courant

$ git status

(cid:73) Untracked (cid:28)les : (cid:28)chiers non versionnØs.

(cid:73) Changes to be committed : modi(cid:28)cations (ajout, suppression,

changements) chargØes en zone de transit (staging area), ou

indexØes.

(cid:73) Changes not staged for commit : modi(cid:28)cations n’ayant pas ØtØ

chargØes en zone de transit (ou indexØes).

Git

Les commandes de base

Indexer l’ajout ou les changements d’un (cid:28)chier

$ git add [-p] <fichier>

Annuler les modi(cid:28)cations indexØes d’un (cid:28)chier

$ git reset <fichier>

Annuler les modi(cid:28)cations non encore indexØes d’un (cid:28)chier

$ git checkout [--] <fichier>

Indexer la suppression d’un (cid:28)chier

$ git rm <fichier>

DØversionner un (cid:28)chier

$ git rm --cached <fichier>

Git

Les commandes de base

A(cid:30)cher le dØtail des modi(cid:28)cations non indexØes

$ git diff

A(cid:30)cher le dØtail des modi(cid:28)cations indexØes

$ git diff --staged

Soumettre les modi(cid:28)cations indexØes en zone de transit

$ git commit

Voir l’historique des soumissions

$ git log

Git

Branches

Qu’est-ce qu’une branche dans un projet ?

C’est une ligne d’Øvolution

divergent de la ligne

d’Øvolution courante, celles-ci

se poursuivant

indØpendemment l’une de

l’autre.

Pourquoi des branches ?

(cid:73) Pouvoir se lancer dans des Øvolutions ambitieuses en ayant

toujours la capacitØ de revenir (cid:224) une version stable que l’on

peut continuer (cid:224) maintenir indØpendemment.

(cid:73) Pouvoir tester di(cid:27)Ørentes implØmentations d’une mŒme

fonctionnalitØ de maniŁre indØpendante.

Git

Branches

Une branche dans Git est tout simplement un pointeur vers un objet

(cid:16)commit(cid:17). Par dØfaut, il en existe une seule, nommØe (cid:16)master(cid:17).

CrØer une nouvelle branche

$ git branch <branche>

HEAD est un pointeur spØcial vers la

branche sur laquelle on travaille

actuellement (extraite dans le

rØpertoire de travail).

Git

Branches

Voir les branches du dØp(cid:244)t local

$ git branch

Supprimer une branche

$ git branch -d <branche>

Passer (cid:224) une branche donnØe (mise (cid:224) jour de l’index et du

rØpertoire de travail, ainsi que du pointeur HEAD)

$ git checkout <branche>

(cid:32)

Git

Branches

Deux fa(cid:231)ons pour incorporer les modi(cid:28)cations d’une branche dans

la branche courante.

Fusionner (merge)

Rebaser (rebase)

Git

Branches

Fusionner les modi(cid:28)cations d’une branche donnØe dans la

branche courante (HEAD)

$ git merge <branche>

(cid:73) Si l’objet (cid:16)commit(cid:17) pointØ par <branche> est dØj(cid:224) un ancŒtre

de l’objet (cid:16)commit(cid:17) courant (HEAD), alors rien n’est fait.

(cid:73) Si l’objet (cid:16)commit(cid:17) pointØ par <branche> est un descendant

de l’objet (cid:16)commit(cid:17) courant, seul le pointeur de la branche

courante est dØplacØ sur l’objet (cid:16)commit(cid:17) concernØ par la

fusion ((cid:16)fast-forward(cid:17)).

(cid:32)

Git

Branches

(cid:73) Autrement, Git se base sur trois instantanØs di(cid:27)Ørents, celui de

l’objet (cid:16)commit(cid:17) courant, celui de l’objet (cid:16)commit(cid:17) pointØ par

<branche> et celui de l’objet (cid:16)commit(cid:17) correspondant au plus

jeune ancŒtre commun des deux premiers objets (cid:16)commit(cid:17),

pour crØer un nouvel instantanØ associØ (cid:224) un nouvel objet

(cid:16)commit(cid:17) par la fusion de deux branches, sur lequel la branche

courante pointera (cid:224) prØsent.

(cid:32)

Git

Branches

En cas de con(cid:29)it empŒchant la fusion

(cid:73) Aucun objet (cid:16)commit(cid:17) de fusion n’est crØØ, mais le processus

est mis en pause.

(cid:73) git status donne les (cid:28)chiers n’ayant pas pu Œtre fusionnØs

(listØs en tant que (cid:16)unmerged(cid:17)).

(cid:73) Git ajoute des marqueurs de rØsolution de con(cid:29)its (cid:224) tout (cid:28)chier

sujet (cid:224) con(cid:29)its a(cid:28)n que ceux-ci puissent Œtre rØsolus (cid:224) la main.

(cid:73) Pour marquer les con(cid:29)its dans un (cid:28)chier <fichier> comme

rØsolus, il faut faire git add <fichier>. On peut, aprŁs

rØsolution de tous les con(cid:29)its, soumettre les modi(cid:28)cations sous

forme d’objet (cid:16)commit(cid:17) de fusion avec git commit et

terminer ainsi le processus de fusion.

Git

Branches

Rebaser les modi(cid:28)cations de la branche courante (HEAD) sur

une branche donnØe

$ git rebase <branche>

(cid:73) Aller (cid:224) l’objet (cid:16)commit(cid:17) correspondant au plus jeune ancŒtre

commun des deux objets (cid:16)commit(cid:17) pointØs par la branche

courante et <branche>.

(cid:73) Obtenir et sauvegarder les changements introduits depuis ce

point par chaque objet (cid:16)commit(cid:17) de la branche courante.

(cid:73) Faire pointer la branche courante sur le mŒme objet (cid:16)commit(cid:17)

que <branche> et rØappliquer tous les changements un par un.

(cid:32)

Git

Travail avec des dØp(cid:244)ts distants

Pour collaborer, il est nØcessaire de communiquer et d’Øchanger

avec un ou plusieurs dØp(cid:244)ts distants hØbergeant le mŒme projet

(typiquement des dØp(cid:244)ts publics associØs (cid:224) une personne, une

Øquipe ou tout le projet).

Les donnØes des dØp(cid:244)ts distants (objets (cid:16)commit(cid:17) et instantanØs)

sont entiŁrement copiØes dans le dØp(cid:244)t local, et pour chaque

branche <branche> d’un dØp(cid:244)t distant <dØp(cid:244)t> est maintenue une

branche locale <dØp(cid:244)t>/<branche> non modi(cid:28)able, permettant de

suivre la position de <branche> sur <dØp(cid:244)t> localement.

A(cid:30)cher la liste de tous les dØp(cid:244)ts distants du projet

$ git remote

Git

Travail avec des dØp(cid:244)ts distants

Cloner un dØp(cid:244)t distant (automatiquement nommØ origin)

$ git clone <URL> [<rØpertoire>]

(cid:32)

Git

Travail avec des dØp(cid:244)ts distants

RØcupØrer les modi(cid:28)cations d’un dØp(cid:244)t distant

$ git fetch <dØp(cid:244)t>

Git

Travail avec des dØp(cid:244)ts distants

Ajouter un dØp(cid:244)t distant

$ git remote add <nom> <URL>

(cid:32)

Git

Travail avec des dØp(cid:244)ts distants

Mettre (cid:224) jour un dØp(cid:244)t distant donnØ pour une certaine

branche locale

$ git push <dØp(cid:244)t> <branche>

Attention : ceci fonctionne uniquement si le dernier objet (cid:16)commit(cid:17)

de la branche concernØe du dØp(cid:244)t distant a ØtØ rØcupØrØ et intØgrØ

dans la branche en question du dØp(cid:244)t local, en d’autres termes si la

mise (cid:224) jour de la branche du dØp(cid:244)t distant peut Œtre faite par

(cid:16)fast-forward(cid:17).

Combiner git fetch et git merge

git pull <dØp(cid:244)t> <branche>

Combiner git fetch et git rebase

git pull --rebase <dØp(cid:244)t> <branche>

Git

Conseils, bonnes pratiques

Conseils

(cid:73) User et abuser des branches.

(cid:73) Eviter de systØmatiquement faire un git pull, mais rØ(cid:29)Øchir

(cid:224) ce qu’il est le plus pertinent de faire (fusionner ou rebaser).

Bonnes pratiques

(cid:73) Ne jamais rebaser une branche dØj(cid:224) prØsente sur un dØp(cid:244)t

public.

(cid:73) Respecter les conventions de formattage du message de

soumission : titre de 50 caractŁres au plus, suivi d’une ligne

vide puis d’une description dØtaillØe avec des lignes de 72

caractŁres au plus, le tout au prØsent de l’impØratif

(http://tbaggery.com/2008/04/19/

a-note-about-git-commit-messages.html).

GitHub

(cid:73) Service web d’hØbergement et de gestion de projets de

dØveloppement logiciel utilisant le systŁme de gestion de

version Git.

(cid:73) En plus de ce systŁme, on trouvera tout un Øco-systŁme

incluant notamment un Wiki et un systŁme de tickets (avec

MarkDown et rØfØrencement des tickets).

(cid:73) https://help.github.com/

Fin

Des questions ?