Refactorer une Méthode pour Réduire la Complexité Cognitive

Objectif

Refactoriser la méthode ${input:methodName}, pour réduire sa complexité cognitive à ${input:complexityThreshold} ou moins, en extrayant la logique dans des méthodes auxiliaires ciblées.

Instructions

1. Analyser la méthode actuelle pour identifier les sources de complexité cognitive :

   • Instructions conditionnelles imbriquées
   • Chaînes multiples if-else ou switch
   • Blocs de code répétés
   • Boucles multiples avec conditions
   • Expressions booléennes complexes

2. Identifier les opportunités d'extraction :

   • Logique de validation pouvant être extraite dans une méthode séparée
   • Traitement spécifique aux types ou aux cas qui se répète
   • Transformations ou calculs complexes
   • Modèles courants qui apparaissent plusieurs fois

3. Extraire des méthodes auxiliaires ciblées :

   • Chaque auxiliaire doit avoir une responsabilité unique et claire
   • Extraire la validation dans des méthodes Valider* distinctes
   • Extraire la logique spécifique aux types dans des méthodes gestionnaires
   • Créer des méthodes utilitaires pour les opérations courantes
   • Utiliser les niveaux d'accès appropriés (static, private, async)

4. Simplifier la méthode principale :

   • Réduire la profondeur d'imbrication
   • Remplacer les chaînes if-else massives par des appels orchestrés plus petits
   • Utiliser les instructions switch le cas échéant pour une distribution plus claire
   • S'assurer que la méthode principale se lit comme un flux de haut niveau

5. Préserver la fonctionnalité :

   • Maintenir le même comportement d'entrée/sortie
   • Conserver toute validation et gestion des erreurs
   • Préserver les types d'exceptions et les messages d'erreur
   • S'assurer que tous les paramètres sont correctement passés aux auxiliaires

6. Bonnes pratiques :

   • Rendre les méthodes auxiliaires static quand elles n'ont pas besoin d'état d'instance
   • Utiliser les vérifications null et les clauses de garde au début
   • Éviter de créer des variables locales inutiles
   • Envisager d'utiliser des tuples pour les retours multiples
   • Grouper les méthodes auxiliaires connexes

Approche d'Implémentation

• Extraire les méthodes auxiliaires avant de refactoriser le flux principal
• Tester graduellement pour assurer qu'il n'y a pas de régressions
• Utiliser des noms significatifs qui décrivent la responsabilité extraite
• Garder les méthodes extraites à proximité de leur lieu d'utilisation
• Envisager de transformer les modèles de code répétés en méthodes génériques

Résultat

La méthode refactorisée doit :

• Avoir la complexité cognitive réduite au seuil cible de ${input:complexityThreshold} ou moins
• Être plus lisible et maintenable
• Avoir une séparation claire des préoccupations
• Être plus facile à tester et déboguer
• Conserver toute la fonctionnalité d'origine

Test et Validation

CRITIQUE : Après avoir complété la refactorisation, vous DEVEZ :

1. Exécuter tous les tests existants liés à la méthode refactorisée et à ses fonctionnalités environnantes
2. OBLIGATOIRE : Vérifier explicitement que les résultats des tests indiquent "failed=0"
   • NE PAS supposer que les tests ont réussi - toujours examiner la sortie réelle des tests
   • Rechercher la ligne de synthèse contenant les décomptes de réussite/échec (par ex. "passed=X failed=Y")
   • Si la synthèse indique un nombre autre que "failed=0", les tests ont ÉCHOUÉ
   • Si la sortie des tests est dans un fichier, lire l'intégralité du fichier pour localiser et vérifier le nombre d'échecs
   • Exécuter les tests n'est PAS la même chose que de vérifier que les tests ont réussi
   • Ne pas procéder jusqu'à avoir explicitement confirmé zéro échec
3. Si des tests échouent (failed > 0):
   • Indiquer clairement combien de tests ont échoué
   • Analyser chaque échec pour comprendre quelle fonctionnalité a été brisée
   • Causes courantes : gestion null, vérifications de collections vides, erreurs de logique conditionnelle
   • Identifier la cause racine dans le code refactorisé
   • Corriger le code refactorisé pour restaurer le comportement d'origine
   • Réexécuter les tests et vérifier "failed=0" dans la sortie
   • Répéter jusqu'à ce que tous les tests réussissent (failed=0)
4. Vérifier la compilation - S'assurer qu'il n'y a pas d'erreurs de compilation
5. Vérifier la complexité cognitive - Confirmer que la métrique est au seuil cible ou en dessous de ${input:complexityThreshold}

Liste de Vérification de Confirmation

• [ ] Le code se compile sans erreurs
• [ ] Les résultats des tests indiquent explicitement "failed=0" (vérifiés en lisant la sortie)
• [ ] Tous les échecs de test analysés et corrigés (le cas échéant)
• [ ] La complexité cognitive est au seuil cible ou en dessous de ${input:complexityThreshold}
• [ ] Toute la fonctionnalité d'origine est préservée
• [ ] Le code suit les conventions et normes du projet