Comment vérifier qu'un commit a été appliqué à l'aide de git cherry-pick

Introduction

Git est un puissant système de contrôle de version qui permet aux développeurs de gérer efficacement leur base de code. L'une des fonctionnalités clés de Git est la capacité d'appliquer sélectivement des commits d'une branche à une autre en utilisant la commande cherry-pick. Ce tutoriel vous guidera tout au long du processus de vérification que le commit a été appliqué avec succès à l'aide de la commande Git cherry-pick, ainsi que des stratégies pour résoudre tout conflit qui pourrait survenir au cours du processus.

Comprendre Git Cherry-pick

Git cherry-pick est une fonctionnalité puissante qui vous permet d'appliquer sélectivement des commits d'une branche à une autre. Cela est particulièrement utile lorsque vous souhaitez intégrer des modifications spécifiques d'une branche dans une autre, sans fusionner l'ensemble de la branche.

Qu'est-ce que Git Cherry-pick?

Git cherry-pick est une commande qui prend les modifications introduites par un seul commit et les applique à une autre branche. Cela est utile lorsque vous souhaitez :

Rétroporter des corrections (Backport Fixes): Si vous avez corrigé un bogue dans une branche que vous souhaitez appliquer à une autre branche, vous pouvez utiliser cherry-pick pour ce faire.
Réappliquer des commits: Si vous avez accidentellement effectué un rebase ou un reset d'une branche et que vous souhaitez réappliquer des commits spécifiques, vous pouvez utiliser cherry-pick pour ce faire.
Maintenir un historique de commits linéaire: En utilisant cherry-pick pour appliquer des commits, vous pouvez maintenir un historique de commits linéaire, qui peut être plus facile à comprendre et à gérer.

Quand utiliser Git Cherry-pick

Git cherry-pick est généralement utilisé dans les scénarios suivants :

Rétroporter des corrections (Backport Fixes): Lorsque vous avez corrigé un bogue dans une branche que vous souhaitez appliquer à une autre branche, comme une branche de version (release) ou une branche stable.
Maintenir un historique de commits linéaire: Si vous avez une branche de fonctionnalité qui a divergé considérablement de la branche principale, vous pouvez utiliser cherry-pick pour appliquer des commits spécifiques et maintenir un historique de commits linéaire.
Réappliquer des commits: Si vous avez accidentellement effectué un rebase ou un reset d'une branche et que vous souhaitez réappliquer des commits spécifiques, vous pouvez utiliser cherry-pick pour ce faire.

Comment fonctionne Git Cherry-pick

Lorsque vous utilisez la commande git cherry-pick, Git crée un nouveau commit sur la branche actuelle qui contient les mêmes modifications que le commit spécifié. Ce nouveau commit a un hash de commit différent, mais les modifications sont les mêmes que celles du commit original.

graph LR
  A[Commit A] --> B[Commit B]
  B --> C[Commit C]
  C --> D[Commit D]
  D --> E[Commit E]
  E --> F[Commit F]
  F --> G[Commit G]
  G --> H[Commit H]
  H --> I[Commit I]
  I --> J[Commit J]
  J --> K[Commit K]
  K --> L[Commit L]
  L --> M[Commit M]
  M --> N[Commit N]
  N --> O[Commit O]
  O --> P[Commit P]

Dans le diagramme ci-dessus, si vous souhaitez appliquer les modifications de Commit E à une autre branche, vous pouvez utiliser git cherry-pick E pour créer un nouveau commit avec les mêmes modifications que Commit E.

Appliquer et vérifier les commits cherry-pickés

Appliquer des commits cherry-pickés

Pour appliquer un commit cherry-pické, vous pouvez utiliser la commande git cherry-pick suivie du hash du commit ou du nom de la branche. Par exemple :

$ git cherry-pick e8e8c23

Cela appliquera les modifications du commit avec le hash e8e8c23 à la branche actuelle.

Vous pouvez également cherry-picker une plage de commits en utilisant la syntaxe suivante :

$ git cherry-pick <start_commit>..<end_commit>

Cela appliquera tous les commits de la plage spécifiée à la branche actuelle.

Vérifier les commits cherry-pickés

Après avoir appliqué un commit cherry-pické, vous pouvez vérifier que le commit a été appliqué correctement en utilisant les commandes suivantes :

Vérifier le journal des commits (Commit Log): Vous pouvez utiliser la commande git log pour afficher l'historique des commits et vous assurer que le commit cherry-pické est présent.

$ git log --oneline

Inspecter la différence de commit (Commit Diff): Vous pouvez utiliser la commande git diff pour comparer les modifications introduites par le commit cherry-pické avec les modifications de la branche actuelle.

$ git diff <cherry-picked_commit>

Vérifier le hash du commit: Vous pouvez comparer le hash du commit cherry-pické avec le hash du commit dans la branche actuelle pour vous assurer que le bon commit a été appliqué.

$ git rev-parse HEAD

Vérifier le message de commit: Vous pouvez vérifier le message de commit du commit cherry-pické pour vous assurer qu'il correspond au message de commit original.

$ git show --oneline --name-only <cherry-picked_commit>

En suivant ces étapes, vous pouvez vous assurer que le commit cherry-pické a été appliqué correctement et que les modifications ont été intégrées dans la branche actuelle.

Résolution des conflits lors d'un cherry-pick

Comprendre les conflits de cherry-pick

Lorsque vous effectuez un cherry-pick d'un commit, il est possible que les modifications du commit entrent en conflit avec les modifications de la branche actuelle. Cela peut se produire lorsque les mêmes lignes de code ont été modifiées à la fois dans le commit original et dans la branche actuelle.

Lorsqu'un conflit se produit lors d'un cherry-pick, Git met en pause le processus et marque les zones conflictuelles dans les fichiers concernés. Vous devrez résoudre manuellement ces conflits avant de pouvoir terminer le cherry-pick.

Résolution des conflits

Pour résoudre les conflits lors d'un cherry-pick, suivez ces étapes :

Identifier les fichiers conflictuels : Après que le processus de cherry-pick ait été mis en pause, vous pouvez utiliser la commande git status pour voir quels fichiers présentent des conflits.

$ git status

Ouvrir les fichiers conflictuels : Ouvrez les fichiers conflictuels dans un éditeur de texte et recherchez les marqueurs de conflit. Ces marqueurs indiquent les zones où Git n'a pas été en mesure de fusionner automatiquement les modifications.

<<<<<<< HEAD
## Vos modifications
=======
## Modifications du commit cherry-pické
>>>>>>> e8e8c23 (Message de commit)

Résoudre les conflits : Modifiez manuellement les sections conflictuelles du fichier pour résoudre les conflits. Conservez les modifications que vous souhaitez conserver et supprimez les marqueurs de conflit.
Préparer (Stager) les conflits résolus : Après avoir résolu les conflits, utilisez la commande git add pour préparer les fichiers résolus.

$ git add <fichier_conflictuel>

Continuer le cherry-pick : Une fois que tous les conflits ont été résolus et préparés, vous pouvez continuer le processus de cherry-pick en utilisant la commande git cherry-pick --continue.

$ git cherry-pick --continue

Si vous souhaitez annuler le processus de cherry-pick à tout moment, vous pouvez utiliser la commande git cherry-pick --abort.

$ git cherry-pick --abort

En suivant ces étapes, vous pouvez résoudre avec succès tous les conflits qui surviennent lors d'une opération de cherry-pick et terminer le processus d'application du commit sélectionné à votre branche actuelle.

Résumé

Dans ce tutoriel sur Git, vous avez appris à utiliser la commande cherry-pick pour appliquer sélectivement des commits d'une branche à une autre. Vous avez également découvert des techniques pour vérifier que le commit a été appliqué avec succès et comment résoudre tout conflit qui pourrait survenir au cours du processus. En maîtrisant ces compétences Git, vous pouvez garantir l'intégrité de votre dépôt et maintenir une base de code propre et organisée.