(concepts, utilisation et cas pratiques)

Git

- Maî

tris

ez la

ges

tion

de

vos

vers

ions

ISSN : 1960-3444ISBN : 978-2-7460-9926-5

54 €

Pour plus d’informations :

Git Maîtrisez la gestion de vos versions (concepts, utilisation et cas pratiques)Ce livre s’adresse principalement aux développeurs et aux chefs de projet mais également aux professionnels appelés à modifier des codes sources (Graphiste, Webdesigner, etc.).Le livre présente tout d’abord l’historique des solutions de gestion de versions et leur intérêt. Il permet ensuite au lecteur d’installer et de configurer Git puis de l’utiliser tout au long de cinq chapitres progressifs (fonctionnement des branches, partage d’un dépôt, outils internes…) Un chapitre permet au lecteur de bien appréhender git-flow, une méthode pour gérer efficacement les différentes versions d’un projet en entreprise.Les deux derniers chapitres présentent la gestion de versions de manière très pragmatique en utilisant deux scénarios mettant en œuvre des développeurs. Le premier scénario re-prend les bases de l’utilisation de Git et montre l’utilisation des principales commandes dans des cas quasi-réels. Le deuxième scénario met en scène une équipe de développeurs : de l’installation de GitLab, jusqu’à une utilisation de la méthode git-flow par l’équipe. Ce chapitre détaille les principales étapes par lesquelles l’équipe doit passer pour version-ner un projet existant.Un aide-mémoire en annexe permet de visualiser rapidement les principales commandes et leurs principales options.Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.

Avant-propos • Git et la gestion de version • Installation de Git • Création d’un dépôt • Manipulation des fichiers et commit • Consul-tation et manipulation de l’historique • Les branches et les tags • Partager un dépôt • Git-Flow : workflow d’entreprise • Les outils de Git • Scénario de développeur indépen-dant • Scénario d’équipe • Aide-mémoire

Les chapitres du livre Samuel DAUZON est développeur PHP chez Nameshield et est également déve-loppeur indépendant sur des projets Python / Django (il est l’auteur du livre Django Essentials aux éditions Packt Pu-blishing). Au cours de ses missions, il a géré ses projets avec trois systèmes de versions différents. Il préfère Git pour ses perfor-mances et ses nombreux outils et il partage volontiers son expertise sur ce sujet, au grand bénéfice des lecteurs.

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Les principaux dépôts

d’exemples du livre.

Git Maîtrisez la gestion

de vos versions (concepts, utilisation

et cas pratiques)

Samuel DAUZON

1Table des matières

Avant-propos

1. À qui s’adresse cet ouvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2. Objectifs de l'ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3. Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4. Progression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5. Détail des chapitres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

6. Un point sur les langues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

7. Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

8. Introduction à Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Chapitre 1

Git et la gestion de version

1. La gestion de version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2. Les intérêts de la gestion de version . . . . . . . . . . . . . . . . . . . . . . . . . . 202.1 Une véritable machine à remonter le temps . . . . . . . . . . . . . . . . 202.2 Une documentation détaillée et datée . . . . . . . . . . . . . . . . . . . . 202.3 Une pierre de Rosette pour collaborer . . . . . . . . . . . . . . . . . . . . . 21

3. Histoire de la gestion de version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.1 Systèmes de gestion de versions locaux . . . . . . . . . . . . . . . . . . . 213.2 Systèmes de gestion de versions centralisés . . . . . . . . . . . . . . . . 223.3 Systèmes de gestion de versions décentralisés . . . . . . . . . . . . . . 23

4. Pourquoi Git ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence de l'ouvrage EPGIT dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2Maîtrisez la gestion de vos versions

Git

Chapitre 2

Installation de Git

1. Installation sous Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291.1 Installation à partir de paquets préexistants . . . . . . . . . . . . . . . 291.2 Installation à partir des sources . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2. Installation sous Mac OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3. Installation sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4. L’aide de Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.2 Types de commandes Git. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4.2.1 Les commandes de porcelaine . . . . . . . . . . . . . . . . . . . . . . 384.2.2 Les commandes de plomberie . . . . . . . . . . . . . . . . . . . . . . 38

5. Configuration requise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.1 Configurer le nom de l'utilisateur . . . . . . . . . . . . . . . . . . . . . . . . 395.2 Configurer l'e-mail de l'utilisateur . . . . . . . . . . . . . . . . . . . . . . . . 39

Chapitre 3

Création d’un dépôt

1. Créer un dépôt local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

2. Le contenu du dossier .git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3. Le fichier README . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

4. Markdown . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.2 Éléments de syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4.2.1 Titres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.2.2 Listes non ordonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2.3 Listes ordonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2.4 Mettre en gras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2.5 Mettre en italique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2.6 Ligne horizontale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48


4.2.7 Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.2.8 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.2.9 Liens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.2.10Notes de bas de page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5. reStructuredText . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505.2 Éléments de syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.2.1 Titres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505.2.2 Listes autonumérotées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

5.3 Logiciels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6. Outils pour travailler avec Markdown . . . . . . . . . . . . . . . . . . . . . . . . 526.1 Sublime Text. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526.2 Texts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536.3 Ulysses. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

7. Configurer le dépôt local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557.1 Configuration minimale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557.2 Niveaux de configuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

7.2.1 Le niveau système. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567.2.2 Le niveau utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567.2.3 Le niveau dépôt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

7.3 Les paramètres configurables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577.3.1 Définir l'éditeur de texte . . . . . . . . . . . . . . . . . . . . . . . . . . 577.3.2 Modèle de commit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577.3.3 Ignorer des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587.3.4 Hashs abrégés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

7.4 Définition d'alias Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

8. Les options de configuration avancées . . . . . . . . . . . . . . . . . . . . . . . . 608.1 Pagination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.2 Expressions régulières étendues . . . . . . . . . . . . . . . . . . . . . . . . . . 608.3 Séparateur de mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.4 Ancêtre commun des conflits . . . . . . . . . . . . . . . . . . . . . . . . . . . 61


Git

Chapitre 4

Manipulation des fichiers et commit

1. Gestion des fichiers et commit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

2. Une histoire de hash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.1 Une identification par contenu . . . . . . . . . . . . . . . . . . . . . . . . . . 652.2 Risque de collision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3. Les trois zones d’un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.1 Le répertoire de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673.2 L'index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693.3 Le dépôt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

4. Manipuler les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734.1 Ajouter des fichiers dans l'index . . . . . . . . . . . . . . . . . . . . . . . . . 734.2 Déplacer ou renommer des fichiers . . . . . . . . . . . . . . . . . . . . . . . 744.3 Supprimer des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754.4 Arrêter de suivre un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764.5 Ignorer des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5. Commiter ou enregistrer des modifications . . . . . . . . . . . . . . . . . . . . 785.1 Effectuer un premier commit . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.2 Rédiger un bon message de commit . . . . . . . . . . . . . . . . . . . . . . 80

5.2.1 Les règles d'un message de commit . . . . . . . . . . . . . . . . . . 805.2.2 Méthode pour le titre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815.2.3 En quelle langue ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Chapitre 5

Consultation et manipulation de l’historique

1. Lister les commits avec git log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851.1 Limiter le nombre de commits affichés. . . . . . . . . . . . . . . . . . . . 871.2 Afficher les statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 881.3 Afficher chaque commit sur une seule ligne. . . . . . . . . . . . . . . . 891.4 Filtrer les commits chronologiquement . . . . . . . . . . . . . . . . . . . 891.5 Filtrer les commits selon les intervenants. . . . . . . . . . . . . . . . . . 90


1.6 Afficher le graphique des branches . . . . . . . . . . . . . . . . . . . . . . . 911.7 Spécifier un format de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921.8 Prendre en compte les merges . . . . . . . . . . . . . . . . . . . . . . . . . . . 941.9 Lister les commits impactant un fichier . . . . . . . . . . . . . . . . . . . 95

2. Afficher les différences de contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . 962.1 Différences en cours dans le répertoire . . . . . . . . . . . . . . . . . . . . 962.2 Différences entre l'index et HEAD . . . . . . . . . . . . . . . . . . . . . . . 972.3 Différences entre le répertoire de travail et HEAD. . . . . . . . . . . 982.4 Différences introduites par un ou plusieurs commits . . . . . . . . 982.5 Différences de mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

3. Identifier l’auteur d’une ligne de code. . . . . . . . . . . . . . . . . . . . . . . . 101

4. Rechercher des commits avec le mode pick axe . . . . . . . . . . . . . . . . 102

5. Supprimer les modifications du répertoire de travail . . . . . . . . . . . . 103

6. Supprimer les modifications de l'index . . . . . . . . . . . . . . . . . . . . . . . 104

7. Revenir à un état antérieur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

8. Modifier le dernier commit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Chapitre 6

Les branches et les tags

1. Les tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091.1 Numérotation des versions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091.2 Différents types de tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101.3 Création des tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1111.4 Création d’un tag annoté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1111.5 Liste des tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1121.6 Détails d’un tag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1121.7 Envoi des tags vers le dépôt distant. . . . . . . . . . . . . . . . . . . . . . 1131.8 Suppression d’un tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114


Git

2. Les branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152.1 Liste des branches existantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172.2 Création d’une branche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182.3 Positionnement sur une branche. . . . . . . . . . . . . . . . . . . . . . . . 1192.4 Fusionner deux branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

2.4.1 L'avance rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1222.4.2 Nettoyer votre dépôt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252.4.3 Les conflits de fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

2.5 Supprimer une branche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1332.6 Rebaser une branche dans une autre . . . . . . . . . . . . . . . . . . . . . 134

Chapitre 7

Partager un dépôt

1. Qu'est-ce qu'un dépôt distant ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

2. Créer un dépôt distant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1412.1 Pour un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1412.2 Pour un projet existant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

3. Cloner un dépôt distant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

4. Les protocoles d'échange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

5. Fonctionnement interne et branches distantes . . . . . . . . . . . . . . . . 1455.1 Les dépôts distants liés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1455.2 Les branches distantes suivies . . . . . . . . . . . . . . . . . . . . . . . . . . 146

6. Envoyer ses modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

7. Recevoir les modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149


Chapitre 8

Git-Flow : workflow d’entreprise

1. Un système de gestion des branches . . . . . . . . . . . . . . . . . . . . . . . . . 1551.1 Les branches éternelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

1.1.1 La branche de production (master) . . . . . . . . . . . . . . . . . 1561.1.2 La branche de développement (develop) . . . . . . . . . . . . . 156

1.2 Les branches éphémères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1571.2.1 Les branches de versions (release) . . . . . . . . . . . . . . . . . . 1571.2.2 Les branches de correctifs (hotfix). . . . . . . . . . . . . . . . . . 1581.2.3 Les branches de fonctionnalités (feature) . . . . . . . . . . . . 158

2. Exemple de workflow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

3. Git-Flow intuitif grâce à Tower. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1613.1 Client Git et Git-Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1613.2 Cas pratique d’utilisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Chapitre 9

Les outils de Git

1. Mettre de côté des modifications avec git stash. . . . . . . . . . . . . . . . 169

2. Dépôts intégrés avec submodules . . . . . . . . . . . . . . . . . . . . . . . . . . . 1722.1 Ajout du dépôt intégré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1742.2 Cloner un dépôt et ses dépôts intégrés . . . . . . . . . . . . . . . . . . . 1772.3 Modification des dépôts intégrés. . . . . . . . . . . . . . . . . . . . . . . . 1772.4 Supprimer un dépôt intégré . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1782.5 Inconvénients des dépôts intégrés. . . . . . . . . . . . . . . . . . . . . . . 179

3. Retrouver un commit erroné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1803.1 Utilisation pratique de git bisect . . . . . . . . . . . . . . . . . . . . . . . . 1813.2 Automatiser git bisect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

4. Journal des références (reflog) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184


Git

Chapitre 10

Scénario de développeur indépendant

1. But de ce chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

2. Contexte du scénario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

3. Création du dépôt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

4. Début du développement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

5. Enregistrer des modifications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

6. Bitbucket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1936.1 Création d'un compte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1956.2 Envoyer un dépôt local vers Bitbucket . . . . . . . . . . . . . . . . . . . 1986.3 Éditer un fichier sur Bitbucket. . . . . . . . . . . . . . . . . . . . . . . . . . 1996.4 Récupérer les modifications du dépôt distant . . . . . . . . . . . . . 200

7. Intégrer un nouveau développement . . . . . . . . . . . . . . . . . . . . . . . . 2007.1 Vérifier son code avant l'indexation . . . . . . . . . . . . . . . . . . . . . 2017.2 Commiter le nouveau développement . . . . . . . . . . . . . . . . . . . 202

8. Annuler les modifications d'un fichier . . . . . . . . . . . . . . . . . . . . . . . 202

9. .gitignore : ignorer une bibliothèque . . . . . . . . . . . . . . . . . . . . . . . . . 203

10. Commiter tous les fichiers ajoutés ou modifiés . . . . . . . . . . . . . . . . 206

11. Envoyer les commits au dépôt distant . . . . . . . . . . . . . . . . . . . . . . . 207

12. Afficher les différences entre deux commits. . . . . . . . . . . . . . . . . . . 207

13. Cloner le dépôt distant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

14. Une branche, ça sert à quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

15. Changer de branche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

16. Fusionner deux branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214


Chapitre 11

Scénario d’équipe

1. Contexte du scénario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

2. Aperçu du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2182.1 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2192.2 Récupération du dépôt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2202.3 Installation des dépendances Python . . . . . . . . . . . . . . . . . . . . 2202.4 Initialisation des dépôts intégrés . . . . . . . . . . . . . . . . . . . . . . . . 2202.5 Génération des bibliothèques. . . . . . . . . . . . . . . . . . . . . . . . . . . 2212.6 Création du fichier de configuration . . . . . . . . . . . . . . . . . . . . . 2222.7 Création de la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2222.8 Création d'un compte root. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2232.9 Lancement du serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

3. Installation de GitLab. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

4. Création des comptes utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

5. Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

6. Attribuer des projets aux utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . 230

7. Premier commit du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2317.1 Rédaction du fichier .gitignore . . . . . . . . . . . . . . . . . . . . . . . . . 231

7.1.1 Ignorer les bibliothèques . . . . . . . . . . . . . . . . . . . . . . . . . 2327.1.2 Ignorer les fichiers propres à la technologie . . . . . . . . . . 2327.1.3 Ignorer les données sensibles . . . . . . . . . . . . . . . . . . . . . . 2327.1.4 Ajouter les dépôts intégrés. . . . . . . . . . . . . . . . . . . . . . . . 2337.1.5 Le fichier README . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

7.2 Commit du projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2347.3 Création de la branche develop pour Git-Flow. . . . . . . . . . . . . 234

8. Phase de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2358.1 Fonctionnalité graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2358.2 Correctif de temps négatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2368.3 Intégration du correctif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2378.4 Fonctionnalité type de tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . 238


Git

8.5 Finalisation des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2388.6 Finalisation des types de tâche . . . . . . . . . . . . . . . . . . . . . . . . . 2408.7 Création de la branche de version . . . . . . . . . . . . . . . . . . . . . . . 2408.8 Export CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2418.9 Correctif de version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2418.10 Nouvelle version stable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2428.11 Finalisation de l’export CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

9. Mise en ligne du dépôt sur GitHub . . . . . . . . . . . . . . . . . . . . . . . . . . 2439.1 Création d'un compte GitHub. . . . . . . . . . . . . . . . . . . . . . . . . . 2439.2 Création d'un dépôt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2449.3 Ajout du remote au dépôt local . . . . . . . . . . . . . . . . . . . . . . . . . 2469.4 Envoi des branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2469.5 Le fichier LICENSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2469.6 Le fichier README . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

Annexe

Aide-mémoire

1. Les références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2491.1 HEAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2491.2 Les branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2501.3 Les tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2501.4 Référence des ancêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

2. Les commandes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2512.1 git add . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2512.2 git archive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2522.3 git bisect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2522.4 git blame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2532.5 git branch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2542.6 git checkout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2552.7 git cherry-pick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2562.8 git clean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2562.9 git clone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257


2.10 git commit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2582.11 git config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2592.12 git diff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2602.13 git fetch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612.14 git gc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2622.15 git help. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2622.16 git init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2632.17 git log. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2632.18 git merge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2642.19 git mv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2652.20 git pull . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2652.21 git push . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2662.22 git rebase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2672.23 git reflog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2672.24 git remote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2682.25 git reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2682.26 git revert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2692.27 git rm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.28 git show. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.29 git stash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2712.30 git submodule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2722.31 git tag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

Chapitre 6

Les branches et les tags

Les branches et les tags1. Les tags

Un tag est un alias (un nom) défini par un développeur, dont le rôle est depointer vers un commit. Il permet d'identifier facilement un commit. Les tagssont utilisés pour nommer à des moments précis l'état du dépôt. Les tags per-mettent d'éviter l'utilisation des hashs SHA-1 qui sont ne sont pas expliciteset difficiles à retenir.

Les tags sont notamment utilisés pour marquer des numéros de version surdes commits.

1.1 Numérotation des versions

Il existe plusieurs manières de noter les versions d’un logiciel. Il n’y a pas deméthode parfaite pour choisir les numéros de versions. Il faut juste restercohérent avec le système choisi.

Le système SemVer (pour Semantic Versioning) est un système dont la philoso-phie est de donner un numéro de version qui ait du sens dans le cycle de viedu logiciel. Ce système est utilisé sur des projets de grande envergure commePython ou Django et est parfaitement adapté à des projets de petite taille.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Git

Le numéro de version se construit à partir de trois nombres séparés de points :x.y.z

Signification des trois nombres :

– Le x va marquer une version majeure. Une version majeure est une versionqui entraîne des modifications importantes dans le fonctionnement del’application ou encore qui induit une incompatibilité avec une version pré-cédente.

– Le y va marquer une version mineure. Une version mineure est une versionqui ajoute des fonctionnalités tout en conservant une compatibilité avecl’ancien système.

– Le z va marquer un patch. Un patch correspond à des corrections de bugssans ajout de fonctionnalités.

Ainsi, on peut imaginer un extrait de liste des modifications (changelog) d'unlogiciel de conversion vidéo :

– 1.8.5 : correction de divers bugs lors de la conversion d’une vidéo HD.

– 1.9 : ajout de la prise en charge du format Matroska.

– 2 : modification de l’algorithme de compression du fichier de sortie.

1.2 Différents types de tags

Avec Git, il existe deux types de tags : les tags légers et les tags annotés. Lestags légers sont des tags qui stockent le nom du tag sur un commit donné. Lestags annotés stockent davantage d’informations en conservant également ladate de création et le créateur du tag.

Les tags annotés sont utiles lorsqu’on a besoin de stocker les informations liéesà la personne qui a créé un tag. En utilisant un tag annoté, il est nécessaired’enregistrer un message, ce qui permet de sauvegarder des détails complé-mentaires sur le tag tels que la version définie par ce tag. Cela dépend trèssouvent de l’organisation et des méthodes de travail choisies dans le service in-formatique.

111Les branches et les tagsChapitre 6

1.3 Création des tags

Pour créer un tag léger, il faut se positionner sur le commit dont on veut créerun alias (avec la commande git checkout hash_du_commit) puis créerle tag avec la syntaxe suivante :

git tag nom_du_tag

Par exemple, pour créer le tag de la version 1.8.5, il faut utiliser la commandesuivante :

git tag v1.8.5

Il est également possible de créer un tag sans se positionner sur le commit enutilisant la commande git tag tout en spécifiant le hash du commit :

git tag nom_du_tag hash

Par exemple, pour définir le tag de la version 1.8.6 sur le commit dont le hashcommence par af31a4, il faut utiliser la commande suivante :

git tag v1.8.6 af31a4

1.4 Création d’un tag annoté

Il est possible de créer un tag annoté en ajoutant le paramètre -a à la com-mande git tag.

Syntaxe de création d’un tag annoté :

git tag -a nom_du_tag

Par exemple, pour créer le tag de la version 1.9 sur le commit courant, il faututiliser la commande suivante :

git tag -a v1.9

En exécutant cette commande, Git va demander à l’utilisateur d’entrer unmessage de tag dans l’éditeur de texte configuré. Il est également possible denoter le message du tag directement dans la commande en utilisant le para-mètre -m.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Git

Syntaxe permettant de définir le tag annoté et le message dans une seulecommande :

git tag -a nom_du_tag -m "message_du_tag"

Par exemple, pour créer le tag correspondant à la version 1.10 :

git tag -a v1.10 -m "Webservices remplacés par l’API REST"

1.5 Liste des tags

Pour lister uniquement les noms des tags, il faut utiliser la commandesuivante :

git tag --list

Il est aussi possible d’utiliser le raccourci -l au lieu de --list. Pour afficherégalement des lignes du message de tag, il faut utiliser le paramètre -n. Ce pa-ramètre prend en argument le nombre de lignes du message de tag à afficher.Si aucun argument n’est défini, Git affichera uniquement la première ligne dumessage.

Exemple listant les tags, leurs noms et les trois premières lignes du message detag :

git tag --list -n3

1.6 Détails d’un tag

Afficher les détails d’un tag va également afficher les détails du commit auquelle tag est associé. Pour afficher les détails d’un tag, il faut utiliser la commandesuivante :

git show v1.8.5

113Les branches et les tagsChapitre 6

Pour un tag simple, cette commande va simplement afficher les détails ducommit auquel il est attaché. Pour un tag annoté, cette commande va afficherles détails du tag puis les détails du commit. Voici par exemple les détails detag et de commit qu’on obtient en utilisant cette commande :

tag v2

Tagger: Samuel DAUZON <[email protected]>

Date: Sun Apr 26 20:33:40 2015 +0200

Webservices remplacés par l’API REST

commit 2aa8afa6b79274f63b2f4331dcba05a85812904d

Author: Samuel DAUZON <[email protected]>

Date: Sun Apr 26 20:30:25 2015 +0200

Intégration de l’API REST.

diff --git a/tag.txt b/tag.txt

index b6d93df..f3e4b24 100644

--- a/README

+++ b/README

@@ -1 +1,2 @@

+Nouveautés dans la version 2

+ --- suite du contenu du commit ---

L’affichage de cette commande présente les détails du tag, mais égalementceux du commit. Cet affichage est intéressant car le créateur du commit n’estpas obligatoirement celui qui a défini le tag. En effet, il est fréquent que lecommit soit créé par le développeur ayant effectué la modification et que letag soit apposé par un chef de projet pour valider une nouvelle version.

1.7 Envoi des tags vers le dépôt distant

Pour envoyer les tags créés sur le dépôt local vers le dépôt distant, il faut uti-liser la commande suivante (où origin est le nom du dépôt distant) :

git push origin -tags

Il est également possible d’envoyer les tags un à un vers le dépôt distant en uti-lisant la syntaxe suivante (où origin est le nom du dépôt distant) :

git push origin nom_du_tag

© E

dit

ions

EN

I -

All r

ights

rese

rved


Git

Par exemple, lorsque la version 2 est validée, le chef de projet qui a apposé letag v2 pourra l’envoyer au dépôt distant de cette manière :

git push origin v2

De cette manière, lorsque les utilisateurs du dépôt auront mis à jour leur dépôtlocal, ils pourront utiliser le tag v2.

1.8 Suppression d’un tag

Supprimer un tag ne signifie pas supprimer le commit auquel il se réfère, maisuniquement l’alias qui se réfère à ce commit. Supprimer un tag n’entraînedonc aucune perte dans l’historique du projet.

Pour supprimer un tag, il faut utiliser la commande suivante :

git tag -d nom_du_tag

Par exemple, si le tag v2 a été défini sur un mauvais commit, il est possible desupprimer le tag de cette manière :

git tag -d v2

Cette commande n’envoie rien au dépôt distant, pour vos collaborateurs dedépôt le tag existe toujours.

Pour faire savoir au dépôt distant que le tag est supprimé, il faut lui envoyerl’objet interne de Git avec la commande suivante :

git push origin :refs/tags/nom_du_tag

Par exemple, si le chef de projet a envoyé le tag v2 pointant vers un mauvaiscommit, il peut supprimer cette référence dans le dépôt distant de cettemanière :

git push origin :refs/tags/v2

(concepts, utilisation et cas pratiques)

Documents

Transcript of (concepts, utilisation et cas pratiques)