306 lines
12 KiB
Markdown
306 lines
12 KiB
Markdown
## Refactor
|
||
|
||
Implémente une refactorisation de code sûre et progressive, évalue quantitativement le respect des principes SOLID. Visualise la dette technique et clarifie les priorités d'amélioration.
|
||
|
||
### Utilisation
|
||
|
||
```bash
|
||
# Identification de code complexe et plan de refactorisation
|
||
find . -name "*.js" -exec wc -l {} + | sort -rn | head -10
|
||
"Refactorisez ces gros fichiers pour réduire la complexité"
|
||
|
||
# Détection et intégration de code dupliqué
|
||
grep -r "function processUser" . --include="*.js"
|
||
"Unifiez ces fonctions dupliquées avec Extract Method"
|
||
|
||
# Détection des violations des principes SOLID
|
||
grep -r "class.*Service" . --include="*.js" | head -10
|
||
"Évaluez si ces classes suivent le principe de responsabilité unique"
|
||
```
|
||
|
||
### Exemples de base
|
||
|
||
```bash
|
||
# Détection de méthodes longues
|
||
grep -A 50 "function" src/*.js | grep -B 50 -A 50 "return" | wc -l
|
||
"Divisez les méthodes de plus de 50 lignes avec Extract Method"
|
||
|
||
# Complexité des branchements conditionnels
|
||
grep -r "if.*if.*if" . --include="*.js"
|
||
"Améliorez ces déclarations conditionnelles imbriquées avec le pattern Strategy"
|
||
|
||
# Détection des code smells
|
||
grep -r "TODO\|FIXME\|HACK" . --exclude-dir=node_modules
|
||
"Résolvez les commentaires qui sont devenus de la dette technique"
|
||
```
|
||
|
||
### Techniques de refactorisation
|
||
|
||
#### Extract Method (Extraction de méthode)
|
||
|
||
```javascript
|
||
// Avant : Méthode étendue
|
||
function processOrder(order) {
|
||
// 50 lignes de traitement complexe
|
||
}
|
||
|
||
// Après : Séparation des responsabilités
|
||
function processOrder(order) {
|
||
validateOrder(order);
|
||
calculateTotal(order);
|
||
saveOrder(order);
|
||
}
|
||
```
|
||
|
||
#### Replace Conditional with Polymorphism
|
||
|
||
```javascript
|
||
// Avant : instruction switch
|
||
function getPrice(user) {
|
||
switch (user.type) {
|
||
case "premium":
|
||
return basePrice * 0.8;
|
||
case "regular":
|
||
return basePrice;
|
||
}
|
||
}
|
||
|
||
// Après : pattern Strategy
|
||
class PremiumPricing {
|
||
calculate(basePrice) {
|
||
return basePrice * 0.8;
|
||
}
|
||
}
|
||
```
|
||
|
||
### Score des principes SOLID (0-100 points)
|
||
|
||
#### Critères d'évaluation et notation
|
||
|
||
```text
|
||
S - Single Responsibility (20 points)
|
||
├─ Nombre de responsabilités de classe : 1 (20 pts) | 2 (15 pts) | 3 (10 pts) | 4+ (5 pts)
|
||
├─ Nombre de méthodes : <7 (+5 pts) | 7-15 (+3 pts) | >15 (0 pts)
|
||
├─ Clarté de la raison de changement : Claire (+5 pts) | Ambiguë (0 pts)
|
||
└─ Exemple de score : UserService(authentification+traitement de données) = 10 points
|
||
|
||
O - Open/Closed (20 points)
|
||
├─ Points d'extension : Strategy/Template Method (20 pts) | Héritage seul (10 pts) | Aucun (5 pts)
|
||
├─ Changements de code existant lors de l'ajout de nouvelles fonctions : Non nécessaire (+5 pts) | Minimal (+3 pts) | Nécessaire (0 pts)
|
||
├─ Utilisation d'interfaces : Appropriée (+5 pts) | Partielle (+3 pts) | Aucune (0 pts)
|
||
└─ Exemple de score : PaymentProcessor(Strategy) = 20 points
|
||
|
||
L - Liskov Substitution (20 points)
|
||
├─ Adhésion au contrat des classes dérivées : Complète (20 pts) | Partielle (10 pts) | Violation (0 pts)
|
||
├─ Renforcement des préconditions : Aucun (+5 pts) | Existe (-5 pts)
|
||
├─ Affaiblissement des postconditions : Aucun (+5 pts) | Existe (-5 pts)
|
||
└─ Exemple de score : Square extends Rectangle = 0 points (violation)
|
||
|
||
I - Interface Segregation (20 points)
|
||
├─ Taille d'interface : 1-3 méthodes (20 pts) | 4-7 (15 pts) | 8+ (5 pts)
|
||
├─ Implémentation de méthodes non utilisées : Aucune (+5 pts) | 1-2 (+2 pts) | 3+ (0 pts)
|
||
├─ Clarté du rôle : Rôle unique (+5 pts) | Multiples rôles (0 pts)
|
||
└─ Exemple de score : Séparation Readable/Writable = 20 points
|
||
|
||
D - Dependency Inversion (20 points)
|
||
├─ Direction de dépendance : Abstraction seule (20 pts) | Mixte (10 pts) | Concrète seule (5 pts)
|
||
├─ Utilisation de DI : Constructor Injection (+5 pts) | Setter (+3 pts) | Aucune (0 pts)
|
||
├─ Capacité de test : Mockable (+5 pts) | Difficile (0 pts)
|
||
└─ Exemple de score : Repository Pattern = 20 points
|
||
|
||
Score total = S + O + L + I + D
|
||
├─ 90-100 points : Excellent (Conformité SOLID complète)
|
||
├─ 70-89 points : Bon (Marge d'amélioration légère)
|
||
├─ 50-69 points : Acceptable (Refactorisation recommandée)
|
||
├─ 30-49 points : Pauvre (Amélioration à grande échelle nécessaire)
|
||
└─ 0-29 points : Critique (Révision de conception obligatoire)
|
||
```
|
||
|
||
### Quantification de la dette technique
|
||
|
||
#### Formule de calcul de la dette
|
||
|
||
```text
|
||
Dette technique (temps) = Score de complexité × Portée d'impact × Difficulté de correction
|
||
|
||
Score de complexité :
|
||
├─ Complexité cyclomatique : 1-5(faible) | 6-10(moyenne) | 11-20(élevée) | 21+(dangereuse)
|
||
├─ Complexité cognitive : Profondeur d'imbrication × Nombre de branchements conditionnels
|
||
├─ Lignes de code : <50(1 pt) | 50-200(2 pts) | 200-500(3 pts) | 500+(5 pts)
|
||
└─ Taux de duplication : 0-10%(1 pt) | 10-30%(2 pts) | 30-50%(3 pts) | 50%+(5 pts)
|
||
|
||
Portée d'impact :
|
||
├─ Nombre de modules dépendants : Dépendance directe + Dépendance indirecte × 0.5
|
||
├─ Fréquence d'utilisation : Nombre d'appels API/jour
|
||
├─ Importance métier : Critique(×3) | Élevée(×2) | Moyenne(×1) | Faible(×0.5)
|
||
└─ Connaissance de l'équipe : 1 personne qui comprend(×3) | 2-3(×2) | 4+(×1)
|
||
|
||
Difficulté de correction :
|
||
├─ Couverture de tests : 0%(×3) | <50%(×2) | 50-80%(×1.5) | >80%(×1)
|
||
├─ Documentation : Aucune(×2) | Insuffisante(×1.5) | Suffisante(×1)
|
||
├─ Relations de dépendance : Couplage fort(×3) | Modéré(×2) | Couplage faible(×1)
|
||
└─ Risque de changement : Breaking Change(×3) | Considération de compatibilité(×2) | Sûr(×1)
|
||
|
||
Conversion de coûts :
|
||
├─ Coût de temps : Temps de dette × Salaire horaire du développeur
|
||
├─ Coût d'opportunité : Jours de retard dans le développement de nouvelles fonctionnalités × Impact quotidien sur les ventes
|
||
├─ Coût de qualité : Probabilité d'apparition de bugs × Coût de correction × Fréquence d'apparition
|
||
└─ Coût total : Temps + Coût d'opportunité + Coût de qualité
|
||
```
|
||
|
||
#### Matrice de priorités
|
||
|
||
| Priorité | Degré d'impact | Coût de correction | Délai de réponse | Exemple concret | Action recommandée |
|
||
| --------------------------------- | -------------- | ------------------ | --------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------- |
|
||
| **Critical (Réponse immédiate)** | Élevé | Faible | Dans 1 semaine | God Object, dépendance circulaire | Commencer la refactorisation immédiatement |
|
||
| **Important (Réponse planifiée)** | Élevé | Élevé | Dans 1 mois | Séparation de responsabilités à grande échelle, changement d'architecture | Incorporer dans la planification de sprint |
|
||
| **Watch (Objet de surveillance)** | Faible | Élevé | Dans 3 mois | Traitement interne de haute complexité | Surveillance des métriques, réponse en cas d'aggravation |
|
||
| **Acceptable (Gamme acceptable)** | Faible | Faible | Ne nécessite pas de réponse | Code smells légers | Réponse avec refactorisation normale |
|
||
|
||
### Procédure de refactorisation
|
||
|
||
1. **Analyse et mesure de l'état actuel**
|
||
- Mesure de complexité (cyclomatique ・cognitive)
|
||
- Calcul du score SOLID (0-100 points)
|
||
- Quantification de la dette technique (temps/coût)
|
||
- Création de matrice de priorités
|
||
|
||
2. **Exécution progressive**
|
||
- Petites étapes (unités de 15-30 minutes)
|
||
- Exécution de tests après chaque changement
|
||
- Commits fréquents
|
||
- Mesure continue du score SOLID
|
||
|
||
3. **Confirmation de qualité**
|
||
- Maintien de la couverture de tests
|
||
- Mesure de performance
|
||
- Confirmation de réduction de la dette technique
|
||
- Révision de code
|
||
|
||
### Code smells courants et score de dette
|
||
|
||
| Code Smell | Critère de détection | Score de dette | Méthode d'amélioration |
|
||
| ----------------------- | ---------------------------------------- | -------------- | ------------------------------ |
|
||
| **God Object** | Responsabilités >3, méthodes >20 | Élevé (15-20h) | Extract Class, application SRP |
|
||
| **Long Method** | Lignes >50, complexité >10 | Moyen (5-10h) | Extract Method |
|
||
| **Duplicate Code** | Taux de duplication >30% | Élevé (10-15h) | Extract Method/Class |
|
||
| **Large Class** | Lignes >300, méthodes >15 | Élevé (10-20h) | Extract Class |
|
||
| **Long Parameter List** | Paramètres >4 | Faible (2-5h) | Parameter Object |
|
||
| **Feature Envy** | Références à autres classes >5 | Moyen (5-10h) | Move Method |
|
||
| **Data Clumps** | Répétition du même groupe d'arguments | Faible (3-5h) | Extract Class |
|
||
| **Primitive Obsession** | Utilisation excessive de types primitifs | Moyen (5-8h) | Replace with Object |
|
||
| **Switch Statements** | case >5 | Moyen (5-10h) | Strategy Pattern |
|
||
| **Shotgun Surgery** | Zones affectées lors du changement >3 | Élevé (10-15h) | Move Method/Field |
|
||
|
||
### Exemple pratique : Évaluation du score SOLID
|
||
|
||
```javascript
|
||
// Objet d'évaluation : classe UserService
|
||
class UserService {
|
||
constructor(db, cache, logger, emailService) { // 4 dépendances
|
||
this.db = db;
|
||
this.cache = cache;
|
||
this.logger = logger;
|
||
this.emailService = emailService;
|
||
}
|
||
|
||
// Responsabilité 1 : authentification
|
||
authenticate(username, password) { /* ... */ }
|
||
refreshToken(token) { /* ... */ }
|
||
|
||
// Responsabilité 2 : gestion des utilisateurs
|
||
createUser(data) { /* ... */ }
|
||
updateUser(id, data) { /* ... */ }
|
||
deleteUser(id) { /* ... */ }
|
||
|
||
// Responsabilité 3 : notification
|
||
sendWelcomeEmail(user) { /* ... */ }
|
||
sendPasswordReset(email) { /* ... */ }
|
||
}
|
||
|
||
// Résultat d'évaluation du score SOLID
|
||
S: 10 points (3 responsabilités : authentification, CRUD, notification)
|
||
O: 5 points (sans points d'extension, implémentation directe)
|
||
L: 15 points (sans héritage, non applicable)
|
||
I: 10 points (interface non ségrégée)
|
||
D: 10 points (dépendance de classes concrètes)
|
||
Total: 50 points (Acceptable - Refactorisation recommandée)
|
||
|
||
// Dette technique
|
||
Complexité: 15 (7 méthodes, 3 responsabilités)
|
||
Portée d'impact: 8 (authentification utilisée dans toutes les fonctions)
|
||
Difficulté de correction: 2 (avec tests, documentation insuffisante)
|
||
Temps de dette: 15 × 8 × 2 = 240 heures
|
||
Priorité: Critical (système d'authentification nécessite réponse immédiate)
|
||
```
|
||
|
||
### Exemple d'implémentation après amélioration
|
||
|
||
```javascript
|
||
// Après application des principes SOLID (Score : 90 points)
|
||
|
||
// S : Responsabilité unique (20 points)
|
||
class AuthenticationService {
|
||
authenticate(credentials) { /* ... */ }
|
||
refreshToken(token) { /* ... */ }
|
||
}
|
||
|
||
// O : Ouvert/fermé (20 points)
|
||
class UserRepository {
|
||
constructor(storage) { // Strategy Pattern
|
||
this.storage = storage;
|
||
}
|
||
save(user) { return this.storage.save(user); }
|
||
}
|
||
|
||
// I : Ségrégation d'interface (20 points)
|
||
interface Readable {
|
||
find(id);
|
||
findAll();
|
||
}
|
||
interface Writable {
|
||
save(entity);
|
||
delete(id);
|
||
}
|
||
|
||
// D : Inversion de dépendance (20 points)
|
||
class UserService {
|
||
constructor(
|
||
private auth: IAuthService,
|
||
private repo: IUserRepository,
|
||
private notifier: INotificationService
|
||
) {}
|
||
}
|
||
|
||
// Réduction de dette : 240 heures → 20 heures (92% de réduction)
|
||
```
|
||
|
||
### Support d'automatisation
|
||
|
||
```bash
|
||
# Mesure du score SOLID
|
||
npx solid-analyzer src/ --output report.json
|
||
|
||
# Analyse de complexité
|
||
npx complexity-report src/ --format json
|
||
sonar-scanner -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info
|
||
|
||
# Visualisation de la dette technique
|
||
npx code-debt-analyzer --config .debt.yml
|
||
|
||
# Format de code
|
||
npm run lint:fix
|
||
prettier --write src/
|
||
|
||
# Exécution de tests et couverture
|
||
npm test -- --coverage
|
||
npm run test:mutation # tests de mutation
|
||
```
|
||
|
||
### Précautions
|
||
|
||
- **Interdiction de changements fonctionnels** : Ne pas changer le comportement externe
|
||
- **Test first** : Ajouter des tests avant la refactorisation
|
||
- **Approche progressive** : Ne pas faire de gros changements d'un coup
|
||
- **Vérification continue** : Exécution de tests à chaque étape
|