Git tricks

Introduction

Git est un outil très utile, utilisé très largement aujourd’hui pour le versioning de fichiers. Effectuer les actions de base est assez facile, mais il existe de petites astuces et raccourcis qui peuvent vous faire gagner du temps !

Git config

Avant toute chose, voici une configuration de base de git :

$ git config --global pull.rebase true

Cette ligne permet de rebase au moment du pull plutôt que de merge, ce qui vous permettra de ne pas détruire le log des commits, étant donné que merge rajoute un commit par défaut au moment de la résolution des changements distants. Cette configuration n'est pas réellement un secret, vous devez d'ailleurs déjà l'utiliser avec git pull --rebase, mais c'est un must-have.

$ git staus # ERROR

Ah, les coquilles 😢 en temps normal la commande précédente ne fonctionne pas, et vous êtes obligé de bien taper status au lieu de staus. Sauf si...

$ git config --global help.autocorrect 1

Cette configuration vous permettra de corriger automatiquement les erreurs de commande, lorsque vous faites 1 faute de frappe. Très utile si ça vous arrive souvent !

Git rebase

Parlons de rebase plus en détail ! La première chose à savoir est comment rebase manuellement avant de merge une branche :

$ git checkout my-branch
$ git rebase master
$ git checkout master
$ git merge my-branch --ff-only # fast forward only

C'est aussi simple que ça ! Voyons maintenant comment peut-on utiliser git rebase pour apporter des modifications sur nos commits.

Imaginons que sur une branche crab-branch nous avons ces changements:

Dans un premier lieu, j'aimerais éditer mon deuxième commit pour y ajouter un deuxième crab yee-claw: Il y a 2 méthodes:

Cibler le commit directement et éditer

$ git rebase -i '3cdab36d'

Ou comme ceci pour effectuer plusieurs actions si besoin. Par exemple, on va éditer notre commit et changer le message du suivant.

$ git rebase -i HEAD~2

Ensuite, il suffit de faire les modifications souhaités puis :

$ git add src/crabYeeClaw.ts
$ git rebase --continue

Maintenant, le rebase nous emmène à l'étape suivante (le rewording de notre commit):

Nous pouvons maintenant git push --force-with-lease notre rebasage ! Comme vous l'avez compris, c'est un outil très puissant. Il y a plusieurs actions possibles lors d'un rebasage interactif (notamment squash), je vous conseille vivement d'aller y jeter un oeil avec git rebase --help.

Git add

Tout le monde sait ajouter des fichiers à un commit, mais il existe des méthodes qui permettent de faire cette action plus rapidement. Tout d'abord:

$ git add .

Cela permet d'ajouter tous les fichiers et dossiers (nouveaux ou modifiés) à partir du chemin courant.

Maintenant, imaginons que nous ne voulions ajouter que les fichiers modifiés, sans les nouveaux.

$ git add -u

Mince ! Parmi les fichiers modifiés il y en a un que je ne voulais pas ajouter 😱 Pas de panique:

$ git add -i

Facile n'est-ce pas ? Comme vous pouvez le voir il y a plusieurs actions disponibles en mode interactif, notamment pouvoir ajouter les nouveaux fichier uniquement avec add untracked.

C'est un outil très puissant également ! Pour plus de détails git add --help.

Git stash

Déjà très communément utilisé, git stash est une commande permettant de mettre tous ses changes de côtés pendant un moment, puis pouvoir les pull (pop) plus tard. Très utile avant un git pull:

$ # make some changes
$ git stash
$ git pull
$ git stash pop

Ou encore plus simplement :

$ git pull --autostash

Il est également possible de stash des changements en particulier:

$ # make some changes
$ git stash -p
$ ## si vous voulez créer un nouveau commit à partir des changements:
$ git stash -p -m "feat: add a fantastic feature"

Ou encore, stash des changements avec label en particulier. Ainsi, si vous devez réaliser plusieurs stash, vous pouvez utiliser:

$ git stash save 'The crab is hungry'
$ # do whatever you want
$ git stash save 'Pablo the crab is now satiated'
$ git stash apply 'The crab is hungry' # only apply the first stash

Un outil très puissant pour vous y retrouver dans vos stash !

Git reflog

git quoi ?

git reflog est une commande utilisée par les mages noirs pour voir les modifications qui ont été apportées par le passé, supprimées ou non. C'est un outil très puissant qui vous permettra de redonner la vie à des changements perdus. Par exemple:

$ git add src/domain/pizzaCrab.ts
$ git commit -m "feat: pizzaCrab is making pizza"
$ git rebase -i HEAD~1
$ # drop commit

Oh non ! J'ai perdu mon pizzaCrab en pensant que je n'en aurais plus besoin. Pas de panique:

$ git reflog # invoke some dark magic here

Ce qu'il se passe derrière est pourtant très simple, git sauvegarde tout l'historique des modifications sous forme de refs. git reflog ne fait que log ces refs. Il est tout à fait possible de checkout ou reset sur une de ces refs pour récupérer les changements perdus:

$ git stash
$ git reset --hard 5df9d09
$ git stash pop

Nous sommes revenus dans le passés grâce à git reflog et git reset (qui permet de replacer la HEAD sur une ref) !

Git bisect

git bisect est une commande bien connue, utilisée notamment pour la recherche de bug à travers un nombre de commit assez volumineux. Elle se base sur la recherche dichotomique.

Le principe est simple: on commence à l'endroit souhaité, puis git va rembobiner les commits jusqu'à ce que nous trouvions le commit coupable du bug. Pour cela, il faut utiliser les commandes suivantes:

$ git bisect start
$ git bisect bad # current version is broken
$ git bisect good <commit> # this commit is assumed to be good

A partir de ces 3 commandes, git va chercher les commits qui sont coupables du bug en itérant sur des commits. Il faut les tester un à un et les taguer en good ou bad.

$ git bisect good # current version is working
$ git bisect bad # current version is broken

Après quelques répétitions de l'étape précédente, git affichera le commit coupable.

Une fois le commit coupable repéré, on peut tout nettoyer:

$ git bisect reset

(never do this)