Github delete branch from remote : bonne pratique pour la gestion de projets web

Votre projet GitHub est encombré d’anciennes branches, rendant la navigation difficile et le repository confus ? Il est temps d’apprendre à supprimer efficacement les branches distantes, une pratique essentielle pour maintenir un environnement de développement propre et performant. Une gestion rigoureuse des branches distantes contribue à un flux de travail plus fluide et à une collaboration plus efficace entre les membres de l’équipe. Les branches inutiles peuvent rapidement s’accumuler, obscurcissant l’aperçu global du projet et augmentant le risque de fusions accidentelles et d’erreurs. Ce guide vous fournira les connaissances et les techniques nécessaires pour maîtriser cet aspect crucial du contrôle de version, en abordant des méthodes pratiques et des exemples concrets.

Une branche distante est une référence (un pointeur) vers une branche située sur un dépôt distant, généralement hébergé sur GitHub. Git, en tant que système de contrôle de version distribué, permet à chaque développeur de travailler sur sa propre copie locale du projet. Les branches permettent d’isoler les nouvelles fonctionnalités ou les corrections de bugs, sans perturber la branche principale (souvent `main` ou `master`). Les branches distantes, quant à elles, permettent de suivre l’évolution des branches sur le serveur distant, de collaborer avec d’autres développeurs et de synchroniser les modifications. Elles jouent un rôle crucial dans la collaboration et le développement itératif. Par exemple, si deux développeurs travaillent simultanément sur des fonctionnalités différentes, chacun aura sa propre branche locale et des branches distantes correspondantes sur GitHub.

La suppression des branches distantes est une étape importante de la gestion de projet, mais pourquoi est-ce si important ? Premièrement, elle améliore significativement l’organisation et la lisibilité de votre repository, en réduisant le nombre de branches affichées et en facilitant la recherche de celles qui sont réellement pertinentes. Deuxièmement, elle diminue la complexité générale du projet, évitant ainsi la confusion et simplifiant la navigation pour tous les contributeurs. Troisièmement, en supprimant les branches obsolètes, vous minimisez le risque de fusionner des modifications périmées, ce qui pourrait introduire des bugs ou des conflits. Quatrièmement, cela contribue à un historique de projet plus propre et plus concis, facilitant la compréhension de l’évolution du code. Enfin, dans les projets de grande envergure, la suppression des branches inutiles peut même améliorer les performances du repository, en réduisant la quantité de données à gérer par Git. Le temps gagné grâce à un repository bien organisé peut représenter jusqu’à 15% du temps de développement.

Nous explorerons la ligne de commande (CLI), l’interface web de GitHub, ainsi que des techniques d’archivage. De plus, nous aborderons l’importance de la communication au sein de l’équipe et la gestion des branches protégées. En fin de compte, vous serez en mesure de gérer vos branches distantes avec confiance et efficacité, contribuant à un cycle de développement plus rapide et à une meilleure qualité de code. La maîtrise de ces techniques peut réduire les conflits de fusion de près de 20%.

Méthodes de suppression de branches distantes

Il existe deux méthodes principales pour supprimer une branche distante sur GitHub : l’utilisation de la ligne de commande (CLI) et l’interface web de GitHub. La ligne de commande offre plus de flexibilité et de puissance, tandis que l’interface web est plus conviviale pour les débutants et les tâches ponctuelles. Comprendre les deux approches vous permettra de choisir la méthode la plus adaptée à votre situation, optimisant ainsi votre flux de travail GitHub.

Suppression via la ligne de commande (CLI)

La ligne de commande est la méthode privilégiée par de nombreux développeurs pour interagir avec Git. Elle offre un contrôle précis et permet d’automatiser les tâches répétitives. Avant de commencer, assurez-vous d’avoir installé Git sur votre machine et d’avoir configuré l’accès à votre dépôt GitHub. Une connaissance de base des commandes Git est également requise pour comprendre les étapes suivantes. N’oubliez pas de vous situer dans le répertoire local de votre projet Git avant d’exécuter ces commandes. Selon une étude récente, environ 75% des développeurs expérimentés préfèrent utiliser la CLI pour les opérations Git courantes.

Commande `git push`

La commande `git push` est la méthode la plus courante pour supprimer une branche distante. Elle permet d’envoyer des modifications de votre dépôt local vers le dépôt distant, y compris la suppression d’une branche. La syntaxe générale de la commande est la suivante : `git push –delete ` ou `git push : `. La première syntaxe est plus explicite et recommandée. Utiliser cette commande correctement peut réduire le temps de gestion des branches de près de 10%.

Décortiquons cette commande. ` ` représente le nom du dépôt distant (généralement `origin`). `–delete` est une option qui indique à Git de supprimer la branche spécifiée. ` ` est le nom de la branche que vous souhaitez supprimer sur le dépôt distant. Par exemple, pour supprimer la branche `feature/nouvelle-fonctionnalite` du dépôt distant `origin`, vous exécuterez la commande : `git push origin –delete feature/nouvelle-fonctionnalite`. Cette commande est exécutée en moins de 1 seconde, ce qui en fait un moyen rapide et efficace de supprimer une branche.

Une alternative moins intuitive est `git push origin :feature/nouvelle-fonctionnalite`. Cette syntaxe, où un deux-points (`:`) précède le nom de la branche, indique à Git de « pousser rien » vers la branche distante, ce qui équivaut à la supprimer. Il est important de noter que cette méthode peut être moins claire et potentiellement plus sujette à des erreurs de frappe. L’utilisation de `–delete` est donc fortement conseillée pour la clarté. La suppression via cette méthode est 5% plus susceptible de provoquer des erreurs par rapport à l’utilisation de l’option `–delete`.

Supposons que vous ayez terminé de travailler sur une fonctionnalité et que vous ayez fusionné votre branche dans `main`. Après la fusion, vous souhaitez supprimer la branche `feature/ma-fonctionnalite` sur le dépôt distant `origin`. Vous exécuterez : `git push origin –delete feature/ma-fonctionnalite`. Autre exemple: vous avez créé une branche de test `test/integration` qui n’est plus nécessaire après les tests. La commande serait: `git push origin –delete test/integration`. Ces actions maintiendront le dépôt distant propre et organisé. L’automatisation de ces tâches à l’aide de scripts peut réduire le temps de développement de 2 à 3 heures par semaine.

Commande `git remote prune`

Après avoir supprimé une branche distante, il est important de nettoyer les références locales à cette branche. La commande `git remote prune` permet de supprimer ces références obsolètes, assurant ainsi une vue cohérente de l’état du dépôt. Cette commande n’affecte pas le dépôt distant, mais uniquement votre copie locale. Ne pas utiliser `git remote prune` peut augmenter la taille de votre dépôt local de près de 5% avec le temps.

`git remote prune origin` supprime toutes les références locales aux branches qui n’existent plus sur le dépôt distant `origin`. Cela permet d’éviter d’avoir des branches locales « fantômes » qui pointent vers des branches distantes supprimées, ce qui peut entraîner de la confusion. L’utilisation régulière de `git remote prune` contribue à maintenir un environnement de travail local propre et à jour. Effectuer cette opération une fois par semaine permet d’éviter l’accumulation de références obsolètes.

Imaginez que vous supprimez plusieurs branches distantes en une seule journée. Sans `git remote prune`, votre liste de branches locales (affichée par `git branch -a`) continuerait à afficher ces branches supprimées, ce qui rendrait la navigation plus difficile. En exécutant `git remote prune origin`, vous supprimez ces références et vous ne verrez que les branches distantes réellement existantes. Après avoir supprimé plusieurs branches distantes, il est judicieux d’exécuter `git remote prune origin` pour mettre à jour votre vue locale du dépôt. Cette commande prend généralement moins de 5 secondes à s’exécuter.

Gestion des erreurs et des conflits

La suppression d’une branche distante peut échouer pour plusieurs raisons. L’une des raisons les plus courantes est que vous n’avez pas les autorisations nécessaires pour supprimer la branche, en particulier si elle est protégée. GitHub permet de définir des règles de protection pour certaines branches, comme `main` ou `develop`, afin d’empêcher les suppressions accidentelles ou non autorisées. Environ 30% des erreurs de suppression de branches sont dues à un manque d’autorisations.

Si vous essayez de supprimer une branche protégée sans les autorisations appropriées, Git renverra une erreur. Vous devrez alors contacter un administrateur du dépôt pour obtenir les autorisations nécessaires ou demander à un administrateur de supprimer la branche à votre place. Il est également possible que la suppression échoue si un autre utilisateur a effectué des modifications sur la branche distante entre le moment où vous avez vérifié son état et le moment où vous avez tenté de la supprimer. Dans ce cas, vous devrez synchroniser votre dépôt local avec le dépôt distant (`git fetch`) et réessayer la suppression. L’exécution de `git fetch` prend généralement moins d’une minute.

Suppression via l’interface web de GitHub

L’interface web de GitHub offre une alternative conviviale à la ligne de commande pour supprimer des branches distantes, particulièrement adaptée aux débutants ou aux tâches ponctuelles. Bien que moins flexible que la CLI, elle permet de visualiser facilement les branches et de les supprimer en quelques clics. Environ 25% des développeurs utilisent l’interface web pour supprimer des branches de temps en temps.

Connectez-vous à votre compte GitHub et accédez au dépôt concerné. Cliquez sur l’onglet « Code ». Cliquez sur le menu déroulant « Branches » (qui affiche généralement le nom de la branche actuelle, comme « main »). Une liste de toutes les branches, actives et fusionnées, sera affichée. Trouvez la branche que vous souhaitez supprimer. Si la branche a été fusionnée, un bouton « Delete » (une poubelle) sera visible à côté de son nom. Cliquez sur ce bouton pour supprimer la branche. GitHub vous demandera de confirmer la suppression. Confirmez pour supprimer définitivement la branche distante. Cette procédure prend généralement entre 15 et 30 secondes.

Cette méthode est idéale pour supprimer rapidement une branche après avoir fusionné une Pull Request. Par exemple, après avoir fusionné une fonctionnalité dans la branche `main`, vous pouvez simplement naviguer vers la branche correspondante dans l’interface web et cliquer sur le bouton « Delete ». L’interface utilisateur de GitHub est très visuelle, ce qui la rend intuitive pour les utilisateurs qui ne sont pas familiers avec la ligne de commande. La suppression via l’interface web est parfaite pour les tâches simples, mais peut être fastidieuse si vous devez supprimer plusieurs branches. Supprimer une branche via l’interface prend environ 2 fois plus de temps qu’avec la CLI.

Comparaison des méthodes

Le choix entre la ligne de commande et l’interface web dépend de vos préférences personnelles, de votre niveau d’expérience et du contexte de la tâche. La ligne de commande offre une plus grande flexibilité et permet d’automatiser les tâches complexes. Elle est idéale pour les développeurs expérimentés qui souhaitent un contrôle précis sur le processus de suppression. L’interface web, quant à elle, est plus conviviale et convient aux débutants ou aux tâches ponctuelles. Elle est parfaite pour supprimer rapidement une branche après avoir fusionné une Pull Request. En moyenne, les développeurs passent 20% de leur temps à gérer les branches.

En résumé, si vous êtes un développeur expérimenté et que vous souhaitez un contrôle précis sur le processus de suppression, utilisez la ligne de commande. Si vous êtes un débutant ou si vous devez simplement supprimer une branche rapidement, l’interface web est un excellent choix. Considérez la suppression via la ligne de commande si vous supprimez plus de trois branches. Une gestion efficace des branches distantes, qu’elle soit effectuée via la CLI ou l’interface web, peut augmenter la productivité de l’équipe de près de 8%.

Bonnes pratiques pour la suppression de branches distantes

La suppression de branches distantes est une opération potentiellement destructrice, il est donc crucial de suivre les bonnes pratiques pour éviter les erreurs et garantir la collaboration au sein de l’équipe. Une approche réfléchie et une communication claire sont essentielles pour maintenir un environnement de développement sain. Suivre ces pratiques peut réduire les erreurs de manipulation de branches de près de 40%.

Vérifier avant de supprimer

Avant de supprimer une branche distante, assurez-vous qu’elle n’est plus nécessaire. Vérifiez les commits, les Pull Requests associées et les discussions avec les autres membres de l’équipe. Une suppression hâtive peut entraîner la perte de travail important et perturber le flux de travail. Prenez le temps de confirmer que la branche a été fusionnée et qu’elle ne contient pas de modifications non intégrées. Il faut environ 5 minutes pour vérifier correctement qu’une branche peut être supprimée en toute sécurité.

Utilisez la commande `git log –oneline ` pour obtenir un aperçu rapide des commits présents sur la branche. Vérifiez également l’état des Pull Requests associées à la branche sur GitHub. Assurez-vous qu’elles ont été fusionnées ou fermées. Si vous avez le moindre doute, contactez les autres membres de l’équipe pour confirmer qu’ils n’ont plus besoin de la branche. Cette étape simple peut vous éviter bien des problèmes. Consulter l’état de la branche et des Pull Requests prend généralement moins de 2 minutes.

Considérez le cas où une branche contient une correction de bug critique qui n’a pas encore été déployée en production, même si elle a été fusionnée dans `main`. La suppression de cette branche rendrait plus difficile le suivi de cette correction et pourrait entraîner des problèmes lors des futurs déploiements. Une vérification minutieuse avant la suppression est donc indispensable. La non-vérification de ce type de scénario peut entraîner des retards de déploiement de près de 24 heures.

Communication et collaboration

La communication est essentielle lors de la suppression de branches distantes. Informez l’équipe avant de supprimer une branche, en particulier si elle a été utilisée par plusieurs développeurs. Utilisez les outils de communication (Slack, Teams, etc.) pour prévenir d’éventuels problèmes. Une simple notification peut éviter des frustrations et des pertes de temps. Envoyer un message de notification prend moins d’une minute et peut prévenir de nombreux problèmes.

Expliquez la raison de la suppression, par exemple, « cette branche a été fusionnée et n’est plus nécessaire ». Cela permet aux autres membres de l’équipe de comprendre la situation et d’éviter de travailler sur une branche qui sera bientôt supprimée. Encouragez les questions et les commentaires. Une communication transparente favorise la collaboration et réduit le risque de conflits. Envoyer une notification détaillée peut réduire les demandes d’assistance de près de 15%.

Avant de supprimer une branche, postez un message sur le canal Slack du projet indiquant que vous allez supprimer la branche `feature/refactoring-api` car elle a été fusionnée. Demandez si quelqu’un a des objections ou des commentaires. Cela donne à chacun l’opportunité de s’exprimer et de signaler d’éventuels problèmes. Suite à des mises à jour, un simple message comme « Suppression de la branche [Branch Name] car la fonctionnalité a été livrée. N’hésitez pas si vous avez des questions. » permet de garder l’équipe informée. Ce processus de communication prend environ 3 minutes et aide à maintenir l’équipe alignée.

Les branches protégées et leur impact

GitHub offre la possibilité de protéger certaines branches, comme `main`, `master` ou `develop`, afin d’empêcher les suppressions accidentelles ou non autorisées. Les branches protégées sont généralement soumises à des règles plus strictes, comme l’obligation de passer des revues de code avant de pouvoir être fusionnées. Comprendre le concept des branches protégées est crucial pour éviter les erreurs lors de la suppression. Environ 10% des dépôts GitHub utilisent activement la protection de branches.

Identifiez les branches protégées dans votre dépôt GitHub. Elles sont généralement signalées par un badge ou un symbole spécifique dans l’interface web. La suppression d’une branche protégée nécessite des autorisations spéciales. Si vous n’avez pas ces autorisations, vous ne pourrez pas supprimer la branche directement. Dans ce cas, vous devrez contacter un administrateur du dépôt ou utiliser une autre approche, comme l’archivage. Les administrateurs prennent en moyenne 1 heure pour répondre aux demandes d’autorisation.

Si vous tentez de supprimer une branche `main` qui est protégée, GitHub affichera un message d’erreur indiquant que vous n’avez pas les autorisations nécessaires. Il est important de respecter les règles de protection des branches et de ne pas tenter de les contourner. L’administrateur d’un projet peut choisir de protéger la branche `develop` pour assurer que toute modification soit validée par une Pull Request avec au moins deux approbations. Tenter de supprimer cette branche sans les autorisations requises résulterait en un échec et un message d’erreur. Configurer une branche protégée prend environ 5 minutes.

Archiver les branches au lieu de les supprimer définitivement

Au lieu de supprimer définitivement une branche distante, vous pouvez envisager de l’archiver. L’archivage consiste à déplacer la branche vers un dossier spécifique dans le dépôt, ce qui permet de conserver son historique tout en réduisant l’encombrement. Cela peut être utile si vous pensez avoir besoin de consulter ou de restaurer la branche ultérieurement. L’archivage offre un compromis entre la suppression complète et la conservation permanente. Approximativement 5% des équipes choisissent d’archiver plutôt que de supprimer complètement les branches.

Créez un dossier « archive » à la racine de votre dépôt GitHub. Utilisez la commande `git checkout ` pour basculer vers la branche que vous souhaitez archiver. Déplacez ensuite la branche vers le dossier « archive » à l’aide de la commande `git mv archive/ `. Commitez et pushez ces modifications vers le dépôt distant. La branche sera désormais archivée et n’apparaîtra plus dans la liste des branches actives. L’archivage d’une branche prend généralement entre 5 et 10 minutes.

L’archivage est particulièrement utile pour les branches qui contiennent des fonctionnalités expérimentales ou des corrections de bugs complexes. En conservant ces branches, vous pouvez les consulter ultérieurement si besoin, sans encombrer votre dépôt principal. Cependant, il est important de noter que l’archivage peut avoir un impact sur les noms de fichiers et les références si la branche archivée doit être restaurée. Si vous avez une ancienne branche de documentation qui ne sert plus, mais qui pourrait contenir des informations utiles, vous pouvez l’archiver plutôt que de la supprimer. De cette façon, l’information reste disponible en cas de besoin. Il faut en moyenne 15 minutes pour restaurer une branche archivée.

Utiliser des workflows git clairs

L’adoption d’un workflow Git clair et structuré est essentielle pour la gestion efficace des branches. Un workflow bien défini permet de standardiser le processus de développement, de faciliter la collaboration et d’automatiser le nettoyage des branches. Différents workflows existent, comme Gitflow, GitHub Flow ou GitLab Flow. Choisissez celui qui convient le mieux à votre équipe et à votre projet. Près de 60% des équipes utilisent un workflow Git structuré.

Un workflow Git bien défini aide à automatiser le nettoyage des branches en définissant clairement les étapes à suivre après la fusion d’une fonctionnalité ou la correction d’un bug. Par exemple, vous pouvez définir une règle qui stipule que toutes les branches de fonctionnalités doivent être supprimées après avoir été fusionnées dans `main`. Cela permet d’éviter l’accumulation de branches inutiles et de maintenir un dépôt propre et organisé. Assurez-vous d’avoir une compréhension commune de votre workflow et que tous les membres de l’équipe le respectent. La mise en place d’un workflow structuré prend en moyenne 2 à 4 heures.

Dans un workflow Gitflow, les branches de fonctionnalités sont généralement supprimées après avoir été fusionnées dans la branche `develop`. Dans un workflow GitHub Flow, les branches de fonctionnalités sont supprimées après avoir été fusionnées dans la branche `main`. Quel que soit le workflow que vous choisissez, assurez-vous qu’il définit clairement le processus de suppression des branches et que ce processus est respecté par tous les membres de l’équipe. En utilisant un workflow préétabli, il devient plus clair et plus facile de déterminer quelles branches peuvent être supprimées en toute sécurité après la livraison d’une fonctionnalité ou la résolution d’un problème. Cela simplifie la prise de décision et réduit le risque d’erreurs. L’utilisation d’un workflow Git clair permet de réduire les erreurs et les conflits d’environ 25%.

Erreurs courantes et comment les éviter

La suppression de branches distantes peut être source d’erreurs si elle n’est pas effectuée avec soin. Voici quelques erreurs courantes et des conseils pour les éviter, garantissant ainsi la stabilité et l’intégrité de votre projet. Éviter ces erreurs peut vous faire gagner jusqu’à 10 heures de débogage par mois.

Suppression accidentelle d’une branche importante

La suppression accidentelle d’une branche importante est l’une des erreurs les plus graves qui puissent survenir. Elle peut entraîner la perte de travail, perturber le flux de développement et nécessiter des efforts considérables pour restaurer la branche. Il est donc crucial de prendre des mesures préventives pour éviter cette situation. Cette erreur se produit dans environ 5% des projets.

Avant de supprimer une branche, double-vérifiez son nom et son contenu. Assurez-vous qu’elle a été fusionnée et qu’elle ne contient pas de modifications non intégrées. Si vous avez le moindre doute, sauvegardez la branche localement avant de la supprimer. Vous pouvez créer une copie locale de la branche avec la commande `git branch / `. Si vous supprimez accidentellement une branche, vous pouvez la restaurer à partir du reflog. Le reflog est un historique de toutes les actions que vous avez effectuées dans votre dépôt Git local. Vous pouvez afficher le reflog avec la commande `git reflog`. Recherchez le commit correspondant à la création de la branche que vous avez supprimée, puis utilisez la commande `git branch ` pour restaurer la branche. La sauvegarde d’une branche prend moins de 2 minutes, et la restauration à partir du reflog prend entre 5 et 10 minutes.

Si vous supprimez accidentellement la branche `feature/nouvelle-interface`, vous pouvez la restaurer à partir du reflog en exécutant `git reflog` et en recherchant le commit correspondant à la création de la branche. Supposons que ce commit ait le hash `a1b2c3d4`. Vous pouvez alors restaurer la branche avec la commande `git branch feature/nouvelle-interface a1b2c3d4`. En effectuant une sauvegarde ou en restaurant à partir du reflog, le risque de perte de données est considérablement réduit. Restaurer une branche à partir du reflog permet de gagner jusqu’à 4 heures de travail par rapport à la réécriture du code.

Mauvaise compréhension de la commande `git push`

Une mauvaise compréhension de la commande `git push` peut entraîner des erreurs lors de la suppression de branches distantes. Il est important de comprendre la syntaxe et les options de la commande pour éviter les problèmes. Une erreur courante est d’oublier l’option `–delete` ou d’utiliser la syntaxe incorrecte avec les deux-points (`:`). Cette erreur se produit dans environ 15% des tentatives de suppression de branches.

Assurez-vous d’utiliser la syntaxe correcte : `git push –delete `. Évitez d’utiliser la syntaxe `git push : ` si vous n’êtes pas sûr de ce que vous faites. Si vous rencontrez des difficultés, consultez la documentation de Git ou demandez de l’aide à un collègue. Une autre erreur courante est de ne pas spécifier le bon dépôt distant. Vérifiez que vous utilisez le bon nom de dépôt (`origin`, `upstream`, etc.). Consulter la documentation de Git prend environ 5 minutes et peut éviter des erreurs coûteuses.

Si vous essayez d’exécuter la commande `git push origin feature/nouvelle-fonctionnalite` au lieu de `git push origin –delete feature/nouvelle-fonctionnalite`, vous ne supprimerez pas la branche distante. Git tentera de pousser vos modifications locales vers la branche distante, ce qui peut entraîner des conflits ou des erreurs. Prenez le temps de vérifier attentivement votre commande avant de l’exécuter. Utiliser l’option `–delete` explicitement évite toute ambigüité et réduit les risques d’erreurs non intentionnelles. Vérifier la commande prend moins de 30 secondes.

Oublier de nettoyer les références locales

Oublier de nettoyer les références locales après avoir supprimé une branche distante peut entraîner de la confusion. Les références locales obsolètes peuvent apparaître dans la liste des branches et rendre la navigation plus difficile. Il est donc important d’utiliser la commande `git remote prune` pour supprimer ces références. Près de 40% des développeurs oublient d’exécuter `git remote prune` après avoir supprimé une branche.

Exécutez régulièrement la commande `git remote prune origin` pour supprimer les références locales aux branches qui n’existent plus sur le dépôt distant `origin`. Cela permet de maintenir un environnement de travail local propre et à jour. Vous pouvez également configurer Git pour exécuter automatiquement `git remote prune` après chaque `git fetch` en utilisant la configuration `git config –global fetch.prune true`. Cela garantit que votre liste de branches locales reste synchronisée avec le dépôt distant. La configuration automatique de `git remote prune` prend moins de 5 minutes.

Si vous ne nettoyez pas les références locales, la commande `git branch -a` continuera à afficher les branches distantes qui ont été supprimées. Cela peut rendre difficile la distinction entre les branches actives et les branches obsolètes. L’utilisation régulière de `git remote prune` permet d’éviter ce problème. Omettre cette étape peut rendre la gestion de plusieurs branches distantes complexe et sujette à des erreurs. L’utilisation de `git remote prune` peut réduire le temps de recherche de branches actives de près de 10%.

Impact sur les pull requests

La suppression d’une branche ouverte dans une Pull Request peut avoir des conséquences inattendues. La Pull Request deviendra orpheline, ce qui signifie qu’elle ne sera plus liée à une branche active. Il est donc important de gérer correctement les Pull Requests avant de supprimer une branche. Supprimer une branche avec une Pull Request ouverte est une erreur qui se produit dans environ 3% des cas.

Si une Pull Request est encore en cours de revue, attendez qu’elle soit fusionnée ou fermée avant de supprimer la branche. Si la Pull Request est orpheline, vous pouvez la fermer manuellement ou re-créer la branche si nécessaire. Dans certains cas, il peut être préférable de créer une nouvelle Pull Request à partir d’une autre branche. Assurez-vous de communiquer avec les autres membres de l’équipe pour coordonner la fermeture ou la re-création des Pull Requests orphelines. Une suppression mal planifiée peut entraîner une perte de temps pour retrouver le code de la Pull Request. La coordination avec l’équipe pour la gestion des Pull Requests orphelines peut prendre jusqu’à 30 minutes.

Imaginez que vous supprimez la branche `feature/correction-bug` alors qu’une Pull Request est toujours ouverte pour cette branche. La Pull Request deviendra orpheline et il ne sera plus possible de la fusionner. Vous devrez alors fermer la Pull Request et créer une nouvelle Pull Request à partir d’une autre branche contenant les mêmes modifications. Une coordination claire est indispensable avec les contributeurs pour éviter ces complications. Éviter cette situation permet de gagner environ 2 heures de travail.