Pense bête Git suite: réparer les erreurs

L'un des intérêts des systèmes de versionning est de pouvoir revenir en arrière lorsque l'on s'est trompé. Git possède plusieurs commandes permettant de le faire, leur utilisation dépendant de la situation.
Voici une liste non-exhaustive de commandes utiles suivant les cas.

Préambule

J'ai l'habitude d'utiliser des alias dans mes commandes git (co pour checkout, ci pour commit...) par habitude des commandes SVN.
Mes exemples seront donc avec ces alias.
Si vous voulez les utiliser également, voici les commandes à taper:

 
git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.st status

Le pré-requis de chaque section de cet article est qu'on a découvert une erreur dans un ou plusieurs fichiers.

Le fichier n'est pas encore commité

Le cas le plus simple, mais qu'il fallait quand même mettre pour être complet.

 
git co -- <fichier>
 

Si je veux supprimer toutes les modifications que j'ai faites depuis le dernier commit:

 
git reset HEAD

Fichier commité mais non pushé

Tout peut encore être défait et réécrit sans risque.

Dernier commit

Si on a fait une erreur dans le message de commit, c'est tout simple, il suffit de taper la commande suivante:

 
git ci --amend -m "Nouveau message"

Cette commande permet également de modifier l'auteur si vous avez oublié de configurer votre compte git.

 
git ci --amend --author='Nom <mail@exemple.com>'

Dans l'ensemble, la commande git commit --amend permet de reprendre le dernier commit.

Rappel, pour configurer votre compte:

 
git config --global user.name "Votre Nom"
git config --global user.email "adresse mail"

Revenir à un commit

 
git reset HEAD^1 --soft

Revient à l'avant dernier commit en supprimant le dernier de l'historique tout en gardant les modifications faites depuis.
L'option --soft permet de laisser les fichiers du commit dans l'index, pour ne pas se tromper avec d'eventelles modifications faites depuis.
L'option --hard supprime les modifications.
A la place de HEAD^1, on peut mettre un numéro de commit.

Rappel: pour retirer un fichier de l'index, la commande est:

 
git reset HEAD <fichier>
 

Et pour voir les modifications d'un fichier dans l'index, la commande est:

 
git diff --cached <fichier>

Fichier pushé

La façon de procéder la plus propre est de créer un commit qui annulera les modifications du commit incriminé.

 
git revert <commit>

L'option -n (--no-commit) permet de préparer le commit mais sans l'effectuer, pour personnaliser le message par exemple.

Un seul fichier pose problème

Si on se rend compte qu'on a commité une bétise dans un seul fichier il y a plusieurs commit, reverter tout le commit n'est pas necessaire. Pour faire revenir un fichier dans un état précedant, il faut tout d'abord retrouver le dernier commit dans lequel le fichier est "correct" (par exemple en utilisant git log puis git show pour visualiser le commit), puis la commande est:

 
git reset <commit> <fichier>

Ensuite on peut soit commiter directement le fichier dans son état précédant, soit d'abord le remodifier. Personnellement je trouves la première solution plus propre car elle permet de mieux comprendre ce qui a été fait lorsque l'on regarde l'historique.

Résumé

Les commandes principales pour réparer une erreur sont git reset et git revert, les deux proposent de nombreuses options.
N'hésitez pas à ajouter l'option --help sur n'importe quelle commande git, l'aide est ligne est plutôt complète et contient des exemples.

Cet article est loin d'être complet, et si je trouves d'autres commandes/options pratiques, je les ajouterai.