I - Git : Les bases

Dans le cycle de développement d'une application,  la gestion du code (collaboration et version) est une étape importante.

Linus Torvalds créa git en 2005 en afin de remplacer BitKeeper qui assurait le partage gestion des patch du noyau Linux. Git est parti donc de ces  principes: vitesse, distribution, simplicité et est  distribué selon les termes de la licence GNU 2.0.
C'est un logiciel de contrôle des versions décentralisées. Permettant ainsi à un groupe de personnes de travailler sur un même projet en gérant les différentes versions et fusionnant à un moment donnant leur travail. C'est l’outil de gestion de version le plus populaire.
Git permet de gérer tout type de documents textes, donc il n'est pas destiné uniquement aux développeurs, mais aussi à des utilisateurs d'outils comme latex ou Markdown pour leur création de contenu.

I - Installation

L'installation de git est assez simple en fonction de votre système d'exploitation:

A - Windows:  Git est disponible en téléchargement sur ce lien. Après téléchargement, l'installation se fait de la manière que toute application Windows.

B- Linux et dérivé: Sur les systèmes linux (Ubuntu, Debian, Redhat, ...), l'installation se fait directement via le source code disponible sur  Github (un peu compliqué) ou en utilisant simplement le gestionnaire de package correspondant au système d'exploitation (apt, aptitude, yum, ....).

apt-get install git

L'installation est maintenant terminé, vous pouvez vérifier la version de git installée grâce à cette commande:

git --version

Dans la prochaine section nous verrons comment initialiser notre 1er "repository" (appellation commune des dossiers git).

Pour la suite je considère que vous utilisez un terminal linux, mais sachez que que  les commandes Git restent valide sur Windows.

II - Création d'un "repository" local

Dans cette section, nous allons créer un projet sur la machine local et gérer son évolution avec git. Pour cela suivez ces étapes:

1- Créer un dossier  qui va contenir notre projet git :

mkdir tuto-git
cd tuto-git

Une fois dans le dossier (tuto-git), nous allons maintenant initialiser le repository :

➜  tuto-git git init
Initialized empty Git repository in /Users/boubacar/Desktop/projects/git/tuto-git/.git/

Après initialisation, un dossier ".git" sera créé dans le répertoire. il sera visible avec la commande "ls -al".

Ce dossier ".git" contient l'ensemble des informations de notre projet. Nous allons nous intéresser particulièrement au fichier  ".git/config" qui évoluera tout au long de ce tutoriel.

Avant de continuer nous allons configurer 2 variables qui vont nous aider à identifier l'utilisateur qui effectue les actions sur le repository git. Remplaces ces valeurs par ton nom et votre adresse email. (Oui là, on va se tutoyer maintenant).

git config --global user.name "Your Name"
git config --global user.email [email protected]

2- États du repository et création des fichiers:

Vérifions l'état de notre repository (dossier git) avec la commande: git status

Il est mentionné que nous somme sur la branche master et qu'aucun commit n'a pour l'instant été effectué. Quelques définitions:
-  Une branche est un dossier virtuel dans le repository qui contient des commits.
- Un commit est une sauvegarde d'un état du repository. Chaque commit peut être accessible avec son ID.

Pour un début nous allons travailler sur la branche par défaut qui dans notre cas s'appel "master" et nous ferons évoluer notre repository dans cette branche.
Nous allons créer un 1er fichier que nous allons appeler tuto-git.py qui sera notre programme python à manipuler.

tuto-git.py

def main():
    print("Bienvenue sur Git")

if __name__ == "__main__":
    main()

L'état de notre repository va changer avec l'ajout de ce ficher. Toujours avec la commande "git status" nous aurons:

Le fichier est vu par git, mais est pour l'instant à l’état "Untracked".  A rappeler qu'un fichier git peut avoir l'un des 4 états affiché sur le schéma ci-dessous.

Pour que le fichier soit pris en compte nous devons l'ajouter à git avec la commande:

$ git add tuto-git.py

Le fichier passe ainsi à l'état "Stagged". A noter que la commande "git add " permet d'ajouter plusieurs fichier (et uniquement des fichiers) en les séparant par un espace ou bien ajouter tout le contenu du répertoire git avec la commande:

# Ajoute tout le contenu du repertoire
$ git add . 

# Ajoute tout le contenu de dossier 
$ git add dossier/* 

Une fois le fichier ajouté, nous pouvez créer notre 1er commit qui sera l'enregistrement de l'état de notre répertoire dans git. Et comme indiqué au niveau du schéma des états, le fichier passera à l'état "Unmodified". Pour créer un commit, nous utilisons la commande suivante avec le paramètre  "-m" permettant de spécifier le message.

Notre commit s'appel "Mon coomit: 1". Tu aurais pu mettre un nom de commit différent, en général il correspond à une description de tes modifications. Nous voyons aussi que git nous fait un petit résumé des modifications.

Voici la liste des commits disponibles avec la commande: "git logs"

Nous reviendrons plus en détails sur la magie de "git log", mais intéressons nous un peu à cette image. Nous avons:

• L'identifiant du commit : b0ea64360e6ea6165e98d95e2eb668ee325aec8d
• La branche associé au commit: master
• Auteur du commit: Ce sont les infos que nous avions saisi au début avec la commande "git config --global user.name" et "git config --global user.email"
• Messsage: "Mon commit: 1"

Nous allons effectuer les opérations suivantes afin d'avoir 3 commits au niveau de notre repository:
a - Modifier le contenu de contenu du fichier avec un éditeur de texte classique et remplacer notre texte (print) par  "Bienvenue sur ce cours Git". Un git status nous montre que le fichier repasse à l’état "Modified".

En plus du "git status",  nous pouvons vérifier les modifications effectuées (depuis le commit précédent) avec la commande: "git diff".

Il faut à nouveau refaire les commandes:

# Changer l'état à Stagged
$ git add tuto-git.py

# Changer l'état à Unmodified
$ git commit -m "Changement du message"

b -  Créer un second fichier  que nous allons appeler "lib-python.py" qui aura pour commit message "Ajout d'une lib" une fois ajouté à git.

Le fichier lib-python.py contient uniquement la ligne: #Lib python

Maintenant que nous avons 3 commits nous pouvons voyager dans le temps.

3- Voyage dans le temps

Revoyons vite fait nos commits et leur infos sur la branche master:

Pour avoir un minimum d'informations, nous pouvons rajouter des paramètres à la commande "git log".

A noter qu'il y'a plusieurs format de logs que vous pouvez afficher. Celà peut par exemple être utile lorsque vous effectuer des releases notes. Plus de details sur ce site-web.

Attentions, les commit ID seront différents sur ton ordinateur. Tu remarquera aussi la branche master correspond toujours au dernier commit. En accéder à une branche correspond juste à accéder au dernier commit, et HEAD est une variable qui correspond au commit sur lequel nous nous trouvons.
cela:

Accèder au 1er commit

$ git checkout b0ea643

Mettre les 7 premières valeurs du commit sont suffisant. Git t'informera que que HEAD pointe maintenant vers ce commit. Tu remarqueras aussi le fichier que l'etat de notre dossier a changé:

• Le dernier fichier que nous avons rajouté a disparu.
• Le fichier tuto-git.py a repris son contenu initial.

Verifier le commit actuel.

Il suffit d'afficher le HEAD.

$ git show head

Créer une branche

Une branche est créée (par defaut) à partir du HEAD sur lequel nous nous trouvons, ce qui peut donc être un commit ou une autre branche. Nous allons nous deplacer vers le commit 2 et créer une branch que nous appelerons "dev".

$ git checkout 37ec6a7
$ git checkout -b dev
# le paramètre -b indique que nous créeons une nouvelle branch

Nous aurons ainsi ce graphe, qui indique que la branche "dev" se situe sur le second commit.

La branche dev devient ainsi notre nouveau HEAD et nous pouvons y rajouter d'autres modifications. La branch master dépasse pour l'instant dev d'un commit qui correspond au dernier fichier que nous avons ajouté (lib-python.py). Ce fichier ne s'affichera que lorsque nous revenons sur la branche "master".

$ git checkout master

Nous pouvons ainsi créer plusieurs branches qui vont correspondre à la modification (sujet du sprint) que nous voulons effectuer.

Voici  un exemple de repository différent du notre  ayant plusieurs branches:

Une fois l'ensemble des modifications effectuées sur une branche, nous pouvons les appliquer sur la branche principale (master) en effectuant une fusion.
Ainsi, plusieurs développeurs peuvent ajouter des modifications du projets sur des branches différentes et fusionner plus tard leurs modifications sur la branche principale.  Pour effectuer cette fusion il faut:

Se placer sur la branche qui reçoit la fusion (master par exemple)

$ git checkout master

Fusionner la branche dev vers master

$ git merge dev

Tous les commits qui ont été rajouté sur la branche  "dev" vont ainsi se retrouver sur la branche "master".

4- Ajouter des versions grâce aux tags

Lors de la création d'un projet, nous utilisons un système de version qui est en général sous ce format X.Y.Z ( Ex: 1.0.1) où les valeurs de X, Y ou Z correspondent à une évolution d'une certaine catégorie de fonctionnalité de notre projet. Plus de détails sur ce format avec cette page  qui décrit le semantic versionning.
C'est en anglais je sais, mais dis toi que moi aussi j'aurai pu ecrire ce document en anglais.

Une version n'est rien d'autre qu'un commit que nous allons nommer au format X.Y.Z. Ci dessous les commandes pour créer un tag ou le manipuler:

Se placer au niveau du commit à nommer.

$ git checkout 224916aef8c1776778eb79c0537365d4989d374c

Ajouter un tag avec un message

git tag -a 1.4.0 -m "my version 1.4.0"

Ajouter un tag sans message

git tag  1.4.0 

Afficher les tags

git tag 

Supprimer un tag

git tag -d 1.4.0 

Accèder à un tag specifique:

git checkout 1.4.0

Ces tags sont ainsi beaucoup plus facile à manipuler que les commits et permettent de livrer une version spécifique de notre projet.

II - Rappel des commandes de base:

Ci-dessous les commandes à retenir pour manipuler votre "repository git".

1- Le rapository git

• Creation

$ git init

• Suppression du repository

$ rm -r .git

2 - Les branches

• Création d'une branche

$ git checkout -b nom_branche 

• Liste des branches

$ git branch 

• Accèder à une branche

$ git checkout nom_branche 

• Fusionner 2 branches

$ git checkout nom_branche_destination
$ git merge nom_branche_source

• Supprimer une branche

$ git branch -D nom_branch 

3 - Les commits

• Ajouter un ou des fichiers au prochain commit

$ git add nom_fichier_1 [nom_fichier_1 .... nom_fichier_X]

• Ajouter tous les fichiers

$ git add .

• Créer un commit

$ git commit -m "Message du commit"

• Modifier le commit précedent après avoir rajouté un fichier

$ git commit --amend 

• Liste de commit

$ git log
$ git log --oneline

• Annuler les modifications effectué lors d'un commit

$ git revert IDENTIFIANT_COMMIT

4 - Les tags

• Créer un tag

$  git tag -a nom_tag IDENTIFIANT_COMMIT -m "Message du tag"

• Créer un tag sans le message

$  git tag  nom_tag IDENTIFIANT_COMMIT 

• Afficher les details d'un tag

$  git show  nom_tag 

• Afficher la liste des tags

$  git tag

• Accèder à un tag

$  git checkout nom_tag

• Supprimer un tag

$  git tag -d nom_tag

Pour la suite de ces tutorials qui portent sur Git, nous parlerons d'un outils GitFlow qui permet de faciliter la création et la fusion des branches au niveau d'un projet. Retrouvez cet article expliqué sur ce lien.