Qu'est-ce qu'un VCS?

Une définition

Système permettant de gérer des changements effectués sur des documents, fichiers sources, sites web, etc.

Gérer c'est pouvoir:

• revenir à une version précédente (i.e. historique et correction)
• travailler sur plusieurs versions en parallèle (i.e. travail de groupe et "features")

Gérer des historiques

Une solution standard:

	monfichier.txt
	monfichier.txt.old  # cpold
	monfichier.v2.txt
	monfichier.v2.3txt
	monfichier.v2.3.GC.txt
	monfichier.v2.3.TR.txt
	monfichier.v2.3.GC.TR.20190624.txt
	monfichier.vFinal.txt
	monfichier.vFinal.withmodif.txt
								

Problèmes:

• nommage collaboratif pas homogène
• qui a effectué un changement ?
• quand a-t-il été effectué ?
• qu'est ce qui a été changé et pourquoi ?
• difficile de partager cet historique
• pas de backup
• ne monte pas en charge facilement (scalability)

Travailler en parallèle

Cela suppose d'automatiser au maximum les phases suivantes:

• Partager le contenu facilement
• Travailler sur sa version séparément des autres personnes et versions
• Fusionner (merge) les versions

Quelques VCS

Nous ne vous disons pas tout...

Le livre en ligne git est extrêmement bien fait et vous apprendra tout ce que nous n'avons pas le temps de vous montrer:

Un tutoriel plus rapide:

Un guide intéressant:

Un petit jeu si vous vous ennuyez pendant ce cours ou plus tard:

Structure et operations git

Installation et Configuration

Installation

• Sur mac: installer Xcode (autres solutions possibles)
• Sur windows:
• installer le logiciel git incluant Git Bash
• lancer le programme "Git Bash"
• Sur linux: utiliser le gestionnaire de package

Configuration

$ git config --list

Configuration

Avant d'utiliser git il faut toujours configurer au moins:

• Obligatoirement votre nom et email:

								$ git config --global user.name "Prénom Nom"
								$ git config --global user.email "Prénom.Nom@email.cc"
							

• Le nom de votre branche principale (master par défaut...)

								$ git config --global init.defaultBranch main
							

Note: la configuration peut être locale (i.e. ne pas utiliser --global) si l'on veut utiliser des identifiants différents pour un ou plusieurs dépôt

Dépôt local (repository)

Objectif du dépôt

L'objectif du dépôt est de stocker des recettes de cuisines.

Chaque recette prendra ce format:

- ingrédient 1
- ingrédient 2
- ingrédient 3

Première opération
Deuxième opération
Cuisson
etc.
						

Commandes utiles

Initialiser un dépôt

$ git init

Ajouter les modifications à l'index (un fichier ou tous les fichiers modifiés)

							$ git add fichier
							$ git add . # tous les fichiers
						

Ajouter toutes les modifications de l'index au dépôt

$ git commit

Vérifier l'état du dossier (working tree) et de l'index (staging area)

$ git status

Un premier dépôt

A chaque étape observer le status du dépôt:

• Créez un dépôt dans un dossier "recettes"
• Crée un fichier readme.md contenant

# Mes recettes
Chaque fichier contient des recettes que j'apprécie
							

• Ajoutez ce fichier au dépôt (d'abord à l'index avec add puis au dépôt avec commit )
• Créez trois fichiers de recettes: deux sandwichs et une salade
• Ajoutez les deux sandwichs en 1 commit nommé "Ajout de deux sandwich"
• Ajoutez la salade en 1 commit nommé "Ajout d'une salade"

Modification d'un fichier

• Modifiez le fichier readme.md pour qu'il contienne:

# Mes recettes
Chaque fichier contient une recette que j'apprécie
							

• Ajoutez cette modification au dépôt
• Utilisez la commande "git log" pour voir le résultat (à discuter ensemble)

Observer et comparer

• Observer l'historique:

  $ git log

• Regarder ce qui pourrait être ajouté à l'index (working directory vs. index):

  $ git diff [filename]

  Modifier une recette et utiliser la commande ci-dessus
• Regarder le travail effectué depuis un commit (working directory vs. commit):

  $ git diff commit-hash [filename]

  Regarder les modifications effectuées depuis la modification du fichier readme.md
• Regarder le travail effectué entre deux commits (commit vs. commit, attention à l'ordre):

  $ git diff hash-ancien hash-recent [filename]

  Regarder les différences entre les deux versions du fichier readme.md

Observer l'état actuel

Ne jamais se priver d'utiliser la commande git status

							$ git status
							On branch main
							Changes to be committed:
							(use "git restore --staged <file>..." to unstage)
									modified:   sandwich1.md

							Changes not staged for commit:
							(use "git add <file>..." to update what will be committed)
							(use "git restore <file>..." to discard changes in working directory)
								modified:   salade.md

							Untracked files:
							(use "git add <file>..." to include in what will be committed)
								salade2.md
						

Vous y trouverez notament:

• en vert les fichiers dans l'index;
• en rouge les modifications du working tree non présentes dans l'index
• des tonnes d'indications sur les commandes utilisables

Corriger working tree et staging area

Vérifier le statut après chaque opération:

• Ajoutez du sel à votre recette
• Ajoutez le changement dans l'index puis le retirer de l'index
• Retirez ce changement de votre fichier en utilisant git uniquement

Diviser pour mieux régner

"Zut... j'ai fait trop de changements dans mon fichier et je voudrais les insérer en plusieurs commit"

$ git add -p; git commit

Example - enseignant seulement

Ajouter les modifications ci-dessous en plusieurs commits.

# Mes recettes
Chaque fichier contient des recettes que j'apprécie

## Entrées
- salade niçoise
- scalade de chèvre

## Plats d'hiver (ou pas)
- fondue
- tartiflette
						

Suppression de fichiers

• Observez le status du dépot tout au long de ces opérations


• Si ce n'est pas déjà fait ajoutez plusieurs recettes
• Supprimez un fichier de la manière habituelle
• Observez le statut du dépôt et trouvez une solution pour effectuer un commit de ce changement


• Changez le nom d'une recette (i.e. nom du fichier)
• Observez le statut du dépôt
• Ajoutez toutes les modifications à l'index


• Conclure à partir de l'évolution du statut du dépôt

Quel contenu mettre dans les dépôts ?

Il existe une solution pour eviter d'ajouter des fichiers non voulus dans l'index: .gitignore

Les branches

Problème habituellement rencontré

Problème habituellement rencontré

Pas la peine d'avoir un boss ou de travailler en équipe pour faire face à ce genre de problème

Création et utilisation d'une branche

git branch new-branch-name

git checkout la-branche-de-destination

git branch

Utiliser des branches

Tout au long de cet exercice utlisez git status pour vérifier sur quel branche vous êtes.

• Créez une nouvelle branche dont le but sera de transformer toutes les listes d'ingrédients en listes numérotées. Nommer cette branche intelligement.
• Numérotez les listes dans la nouvelle branche et ajoutez les modifications au dépôt
• Revenez dans la main et observez le contenu du working directory

Un peu plus sur checkout

Intégrer une branche dans une autre: merge

Le but d'une branche est souvent d'être intégrée à sa branche de départ. Pour intégrer la branche new dans la branche old il faut:

git checkout old
git merge new
						

Intégrer une branche dans une autre: merge

Merger / Combiner les branches

• Effectuez le merge de votre branche contenant les numérotations vers la branche master. De quel type de merge s'agit-il?


• Ajoutez une recette à la branche main (i.e. commit).
• Ajoutez une recette à la branche numérotation (i.e. commit).
• effectuez un merge de numérotation vers main. De quel type de merge s'agit-il?

C'est vraiment super facile de faire un merge !?

git mergetool

Merger des modifications "complexes"

• Créez une nouvelle branche auteur
• Dans cette branche ajoutez un auteur sur la première ligne de vos recettes et effectuez un commit
• Revenez à la branche master
• Ajoutez du sel comme premier ingrédient à une des recettes (avec commit)
• Effectuez un merge de la branche auteur vers la branche master. S'aider de l'IDE.

Visualiser les branches

git log --graph --all

Un modèle de branches: gitflow

Les remotes: enfin du GIT collaboratif !

remote workflows

Backup sur remote

Collaboration sur un dépôt

Collaboration par fork

Bonus

Aide visuelle

export GIT_PS1_SHOWDIRTYSTATE=1
export PS1='\w$(__git_ps1 " (%s)")\$ '
							

Stash: une commande utile

$ git stash                    # place les changements dans une liste (cachette) → "a clean working directory"
$ git stash list               # liste le contenu de la cachette
$ git stash apply [stash-name] # applique les modifications sur le commit courant sans le retirer de la liste
$ git stash pop [stash-name]   # applique les modifications sur le commit courant en le retirant de la liste

							

Rhaaaaaaaa... au secours !

• "J'ai oublié de mettre un fichier dans mon commit / j'ai fait une erreur dans le message de commit"

  $ git commit --amend



• "Mais pourquoi j'ai fait ce commit !!!! Je veux le supprimer."

  $ git revert commit-hash  # "git reset commit-hash" pour "revenir en arrière" mais c'est à éviter

Corriger les commits

• Modifiez le dernier commit:
• Observez votre dernier numéro de commit
• Modifiez votre dernier message de commit
• Observez votre dernier numéro de commit


• Supprimez les changements effectués par un commit:
• Observez votre historique
• Annulez le commit qui changeait votre première recette (voir exercice précédent)
• Annulez le précédent commit d'annulation
• Observez votre historique