306 lines
12 KiB
Markdown
306 lines
12 KiB
Markdown
## Refactor
|
||
|
||
Realiza refatoração segura e gradual de código, avaliando quantitativamente a aderência aos princípios SOLID. Visualiza dívida técnica e clarifica as prioridades de melhoria.
|
||
|
||
### Uso
|
||
|
||
```bash
|
||
# Identificação de código complexo e planejamento de refatoração
|
||
find . -name "*.js" -exec wc -l {} + | sort -rn | head -10
|
||
"Refatorar arquivos grandes para reduzir complexidade"
|
||
|
||
# Detecção e unificação de código duplicado
|
||
grep -r "function processUser" . --include="*.js"
|
||
"Unificar funções duplicadas com Extract Method"
|
||
|
||
# Detecção de violações dos princípios SOLID
|
||
grep -r "class.*Service" . --include="*.js" | head -10
|
||
"Avaliar se essas classes seguem o princípio da responsabilidade única"
|
||
```
|
||
|
||
### Exemplos Básicos
|
||
|
||
```bash
|
||
# Detecção de métodos longos
|
||
grep -A 50 "function" src/*.js | grep -B 50 -A 50 "return" | wc -l
|
||
"Dividir métodos com mais de 50 linhas usando Extract Method"
|
||
|
||
# Complexidade de ramificação condicional
|
||
grep -r "if.*if.*if" . --include="*.js"
|
||
"Melhorar condicionais aninhadas com padrão Strategy"
|
||
|
||
# Detecção de code smells
|
||
grep -r "TODO\|FIXME\|HACK" . --exclude-dir=node_modules
|
||
"Resolver comentários que se tornaram dívida técnica"
|
||
```
|
||
|
||
### Técnicas de Refatoração
|
||
|
||
#### Extract Method (Extração de Método)
|
||
|
||
```javascript
|
||
// Antes: método extenso
|
||
function processOrder(order) {
|
||
// 50 linhas de processamento complexo
|
||
}
|
||
|
||
// Depois: separação de responsabilidades
|
||
function processOrder(order) {
|
||
validateOrder(order);
|
||
calculateTotal(order);
|
||
saveOrder(order);
|
||
}
|
||
```
|
||
|
||
#### Replace Conditional with Polymorphism
|
||
|
||
```javascript
|
||
// Antes: declaração switch
|
||
function getPrice(user) {
|
||
switch (user.type) {
|
||
case "premium":
|
||
return basePrice * 0.8;
|
||
case "regular":
|
||
return basePrice;
|
||
}
|
||
}
|
||
|
||
// Depois: padrão Strategy
|
||
class PremiumPricing {
|
||
calculate(basePrice) {
|
||
return basePrice * 0.8;
|
||
}
|
||
}
|
||
```
|
||
|
||
### Pontuação dos Princípios SOLID (0-100 pontos)
|
||
|
||
#### Critérios de Avaliação e Pontuação
|
||
|
||
```text
|
||
S - Single Responsibility (20 pontos)
|
||
├─ Número de responsabilidades da classe: 1 (20 pts) | 2 (15 pts) | 3 (10 pts) | 4+ (5 pts)
|
||
├─ Número de métodos: <7 (+5 pts) | 7-15 (+3 pts) | >15 (0 pts)
|
||
├─ Clareza do motivo de mudança: Clara (+5 pts) | Ambígua (0 pts)
|
||
└─ Exemplo: UserService(autenticação+processamento de dados) = 10 pontos
|
||
|
||
O - Open/Closed (20 pontos)
|
||
├─ Pontos de extensão: Strategy/Template Method (20 pts) | Apenas herança (10 pts) | Nenhum (5 pts)
|
||
├─ Mudanças no código existente ao adicionar funcionalidades: Desnecessárias (+5 pts) | Mínimas (+3 pts) | Necessárias (0 pts)
|
||
├─ Uso de interfaces: Apropriado (+5 pts) | Parcial (+3 pts) | Nenhum (0 pts)
|
||
└─ Exemplo: PaymentProcessor(Strategy) = 20 pontos
|
||
|
||
L - Liskov Substitution (20 pontos)
|
||
├─ Aderência ao contrato das classes derivadas: Completa (20 pts) | Parcial (10 pts) | Violação (0 pts)
|
||
├─ Fortalecimento de pré-condições: Nenhum (+5 pts) | Presente (-5 pts)
|
||
├─ Enfraquecimento de pós-condições: Nenhum (+5 pts) | Presente (-5 pts)
|
||
└─ Exemplo: Square extends Rectangle = 0 pontos (violação)
|
||
|
||
I - Interface Segregation (20 pontos)
|
||
├─ Tamanho da interface: 1-3 métodos (20 pts) | 4-7 (15 pts) | 8+ (5 pts)
|
||
├─ Implementação de métodos não utilizados: Nenhum (+5 pts) | 1-2 (+2 pts) | 3+ (0 pts)
|
||
├─ Clareza do papel: Papel único (+5 pts) | Múltiplos papéis (0 pts)
|
||
└─ Exemplo: Separação Readable/Writable = 20 pontos
|
||
|
||
D - Dependency Inversion (20 pontos)
|
||
├─ Direção da dependência: Apenas abstração (20 pts) | Mista (10 pts) | Apenas concreta (5 pts)
|
||
├─ Uso de DI: Constructor Injection (+5 pts) | Setter (+3 pts) | Nenhum (0 pts)
|
||
├─ Testabilidade: Mock possível (+5 pts) | Difícil (0 pts)
|
||
└─ Exemplo: Repository Pattern = 20 pontos
|
||
|
||
Pontuação Total = S + O + L + I + D
|
||
├─ 90-100 pontos: Excellent (Aderência completa ao SOLID)
|
||
├─ 70-89 pontos: Good (Pequena margem para melhoria)
|
||
├─ 50-69 pontos: Fair (Refatoração recomendada)
|
||
├─ 30-49 pontos: Poor (Melhoria em grande escala necessária)
|
||
└─ 0-29 pontos: Critical (Revisão de design obrigatória)
|
||
```
|
||
|
||
### Quantificação da Dívida Técnica
|
||
|
||
#### Fórmula de Cálculo da Dívida
|
||
|
||
```text
|
||
Dívida Técnica (tempo) = Pontuação de Complexidade × Escopo de Impacto × Dificuldade de Correção
|
||
|
||
Pontuação de Complexidade:
|
||
├─ Complexidade ciclomática: 1-5(baixa) | 6-10(média) | 11-20(alta) | 21+(perigosa)
|
||
├─ Complexidade cognitiva: Profundidade de aninhamento × Número de ramificações condicionais
|
||
├─ Linhas de código: <50(1 pt) | 50-200(2 pts) | 200-500(3 pts) | 500+(5 pts)
|
||
└─ Taxa de duplicação: 0-10%(1 pt) | 10-30%(2 pts) | 30-50%(3 pts) | 50%+(5 pts)
|
||
|
||
Escopo de Impacto:
|
||
├─ Número de módulos dependentes: Dependência direta + Dependência indireta × 0.5
|
||
├─ Frequência de uso: Número de chamadas API/dia
|
||
├─ Importância do negócio: Critical(×3) | High(×2) | Medium(×1) | Low(×0.5)
|
||
└─ Conhecimento da equipe: 1 pessoa entende(×3) | 2-3 pessoas(×2) | 4+ pessoas(×1)
|
||
|
||
Dificuldade de Correção:
|
||
├─ Cobertura de testes: 0%(×3) | <50%(×2) | 50-80%(×1.5) | >80%(×1)
|
||
├─ Documentação: Nenhuma(×2) | Insuficiente(×1.5) | Suficiente(×1)
|
||
├─ Dependências: Acoplamento forte(×3) | Moderado(×2) | Fraco(×1)
|
||
└─ Risco de mudança: Breaking Change(×3) | Consideração de compatibilidade(×2) | Seguro(×1)
|
||
|
||
Conversão de Custo:
|
||
├─ Custo de tempo: Tempo de dívida × Salário por hora do desenvolvedor
|
||
├─ Perda de oportunidade: Dias de atraso no desenvolvimento de novas funcionalidades × Impacto na receita diária
|
||
├─ Custo de qualidade: Probabilidade de ocorrência de bug × Custo de correção × Frequência de ocorrência
|
||
└─ Custo total: Tempo + Perda de oportunidade + Custo de qualidade
|
||
```
|
||
|
||
#### Matriz de Prioridades
|
||
|
||
| Prioridade | Impacto | Custo de Correção | Prazo de Resposta | Exemplo Concreto | Ação Recomendada |
|
||
| ----------------------------------- | ------- | ----------------- | ------------------ | ----------------------------------------------------------------------- | -------------------------------------------------------------- |
|
||
| **Critical (Resposta Imediata)** | Alto | Baixo | Dentro de 1 semana | God Object, dependências circulares | Iniciar refatoração imediatamente |
|
||
| **Important (Resposta Planejada)** | Alto | Alto | Dentro de 1 mês | Separação de responsabilidades em grande escala, mudanças arquiteturais | Incluir no planejamento de sprint |
|
||
| **Watch (Objeto de Monitoramento)** | Baixo | Alto | Dentro de 3 meses | Processamento interno de alta complexidade | Monitoramento de métricas, resposta quando houver deterioração |
|
||
| **Acceptable (Faixa Aceitável)** | Baixo | Baixo | Não necessário | Code smells menores | Resposta através de refatoração normal |
|
||
|
||
### Procedimento de Refatoração
|
||
|
||
1. **Análise e Medição Atual**
|
||
- Medição de complexidade (ciclomática ・cognitiva)
|
||
- Cálculo de pontuação SOLID (0-100 pontos)
|
||
- Quantificação de dívida técnica (tempo/custo)
|
||
- Criação de matriz de prioridades
|
||
|
||
2. **Execução Gradual**
|
||
- Pequenos passos (unidades de 15-30 minutos)
|
||
- Execução de testes após cada mudança
|
||
- Commits frequentes
|
||
- Medição contínua de pontuação SOLID
|
||
|
||
3. **Confirmação de Qualidade**
|
||
- Manutenção de cobertura de testes
|
||
- Medição de desempenho
|
||
- Confirmação de redução de dívida técnica
|
||
- Revisão de código
|
||
|
||
### Code Smells Comuns e Pontuação de Dívida
|
||
|
||
| Code Smell | Critério de Detecção | Pontuação de Dívida | Técnica de Melhoria |
|
||
| ----------------------- | -------------------------------------- | ------------------- | ---------------------------- |
|
||
| **God Object** | Responsabilidades >3, métodos >20 | Alta (15-20h) | Extract Class, aplicação SRP |
|
||
| **Long Method** | Linhas >50, complexidade >10 | Média (5-10h) | Extract Method |
|
||
| **Duplicate Code** | Taxa de duplicação >30% | Alta (10-15h) | Extract Method/Class |
|
||
| **Large Class** | Linhas >300, métodos >15 | Alta (10-20h) | Extract Class |
|
||
| **Long Parameter List** | Parâmetros >4 | Baixa (2-5h) | Parameter Object |
|
||
| **Feature Envy** | Referências a outras classes >5 | Média (5-10h) | Move Method |
|
||
| **Data Clumps** | Repetição do mesmo grupo de argumentos | Baixa (3-5h) | Extract Class |
|
||
| **Primitive Obsession** | Uso excessivo de tipos primitivos | Média (5-8h) | Replace with Object |
|
||
| **Switch Statements** | case >5 | Média (5-10h) | Strategy Pattern |
|
||
| **Shotgun Surgery** | Locais de impacto na mudança >3 | Alta (10-15h) | Move Method/Field |
|
||
|
||
### Exemplo Prático: Avaliação de Pontuação SOLID
|
||
|
||
```javascript
|
||
// Objeto de avaliação: classe UserService
|
||
class UserService {
|
||
constructor(db, cache, logger, emailService) { // 4 dependências
|
||
this.db = db;
|
||
this.cache = cache;
|
||
this.logger = logger;
|
||
this.emailService = emailService;
|
||
}
|
||
|
||
// Responsabilidade 1: autenticação
|
||
authenticate(username, password) { /* ... */ }
|
||
refreshToken(token) { /* ... */ }
|
||
|
||
// Responsabilidade 2: gerenciamento de usuário
|
||
createUser(data) { /* ... */ }
|
||
updateUser(id, data) { /* ... */ }
|
||
deleteUser(id) { /* ... */ }
|
||
|
||
// Responsabilidade 3: notificação
|
||
sendWelcomeEmail(user) { /* ... */ }
|
||
sendPasswordReset(email) { /* ... */ }
|
||
}
|
||
|
||
// Resultado da avaliação de pontuação SOLID
|
||
S: 10 pontos (3 responsabilidades: autenticação, CRUD, notificação)
|
||
O: 5 pontos (sem pontos de extensão, implementação direta)
|
||
L: 15 pontos (sem herança, não aplicável)
|
||
I: 10 pontos (interface não segregada)
|
||
D: 10 pontos (dependência de classe concreta)
|
||
Total: 50 pontos (Fair - refatoração recomendada)
|
||
|
||
// Dívida técnica
|
||
Complexidade: 15 (7 métodos, 3 responsabilidades)
|
||
Escopo de impacto: 8 (autenticação usada em todas as funcionalidades)
|
||
Dificuldade de correção: 2 (testes existentes, documentação insuficiente)
|
||
Tempo de dívida: 15 × 8 × 2 = 240 horas
|
||
Prioridade: Critical (sistema de autenticação requer resposta imediata)
|
||
```
|
||
|
||
### Exemplo de Implementação Após Melhoria
|
||
|
||
```javascript
|
||
// Após aplicação dos princípios SOLID (Pontuação: 90 pontos)
|
||
|
||
// S: responsabilidade única (20 pontos)
|
||
class AuthenticationService {
|
||
authenticate(credentials) { /* ... */ }
|
||
refreshToken(token) { /* ... */ }
|
||
}
|
||
|
||
// O: aberto/fechado (20 pontos)
|
||
class UserRepository {
|
||
constructor(storage) { // Strategy Pattern
|
||
this.storage = storage;
|
||
}
|
||
save(user) { return this.storage.save(user); }
|
||
}
|
||
|
||
// I: segregação de interface (20 pontos)
|
||
interface Readable {
|
||
find(id);
|
||
findAll();
|
||
}
|
||
interface Writable {
|
||
save(entity);
|
||
delete(id);
|
||
}
|
||
|
||
// D: inversão de dependência (20 pontos)
|
||
class UserService {
|
||
constructor(
|
||
private auth: IAuthService,
|
||
private repo: IUserRepository,
|
||
private notifier: INotificationService
|
||
) {}
|
||
}
|
||
|
||
// Redução de dívida: 240 horas → 20 horas (redução de 92%)
|
||
```
|
||
|
||
### Suporte de Automação
|
||
|
||
```bash
|
||
# Medição de pontuação SOLID
|
||
npx solid-analyzer src/ --output report.json
|
||
|
||
# Análise de complexidade
|
||
npx complexity-report src/ --format json
|
||
sonar-scanner -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info
|
||
|
||
# Visualização de dívida técnica
|
||
npx code-debt-analyzer --config .debt.yml
|
||
|
||
# Formatação de código
|
||
npm run lint:fix
|
||
prettier --write src/
|
||
|
||
# Execução de testes e cobertura
|
||
npm test -- --coverage
|
||
npm run test:mutation # teste de mutação
|
||
```
|
||
|
||
### Observações
|
||
|
||
- **Proibição de mudança funcional**: Não alterar comportamento externo
|
||
- **Test First**: Adicionar testes antes da refatoração
|
||
- **Abordagem gradual**: Não fazer grandes mudanças de uma só vez
|
||
- **Verificação contínua**: Execução de testes em cada etapa
|