GIT

Introduction

Il était une fois

[user@dev monprojet]$ ls
monfichier.txt
monfichier.old
monfichier.old2
monfichier.old.du.lundi
monfichier.old.du.lundi.avant
monfichier.old.bak
...

Rudiments de Git

Vérifier vos paramètres

$ git config --list
user.name=John Doe
user.email=jd@mail.com
color.status=auto
color.branch=auto
color.interactive=auto
color.diff=auto
…

$ git config user.name
John Doe

Démarrage d’un dépôt Git local

$ git init

Cela crée un nouveau sous-répertoire nommé .git qui contient tous les fichiers nécessaires au dépôt.

$ git add *.c
$ git add LICENSE
$ git commit -m 'initial project version'

Il est nécessaire de lancer la commande git add pour ajouter les fichiers dans l’index avant commit.

Les alias Git

Certaines commandes Git sont trop longues ou difficiles à mémoriser, pour nous aider nous pouvons utiliser les alias :

git config --global alias.loga "log --oneline --graph --all"

Créer une nouvelle branche

git branch testing

Cela crée un nouveau pointeur vers le commit courant.

Changer de branche

$ git checkout testing

Et bien, faisons une autre validation :

$ vim README.md
$ git commit -a -m 'un changement dans le fichier README'

Retournons sur la branche master

$ git checkout master

Nouvelle modification pour diverger

$ vim README.md
$ git commit -a -m 'un changement dans le fichier README'

Suppression d’une branche

$ git branch -d testing

Merge Fast-forward

$ git checkout master
$ git merge hotfix
Updating f30ab..87ab2
Fast-forward
 index.html | 2 ++
 1 file changed, 2 insertions(+)

Cloner un dépôt distant

Via https:

git clone https://framagit.org/gauthier/SlideGit.git

Via ssh:

git clone git@framagit.org:gauthier/SlideGit.git

Depuis un autre dossier:

git clone /home/user/git/MonProjet.git

Afficher les dépôts distants

$ git remote -v
origin   https://framagit.org/gauthier/SlideGit.git (fetch)
origin   https://framagit.org/gauthier/SlideGit.git (push)

Ajouter des dépôts distants

$ git remote
origin
$ git remote add paul https://gitlab.com/paul/SlideGit
$ git remote -v
origin   https://framagit.org/gauthier/SlideGit.git (fetch)
origin   https://framagit.org/gauthier/SlideGit.git (push)
paul   https://gilab.com/paul/SlideGit.git (fetch)
paul   https://gilab.com/paul/SlideGit.git (push)

Récupérer et tirer depuis des dépôts distants

$ git fetch [remote-name]

Récupérer et tirer depuis des dépôts distants + fusion

$ git pull [remote-name]

Pousser son travail sur un dépôt distant

$ git push [nom-distant] [nom-de-branche]

Inspecter un dépôt distant

$ git remote show origin
* distante origin
  URL de rapatriement : git@framagit.org:gauthier/SlideGit.git
  URL push : git@framagit.org:gauthier/SlideGit.git
  Branche HEAD : master
  Branche distante :
    master suivi
  Branche locale configurée pour 'git pull' :
    master fusionne avec la distante master
  Référence locale configurée pour 'git push' :
    master pousse vers master (à jour)

Retirer et renommer des dépôts distants

$ git remote rename paul polo
$ git remote
origin
polo

Authentification HTTP

Plusieurs modes proposés:

Par défaut, rien n’est mis en cache.
Le mode « cache » conserve en mémoire les identifiants pendant 15 minutes par défaut.

git config --global credential.helper "cache --timeout 900"

Le mode « store » sauvegarde les identifiants dans un fichier texte (en clair) sur le disque, et celui-ci n’expire jamais.

git config --global credential.helper "store --file ~/.my-credentials"

Créer des étiquettes annotées

$ git tag -a v1.4 -m 'ma version 1.4'
$ git tag
v1.3
v1.4

Vous pouvez visualiser les données de l’étiquette à côté du commit qui a été marqué en utilisant la commande git show

Les étiquettes légères

Pour créer une étiquette légère, il suffit de n’utiliser aucune des options -a, -s ou -m :

$ git tag v1.4-lg
$ git tag
v0.1
v1.4
v1.4-lg
v1.5

Regarder la différence de sortie avec git show.

Lister vos étiquettes

Lister les étiquettes existantes dans Git est très simple. Tapez juste git tag :

$ git tag
v0.1
v1.3

Recherche avec un motif

$ git tag -l 'v1.3.*'
v1.3.1
v1.3.2

Étiqueter après coup

Pour étiqueter un ancien commit, vous spécifiez la somme de contrôle du commit (ou une partie) en fin de commande :

$ git tag -a v1.2 9fceb02

Partager les étiquettes

Par défaut, la commande git push ne transfère pas les étiquettes vers les serveurs distants. Il faut explicitement pousser les étiquettes après les avoir créées localement.

$ git push origin v1.5

La commande suivante transférera toutes les nouvelles étiquettes vers le serveur distant.

$ git push origin --tags

Merge avec conflit

Si votre résolution du problème #53 a modifié la même section de fichier que le correctif, vous obtiendrez un conflit qui ressemblera à ceci :

$ git merge prob53
Fusion automatique de index.html
CONFLIT (contenu) : Conflit de fusion dans index.html
La fusion automatique a échoué ; réglez les conflits et validez le résultat.

Git n’a pas automatiquement créé le commit de fusion. Il a arrêté le processus le temps que vous résolviez le conflit.

Verification de la liste des fichiers impactés

$ git status
Sur la branche master
Vous avez des chemins non fusionnés.
  (réglez les conflits puis lancez "git commit")
  (use "git merge --abort" to abort the merge)

Chemins non fusionnés :
  (utilisez "git add <fichier>..." pour marquer comme résolu)

        modifié des deux côtés :  index.html

aucune modification n'a été ajoutée à la validation (utilisez "git add" ou "git commit -a")

Correction du conflit à la main

 <<<<<<< HEAD:index.html
 <div id="footer">contact : email.support@github.com</div>
 =======
 <div id="footer">
  please contact us at support@github.com
 </div>
 >>>>>>> prob53:index.html

C’est au développeur de prendre la décision et d’enregistrer le fichier. Ensuite git add et d’un git commit pour terminer l’opération.

Abandonner une fusion

$ git merge --abort

Ignorer les caractères invisibles lors de la fusion

$ git merge -Xignore-all-space mabranche

ou

$ git merge -Xignore-space-change mabranche

La première option ignore complètement tous les espaces tandis que la seconde traite les séquences d’un ou plusieurs espaces comme équivalentes.

Action du git rebase

$ git checkout testing
$ git rebase master
First, rewinding head to replay your work on top of it...
Applying: added staged command

Exemple

fix($compile): couple of unit tests for IE9

Older IEs serialize html uppercased, but IE9 does not...
Would be better to expect case insensitive, unfortunately jasmine does
not allow to user regexps for throw expectations.

Closes #392
Breaks foo.bar api, foo.baz should be used instead

git add --interactive

Cette commande affiche la liste des sous commandes de git add.

 *** Commands ***
   1: status       2: update       3: revert       4: add untracked
   5: patch        6: diff         7: quit         8: help
 What now> 1

git add --patch

Permet de choisir block par block ce que l’on souhaite ajouter à l’index.

   y - stage this hunk
   n - do not stage this hunk
   q - quit; do not stage this hunk or any of the remaining ones
   a - stage this hunk and all later hunks in the file
   d - do not stage this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

git commit --amend

Remplace le commit précédent. Utile si vous avez oublié un fichier, ou vue une faute de frappe dans votre message.

$ git commit -m 'validation initiale'
$ git add fichier_oublie
$ git commit --amend

Vous n’aurez au final qu’un unique commit — la seconde validation remplace le résultat de la première.

Si vous ne souhaitez pas modifier le message de commit, ajoutez l’option --no-edit.

Défaire les fusions

Avec Git il n’est pas interdit de faire des erreurs, parce qu’il reste toujours possible de les corriger.

$ git reset --hard HEAD~

reset --hard réalise généralement trois étapes :

Déplace la branche pointée par HEAD,
Faire ressembler l’index à HEAD,
Faire ressembler le répertoire de travail à l’index.

À éviter après un push ou un autre commit.

Inverser le commit

Si les déplacements des pointeurs de branche ne sont pas envisageables, Git vous donne encore l’option de créer un nouveau commit qui défait toutes les modifications d’un autre déjà existant.

$ git revert -m 1 HEAD

L’option -m 1 indique quel parent est le principal et devrait être conservé.

Attention, une nouvelle fusion ne donnera rien, car la branche a déjà été fusionnée.

Désindexer un fichier déjà indexé

$ git add .
$ git status
Sur la branche master
Votre branche est à jour avec 'origin/master'.
Modifications qui seront validées :
  (utilisez "git reset HEAD <fichier>..." pour désindexer)

      renommé :   README.md -> README
      modifié :   CONTRIBUTING.md

La commande est rappelée lors du git status.

$ git reset HEAD CONTRIBUTING.md
Modifications non indexées après reset :
M       CONTRIBUTING.md

Réinitialiser un fichier modifié

$ git checkout -- CONTRIBUTING.md
$ git status
Sur la branche master
Votre branche est à jour avec 'origin/master'.
Modifications qui seront validées :
  (utilisez "git reset HEAD <fichier>..." pour désindexer)

          renommé :         README.md -> README

Vous pouvez constater que les modifications ont été annulées.

Commandes:

p, pick = utilise le commit sans y toucher
r, reword = édite du message sans changer le commit
e, edit = permet d'éditer les fichiers, de modifier le commit
s, squash = utiliser le commit, en fusionnant le commit précédent
f, fixup = comme "squash", mais rejette le message de ce commit
x, exec = exécute la commande (le reste de la ligne) en utilisant le shell
d, drop = supprime le commit

Les lignes de commit peuvent être ré-ordonnées; elles sont exécutées de haut en bas.
Si vous supprimez une ligne le commit sera perdu.
Si vous supprimez tout les lignes, le rebase sera annulé.

Astuce

Au début, si vous avez peur de vous tromper, créez une branche avant de rebaser pour facilement revenir en arrière.

$ git branch avantRebase
$ git rebase -i
...
$ git reset --hard avantRebase

Appliquer le contenue du stash

Au même endroit mais plus tard, ou encore dans une autre branche:

# Pour le dépiler.
$ git stash pop

# En le gardant dans le stash pour l’appliquer
# plusieurs fois.
$ git stash apply

Défaire l’effet d’une remise

Il n’existe pas de commande stash unapply.

 git stash show -p stash@{0} | git apply -R

Si la remise n’est pas indiquée, Git utilise la plus récente.

Démarrer un sous-module

Pour ajouter un nouveau sous-module, nous utilisons la commande git submodule add avec l’URL du projet que nous souhaitons suivre.

git submodule add https://github.com/hakimel/reveal.js.git

Comme pour git clone nous pouvons préciser un dossier cible.

git status permet de constater la création de 2 entrées:

Sur la branche master
Modifications qui seront validées :
  (utilisez "git reset HEAD <fichier>..." pour désindexer)

        nouveau fichier : .gitmodules
        nouveau fichier : reveal.js

.gitmodules est le fichier de configuration qui stocke la liaison entre l’URL du projet et le sous-répertoire local dans lequel vous l’avez tiré.

cat .gitmodules

[submodule "reveal.js"]
        path = reveal.js
        url = https://github.com/hakimel/reveal.js.git

Si vous avez plusieurs sous-modules, vous aurez plusieurs entrées dans ce fichier.

Cloner un projet avec des sous-modules

Quand vous récupérez un projet avec des sous-modules, vous obtenez les différents répertoires qui contiennent les sous-modules, mais encore aucun des fichiers.

git clone https://monprojet...
git submodule init
git submodule update

ou

git clone https://monprojet...
git submodule update --init --recursive

ou

git clone --recurse-submodules https://monprojet...

Commiter les changements dans un sous-modules

S’assurer que vous n’êtes pas dans l’état HEAD détaché

git merge master && git checkout -B master

modifier vos fichiers dans le sous-modules et commiter.
Pousser les modifications sur le remote.
Revenir dans le dossier parent.
Commiter le sous-modules.
Pousser les modifications.

git worktree

Il est parfois nécessaire de modifier en même temps 2 branches d’un même projet, et nous ne voulons pas sans arrêt lancer la commande git checkout.

$ git worktree add -b mabranche /home/user/dev/TestWorktree
$ git worktree list
/home/user/dev/Projet        6706591 [master]
/home/user/dev/TestWorktree  e2cdd3e [mabranche]

git filter-branch

git filter-branch traite tout l’historique du référentiel à travers les filtres donnés et réécrit les commits si leur contenu est modifié.

Exemple :

$ git filter-branch --tree-filter "rm -f passwords.txt"