/refactor

Refactor

Implementa refactorización de código segura y gradual, evalúa cuantitativamente la adherencia a los principios SOLID. Visualiza la deuda técnica y clarifica las prioridades de mejora.

Uso

# Identificación de código complejo y plan de refactorización
find . -name "*.js" -exec wc -l {} + | sort -rn | head -10
"Refactoriza estos archivos grandes para reducir la complejidad"

# Detección e integración de código duplicado
grep -r "function processUser" . --include="*.js"
"Unifica estas funciones duplicadas con Extract Method"

# Detección de violaciones de principios SOLID
grep -r "class.*Service" . --include="*.js" | head -10
"Evalúa si estas clases siguen el principio de responsabilidad única"

Ejemplos básicos

# Detección de métodos largos
grep -A 50 "function" src/*.js | grep -B 50 -A 50 "return" | wc -l
"Divide métodos de más de 50 líneas con Extract Method"

# Complejidad de ramificaciones condicionales
grep -r "if.*if.*if" . --include="*.js"
"Mejora estas declaraciones condicionales anidadas con patrón Strategy"

# Detección de code smells
grep -r "TODO\|FIXME\|HACK" . --exclude-dir=node_modules
"Resuelve los comentarios que se han convertido en deuda técnica"

Técnicas de refactorización

Extract Method (Extracción de método)

// Antes: Método extenso
function processOrder(order) {
  // 50 líneas de procesamiento complejo
}

// Después: Separación de responsabilidades
function processOrder(order) {
  validateOrder(order);
  calculateTotal(order);
  saveOrder(order);
}

Replace Conditional with Polymorphism

// Antes: sentencia switch
function getPrice(user) {
  switch (user.type) {
    case "premium":
      return basePrice * 0.8;
    case "regular":
      return basePrice;
  }
}

// Después: patrón Strategy
class PremiumPricing {
  calculate(basePrice) {
    return basePrice * 0.8;
  }
}

Puntuación de principios SOLID (0-100 puntos)

Criterios de evaluación y puntuación

S - Single Responsibility (20 puntos)
├─ Número de responsabilidades de clase: 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)
├─ Claridad de razón de cambio: Clara (+5 pts) | Ambigua (0 pts)
└─ Ejemplo de puntuación: UserService(autenticación+procesamiento de datos) = 10 puntos

O - Open/Closed (20 puntos)
├─ Puntos de extensión: Strategy/Template Method (20 pts) | Solo herencia (10 pts) | Ninguno (5 pts)
├─ Cambios en código existente al agregar nuevas funciones: No necesario (+5 pts) | Mínimo (+3 pts) | Necesario (0 pts)
├─ Uso de interfaces: Apropiado (+5 pts) | Parcial (+3 pts) | Ninguno (0 pts)
└─ Ejemplo de puntuación: PaymentProcessor(Strategy) = 20 puntos

L - Liskov Substitution (20 puntos)
├─ Adherencia al contrato de clases derivadas: Completa (20 pts) | Parcial (10 pts) | Violación (0 pts)
├─ Fortalecimiento de precondiciones: Ninguno (+5 pts) | Existe (-5 pts)
├─ Debilitamiento de postcondiciones: Ninguno (+5 pts) | Existe (-5 pts)
└─ Ejemplo de puntuación: Square extends Rectangle = 0 puntos (violación)

I - Interface Segregation (20 puntos)
├─ Tamaño de interfaz: 1-3 métodos (20 pts) | 4-7 (15 pts) | 8+ (5 pts)
├─ Implementación de métodos no utilizados: Ninguno (+5 pts) | 1-2 (+2 pts) | 3+ (0 pts)
├─ Claridad de rol: Rol único (+5 pts) | Múltiples roles (0 pts)
└─ Ejemplo de puntuación: Separación Readable/Writable = 20 puntos

D - Dependency Inversion (20 puntos)
├─ Dirección de dependencia: Solo abstracción (20 pts) | Mixta (10 pts) | Solo concreta (5 pts)
├─ Uso de DI: Constructor Injection (+5 pts) | Setter (+3 pts) | Ninguno (0 pts)
├─ Capacidad de prueba: Mockeable (+5 pts) | Difícil (0 pts)
└─ Ejemplo de puntuación: Repository Pattern = 20 puntos

Puntuación total = S + O + L + I + D
├─ 90-100 puntos: Excelente (Cumplimiento completo SOLID)
├─ 70-89 puntos: Bueno (Margen de mejora leve)
├─ 50-69 puntos: Aceptable (Refactorización recomendada)
├─ 30-49 puntos: Pobre (Mejora a gran escala necesaria)
└─ 0-29 puntos: Crítico (Revisión de diseño obligatoria)

Cuantificación de deuda técnica

Fórmula de cálculo de deuda

Deuda técnica (tiempo) = Puntuación de complejidad × Alcance de impacto × Dificultad de corrección

Puntuación de complejidad:
├─ Complejidad ciclomática: 1-5(baja) | 6-10(media) | 11-20(alta) | 21+(peligrosa)
├─ Complejidad cognitiva: Profundidad de anidación × Número de ramificaciones condicionales
├─ Líneas de código: <50(1 pt) | 50-200(2 pts) | 200-500(3 pts) | 500+(5 pts)
└─ Tasa de duplicación: 0-10%(1 pt) | 10-30%(2 pts) | 30-50%(3 pts) | 50%+(5 pts)

Alcance de impacto:
├─ Número de módulos dependientes: Dependencia directa + Dependencia indirecta × 0.5
├─ Frecuencia de uso: Número de llamadas API/día
├─ Importancia comercial: Crítica(×3) | Alta(×2) | Media(×1) | Baja(×0.5)
└─ Conocimiento del equipo: 1 persona que entiende(×3) | 2-3(×2) | 4+(×1)

Dificultad de corrección:
├─ Cobertura de pruebas: 0%(×3) | <50%(×2) | 50-80%(×1.5) | >80%(×1)
├─ Documentación: Ninguna(×2) | Insuficiente(×1.5) | Suficiente(×1)
├─ Relaciones de dependencia: Acoplamiento fuerte(×3) | Moderado(×2) | Acoplamiento débil(×1)
└─ Riesgo de cambio: Breaking Change(×3) | Consideración de compatibilidad(×2) | Seguro(×1)

Conversión de costos:
├─ Costo de tiempo: Tiempo de deuda × Salario por hora del desarrollador
├─ Costo de oportunidad: Días de retraso en desarrollo de nuevas funciones × Impacto diario en ventas
├─ Costo de calidad: Probabilidad de aparición de bugs × Costo de corrección × Frecuencia de aparición
└─ Costo total: Tiempo + Costo de oportunidad + Costo de calidad

Matriz de prioridades

Prioridad	Grado de impacto	Costo de corrección	Plazo de respuesta	Ejemplo concreto	Acción recomendada
Critical (Respuesta inmediata)	Alto	Bajo	Dentro de 1 semana	God Object, dependencia circular	Iniciar refactorización inmediatamente
Important (Respuesta planificada)	Alto	Alto	Dentro de 1 mes	Separación de responsabilidades a gran escala, cambio de arquitectura	Incorporar en planificación de sprint
Watch (Objeto de monitoreo)	Bajo	Alto	Dentro de 3 meses	Procesamiento interno de alta complejidad	Monitoreo de métricas, respuesta cuando empeore
Acceptable (Rango aceptable)	Bajo	Bajo	No requiere respuesta	Code smells leves	Respuesta con refactorización normal

Procedimiento de refactorización

1. Análisis y medición del estado actual

   • Medición de complejidad (ciclomática ・cognitiva)
   • Cálculo de puntuación SOLID (0-100 puntos)
   • Cuantificación de deuda técnica (tiempo/costo)
   • Creación de matriz de prioridades

2. Ejecución gradual

   • Pasos pequeños (unidades de 15-30 minutos)
   • Ejecución de pruebas después de cada cambio
   • Commits frecuentes
   • Medición continua de puntuación SOLID

3. Confirmación de calidad

   • Mantenimiento de cobertura de pruebas
   • Medición de rendimiento
   • Confirmación de reducción de deuda técnica
   • Revisión de código

Code smells comunes y puntuación de deuda

Code Smell	Criterio de detección	Puntuación de deuda	Método de mejora
God Object	Responsabilidades >3, métodos >20	Alta (15-20h)	Extract Class, aplicación SRP
Long Method	Líneas >50, complejidad >10	Media (5-10h)	Extract Method
Duplicate Code	Tasa de duplicación >30%	Alta (10-15h)	Extract Method/Class
Large Class	Líneas >300, métodos >15	Alta (10-20h)	Extract Class
Long Parameter List	Parámetros >4	Baja (2-5h)	Parameter Object
Feature Envy	Referencias a otras clases >5	Media (5-10h)	Move Method
Data Clumps	Repetición de mismo grupo de argumentos	Baja (3-5h)	Extract Class
Primitive Obsession	Uso excesivo de tipos primitivos	Media (5-8h)	Replace with Object
Switch Statements	case >5	Media (5-10h)	Strategy Pattern
Shotgun Surgery	Áreas afectadas al cambiar >3	Alta (10-15h)	Move Method/Field

Ejemplo práctico: Evaluación de puntuación SOLID

// Objeto de evaluación: clase UserService
class UserService {
  constructor(db, cache, logger, emailService) { // 4 dependencias
    this.db = db;
    this.cache = cache;
    this.logger = logger;
    this.emailService = emailService;
  }

  // Responsabilidad 1: autenticación
  authenticate(username, password) { /* ... */ }
  refreshToken(token) { /* ... */ }

  // Responsabilidad 2: gestión de usuarios
  createUser(data) { /* ... */ }
  updateUser(id, data) { /* ... */ }
  deleteUser(id) { /* ... */ }

  // Responsabilidad 3: notificación
  sendWelcomeEmail(user) { /* ... */ }
  sendPasswordReset(email) { /* ... */ }
}

// Resultado de evaluación de puntuación SOLID
S: 10 puntos (3 responsabilidades: autenticación, CRUD, notificación)
O: 5 puntos (sin puntos de extensión, implementación directa)
L: 15 puntos (sin herencia, no aplicable)
I: 10 puntos (interfaz no segregada)
D: 10 puntos (dependencia de clases concretas)
Total: 50 puntos (Aceptable - Refactorización recomendada)

// Deuda técnica
Complejidad: 15 (7 métodos, 3 responsabilidades)
Alcance de impacto: 8 (autenticación usada en todas las funciones)
Dificultad de corrección: 2 (con pruebas, documentación insuficiente)
Tiempo de deuda: 15 × 8 × 2 = 240 horas
Prioridad: Critical (sistema de autenticación requiere respuesta inmediata)

Ejemplo de implementación después de mejora

// Después de aplicar principios SOLID (Puntuación: 90 puntos)

// S: Responsabilidad única (20 puntos)
class AuthenticationService {
  authenticate(credentials) { /* ... */ }
  refreshToken(token) { /* ... */ }
}

// O: Abierto/cerrado (20 puntos)
class UserRepository {
  constructor(storage) { // Strategy Pattern
    this.storage = storage;
  }
  save(user) { return this.storage.save(user); }
}

// I: Segregación de interfaz (20 puntos)
interface Readable {
  find(id);
  findAll();
}
interface Writable {
  save(entity);
  delete(id);
}

// D: Inversión de dependencia (20 puntos)
class UserService {
  constructor(
    private auth: IAuthService,
    private repo: IUserRepository,
    private notifier: INotificationService
  ) {}
}

// Reducción de deuda: 240 horas → 20 horas (92% de reducción)

Soporte de automatización

# Medición de puntuación SOLID
npx solid-analyzer src/ --output report.json

# Análisis de complejidad
npx complexity-report src/ --format json
sonar-scanner -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info

# Visualización de deuda técnica
npx code-debt-analyzer --config .debt.yml

# Formato de código
npm run lint:fix
prettier --write src/

# Ejecución de pruebas y cobertura
npm test -- --coverage
npm run test:mutation  # pruebas de mutación

Precauciones

• Prohibición de cambios funcionales: No cambiar el comportamiento externo
• Test first: Agregar pruebas antes de la refactorización
• Enfoque gradual: No hacer cambios grandes de una vez
• Verificación continua: Ejecución de pruebas en cada paso