Git Cherry-Pick : Comment sélectionner et appliquer des modifications spécifiques

Syntaxe de Git Cherry-Pick

La compréhension de la syntaxe de git cherry-pick est essentielle pour une utilisation efficace de cette commande. Il ne s'agit pas seulement de sélectionner des engagements, mais de les appliquer avec précision pour obtenir le résultat souhaité.

La syntaxe de base pour sélectionner un seul commit est la suivante :

git cherry-pick <commit-hash>

• git cherry-pick: La commande qui initie l'opération.
• : L'identifiant unique (hachage SHA-1) du commit que vous souhaitez sélectionner. Ce hachage peut être trouvé en lançant git log pour lister l'historique des livraisons.

Lorsque vous exécutez la commande ci-dessus, Git applique les modifications du commit spécifié à la branche courante, créant un nouveau commit avec les mêmes modifications mais un hash différent. 

Il est important de noter que la commande ne transfère que le commit lui-même, et non le contexte ou l'historique parent de la branche d'origine.

Nouveau pour Git et GitHub ? Commencez à utiliser le contrôle de version grâce à ce tutoriel GitHub et Gitginner-friendly.

Comment utiliser Git Cherry-Pick : Exemples pas à pas

Maintenant que vous avez compris la syntaxe de base de git cherry-pick, il est temps de voir la commande en action.

Cette section fournit des exemples pratiques qui vous guident à travers des scénarios de base courants et des scénarios plus complexes dans lesquels le cherry-picking est utile. Chaque exemple illustre comment appliquer les modifications d'un ou de plusieurs commentaires à une autre branche. 

Exemple 1 : La sélection d'un seul commit

Supposons que vous ayez effectué une correction sur une branche de fonctionnalités que vous souhaitez appliquer à la branche principale sans fusionner l'ensemble de la branche de fonctionnalités.

• Tout d'abord, trouvez le hash du commit que vous voulez sélectionner en exécutant :

git log

• Localisez le hachage de la livraison. 
• Passez à la branche principale :

git checkout main

• Exécutez la commande cherry-pick (en supposant que le hachage est abc1234) :

git cherry-pick abc1234

Lorsque vous exécutez cette commande, Git applique les modifications du commit identifié par abc1234 à votre branche courante (qui est main dans ce cas). Git crée un nouveau commit sur la branche principale qui contient les mêmes modifications que le commit original mais avec un nouveau hash de commit.

Exemple 2 : Sélection de plusieurs commits

Dans certaines situations, vous pouvez avoir besoin d'appliquer plusieurs commits distincts d'une branche à une autre. Supposons que vous ayez trois commits distincts dans votre branche de fonctionnalités que vous devez intégrer à la branche principale.

• Trouvez les hashs de commit pour chaque commit que vous voulez sélectionner en utilisant git log:

git log

• Passez à la branche principale :

git checkout main

• Exécutez la commande cherry-pick, en listant les commits :

git cherry-pick abc1234 def5678 ghi7890

Exemple 3 : Sélection d'une gamme d'engagements

Supposons que vous ayez effectué une série de commits sur la branche des fonctionnalités et que vous souhaitiez les appliquer à la branche principale en une seule fois, sans spécifier chaque commit individuellement. Comment feriez-vous ?

• Utilisez git log pour identifier les commits de début et de fin que vous souhaitez sélectionner (par exemple, abc1234 à ghi7890).
• Passez à la branche principale :

git checkout main

• Exécutez la commande cherry-pick avec une plage de livraisons :

git cherry-pick abc1234...ghi7890

Exemple 4 : Prélever un commit sur une branche distante

Parfois, une correction critique existe dans une branche distante, et vous souhaitez l'appliquer à votre branche locale sans fusionner la branche entière. Voici comment procéder :

• Récupérer les dernières modifications du référentiel distant

git fetch origin

• Listez les commits de la branche distante pour trouver le hash dont vous avez besoin :

git log origin/feature_branch --oneline

• Supposons que le hash du commit dont vous avez besoin est abc1234.
• Passez à l'agence principale de votre région :

git checkout main

• Prélever le commit de la branche distante :

git cherry-pick abc1234

Cela vous permet d'appliquer un commit d'une branche distante sans fusionner la branche entière.

Vous avez besoin de vérifier une succursale éloignée ? Suivez ce guide pas à pasp sur le checkout Git pour les branches distantes.

Exemple 5 : Choisir un commit et le modifier

Si vous choisissez un commit mais que vous avez besoin d'y apporter de légères modifications avant de le valider, vous pouvez utiliser le mode interactif de Git. Voici comment :

• Passez à la branche cible :

git checkout main

• Choisissez un engagement, mais arrêtez-vous avant de l'engager :

git cherry-pick -n abc1234

Le drapeau -n (ou --no-commit) applique les modifications mais ne crée pas de validation.

• Modifiez les fichiers si nécessaire.
• Stage et valider les modifications manuellement :

git add .
git commit -m "Modified cherry-picked commit from feature_branch"

Ceci est utile lorsque vous avez besoin d'ajuster un commit sélectionné avant de le finaliser.

Gérer les conflits lors du Git Cherry-Pick

Les conflits sont inévitables lorsque l'on sélectionne les commits entre les branches, en particulier lorsque la base de code a divergé de manière significative. 

Bien que cherry-pick soit conçu pour appliquer les changements proprement, il ne peut pas toujours réconcilier les différences automatiquement. Dans ce cas, les conflits doivent être résolus manuellement. Pour mener à bien une opération cherry-pick, il est essentiel de comprendre comment les conflits surviennent et comment les gérer.

Comment les conflits surviennent-ils ?

Les conflits surviennent généralement lorsque les modifications du commit cherry-picked chevauchent ou contredisent des modifications déjà présentes dans la branche cible. Par exemple :

• La même ligne a été modifiée dans les deux branches : Si la même ligne de code est modifiée dans les branches source et cible, Git ne saura pas quelle version appliquer.
• Fichier supprimé dans une branche mais modifié dans une autre : Si un fichier est supprimé dans une branche mais modifié dans le commit cherry-picked, Git ne saura pas s'il faut le conserver ou appliquer les modifications.
• Changements sans rapport, mais même dossier : Même si les modifications ne semblent pas liées, si elles se produisent dans le même fichier, Git peut les signaler comme un conflit potentiel.

Lorsqu'un conflit survient, Git interrompt l'opération cherry-pick, laissant votre répertoire de travail dans un état conflictuel qui doit être résolu avant de continuer.

Résolution des conflits

Lorsqu'un conflit survient, Git fournit des indicateurs sur les fichiers en conflit, et vous devez résoudre manuellement les divergences. Voici comment résoudre les conflits :

1. Vérifiez les fichiers en conflit : Exécutez la commande suivante pour voir quels fichiers sont en conflit :

git status

La commande affichera la liste des fichiers en conflit. 

2. Résolvez les conflits : Vous pouvez modifier manuellement les fichiers en conflit pour résoudre les problèmes. Retirez les marqueurs de conflit (<<<<<<<, =======, >>>>>>>) et déterminez les changements à conserver ou la manière de les combiner.

3. Utilisez l'outil Git Mergetool (facultatif) : Si la résolution manuelle des conflits est fastidieuse, vous pouvez utiliser un outil de fusion pour vous aider à visualiser et à résoudre les conflits :

git mergetool

Selon votre configuration, l'outil ci-dessus ouvrira un outil de fusion visuelle, qui facilite l'examen et la résolution des conflits.

4. Marquez les conflits comme résolus : Après avoir résolu les conflits, marquez les fichiers comme résolus en utilisant :

git add <conflicted-file>

5. Complétez la cueillette des cerises : Une fois que tous les conflits sont résolus et que les fichiers sont mis en scène, finalisez le cherry-pick en exécutant :

git cherry-pick --continue

De nombreux IDE et outils modernes, tels que Visual Studio Code et GitHub, proposent des fonctions intégrées de résolution des conflits de fusion. L'interface web de GitHub vous permet de résoudre les conflits directement dans les demandes d'extraction, ce qui facilite la collaboration sur les dépôts partagés sans passer par un environnement local.

Sauter un commit après un conflit

Parfois, la résolution d'un conflit peut s'avérer trop complexe, ou vous pouvez vous rendre compte que l'engagement n'est finalement pas nécessaire. Dans ce cas, vous pouvez sauter l'étape de la validation.

1. Abandonnez le processus de cueillette en cours : Si le conflit est trop compliqué et que vous ne souhaitez pas appliquer le commit, vous pouvez l'ignorer en exécutant la commande suivante

git cherry-pick --skip

Ceci abandonnera le commit conflictuel et passera au suivant (si vous sélectionnez plusieurs commits).

2. Abandonnez l'ensemble de la cueillette des cerises : Si vous souhaitez interrompre l'opération cherry-pick, vous pouvez exécuter la commande :

git cherry-pick --abort

Cette commande restaurera votre répertoire de travail dans l'état où il se trouvait avant que vous ne lanciez le cherry-pick. 

Vous souhaitez nettoyer l'historique de vos livraisons ? Apprenez à combiner plusieurs commits en un seul avec ce tutoriel Git squash.

Meilleures pratiques pour l'utilisation de Git Cherry-Pick

Une mauvaise utilisation de cherry-pick peut entraîner des historiques compliqués et une certaine confusion dans le contrôle des versions de votre projet. Pour éviter ces écueils, le respect des meilleures pratiques vous permet d'utiliser cherry-pick de manière efficace sans introduire de complexité inutile dans votre base de code.

Restez modeste et précis

Le "cherry-picking" est plus efficace lorsqu'il est utilisé pour de petites livraisons spécifiques qui concernent des tâches bien définies, telles que des corrections de bogues ou des améliorations mineures de fonctionnalités. 

Évitez de sélectionner des commits importants et complexes qui regroupent plusieurs modifications, car ils peuvent introduire des conflits et compliquer la gestion de la base de code. Plus l'engagement est ciblé, plus il est facile de l'appliquer sans effets secondaires indésirables.

Documentez vos choix

Pour que l'histoire soit claire, il faut toujours fournir un contexte approprié lorsque l'on fait du "cherry picking". Cela peut se faire par le biais de messages de livraison détaillés ou d'annotations dans la documentation. 

L'essentiel est que vous expliquiez pourquoi il était nécessaire de procéder à une sélection. Ceci est particulièrement important lorsque l'on fait du "cherry picking" dans des branches de longue durée ou des environnements collaboratifs, car cela permet aux futurs contributeurs de comprendre pourquoi les changements ont été appliqués de manière sélective.

Consulter l'historique des livraisons

Avant de procéder à un "cherry-picking", examinez l'historique des livraisons de la branche source et de la branche cible. Cette étape permet d'identifier si le commit que vous êtes sur le point de sélectionner dépend d'autres changements. Les dépendances manquantes peuvent entraîner des fonctionnalités incomplètes ou des bogues. Veillez donc à ce que le "cherry-pick" n'introduise pas de fonctionnalités ou de mises à jour à moitié abouties.

Évitez le recours excessif à la cueillette de cerises

Si le cherry-picking est pratique pour appliquer des changements spécifiques, son utilisation excessive peut conduire à un historique fragmenté avec des commits dupliqués dans les différentes branches. Il peut donc être difficile de retracer l'origine de certains changements ou de comprendre le contexte plus large du développement. 

Évaluez toujours si la fusion ou le rebasage est une stratégie plus appropriée avant de procéder à un "cherry picking". Utilisez cherry-pick avec parcimonie et de manière ciblée pour éviter d'encombrer l'historique des livraisons.

Vous avez du mal à gérer les fichiers inutiles dans Git ? Apprenez à utiliser efficacement .gitignore avec ce tutoriel sur l'ignorance de Git.

Résolution des problèmes courants avec Git Cherry-Pick

La résolution des problèmes qui surviennent lors de l'utilisation de cherry-pick nécessite une bonne compréhension des mécanismes sous-jacents de Git. Dans cette section, j'aborderai certains problèmes courants que vous pouvez rencontrer lors de la sélection des produits et la manière de les résoudre.

Choisir un commit qui n'existe pas

Parfois, vous pouvez essayer de sélectionner un commit qui n'est pas accessible à partir de la branche actuelle ou qui a déjà été fusionné. Cela se traduit généralement par un message d'erreur indiquant que le commit n'a pas pu être trouvé ou appliqué.

1. L'engagement n'a pas été trouvé : Cela se produit lorsque le hash de commit que vous essayez de sélectionner n'existe pas dans votre dépôt actuel ou dans le contexte de la branche. Assurez-vous que vous faites référence au bon commit en vérifiant l'historique des commits avec git log sur la branche où le commit existe. Solution :

• Vérifiez à nouveau le hachage du commit pour vous assurer qu'il est correct.
• Vérifiez que le commit existe sur une branche à laquelle vous avez accès.
• Si le commit est dans une branche distante, assurez-vous que la branche a été récupérée avec git fetch.

2. Engagement déjà appliqué : Si le commit a déjà été fusionné ou intégré dans la branche cible, Git vous empêchera de le dupliquer. Cette mesure de protection permet de conserver un historique propre et d'éviter les modifications redondantes. Solution :

• Utilisez git log pour vérifier si le commit est déjà dans la branche cible.
• Si nécessaire, sautez l'opération cherry-pick puisque les modifications ont déjà été appliquées.

Cherry-picking après un rebasement ou une fusion

La sélection après un rebasement ou une fusion peut introduire des complexités dues à l'altération de l'historique de vos branches. Le rebasage réécrit l'historique des livraisons, tandis que la fusion combine les branches, ce qui peut avoir un impact sur l'applicabilité d'un "cherry-pick".

1. Conflits dus à des changements de base : Après un rebasement, l'historique des livraisons est réécrit, ce qui peut poser des problèmes si vous essayez de sélectionner des livraisons qui ont été modifiées au cours du processus de rebasement. Vous pouvez rencontrer des conflits lorsque le site cherry-pick tente d'appliquer des changements qui ne correspondent pas à l'historique réécrit. Solution :

• Examinez soigneusement l'historique des livraisons après un rebasement en utilisant git log pour vous assurer que la livraison que vous choisissez n'a pas déjà été modifiée.
• Résolvez les conflits comme vous le feriez dans le cadre d'un processus standard cherry-pick, en utilisant git status et des modifications manuelles.

2. Dupliquer les commits après une fusion : La fusion de branches peut conduire à une situation où un commit que vous souhaitez sélectionner a déjà été inclus dans l'historique fusionné. Un nouveau cursus peut entraîner une duplication des livraisons, ce qui peut encombrer votre historique et rendre difficile le suivi des modifications. Solution :

• Avant d'effectuer un "cherry-picking", inspectez l'historique des livraisons sur les deux branches afin de confirmer si la livraison a déjà été fusionnée.
• Évitez de choisir le même commit s'il se trouve déjà dans la branche cible.

Vous souhaitez annuler des modifications dans Git ? Apprenez quand utiliser git reset ou git revert dans le tutorielis Git reset and revert.

Conclusion

git cherry-pick est un moyen puissant d'appliquer des commits spécifiques d'une branche à une autre sans fusionner la branche entière. Que vous déplaciez une correction de bogue, une mise à jour de fonctionnalité ou que vous appliquiez simplement des changements de manière sélective, cela vous permet de conserver un historique Git propre et ciblé.

Dans ce guide, j'ai expliqué comment sélectionner des commits uniques ou multiples, résoudre les conflits et suivre les meilleures pratiques pour éviter les pièges les plus courants. En utilisant cherry-pick à bon escient, vous pouvez améliorer votre flux de travail tout en gardant votre référentiel organisé.

Si vous souhaitez approfondir vos compétences en matière de Git, vous pouvez consulter Foundations of Git, qui constitue un bon point de départ. Vous pouvez également explorer Introduction aux concepts de GitHub ou adopter une approche structurée avec le cursus de compétences Fondations GitHub.

Maintenant que vous savez comment cueillir des cerises comme un pro, essayez-le dans votre prochain projet !