Reglas de Rector para Refactorizar Código PHP

Desde que empecé a usar Rector, se ha convertido en una de mis herramientas favoritas para refactorizar código PHP de manera automática. Me ha ayudado a mejorar la calidad de mi código y a mantenerlo actualizado sin esfuerzo. Aquí quiero compartir algunas de las reglas que más utilizo, con ejemplos prácticos que pueden serte útiles si decides integrarlo en tus proyectos.

1. Code Quality Rules (Reglas para Mejorar la Calidad del Código)

CombinedAssignRector

Esta regla convierte asignaciones repetitivas en una sola línea para hacer el código más limpio y legible.

Antes:

$counter = $counter + 1;

Después:

$counter += 1;

---

SimplifyEmptyArrayCheckRector

Simplifica las comprobaciones de arrays vacíos usando empty() en lugar de contar los elementos.

Antes:

if (count($array) === 0) {
    // código
}

Después:

if (empty($array)) {
    // código
}

2. Dead Code Rules (Reglas para Eliminar Código Muerto)

RemoveUnusedPrivateMethodRector

Elimina métodos privados que no están en uso. Me ha sido muy útil para limpiar clases antiguas.

Antes:

class MyClass {
    private function unusedMethod() {
        // código
    }
}

Después:

class MyClass {
    // Método eliminado
}

RemoveDeadStmtRector

Identifica y elimina sentencias que nunca se ejecutan.

Antes:

return;
$unusedCode = 'Esto nunca se ejecutará';

Después:

return;

3. Early Return Rules (Reglas para Retorno Temprano)

ChangeNestedIfsToEarlyReturnRector

Convierte estructuras if anidadas en retornos tempranos. Esto hace que el código sea mucho más fácil de leer.

Antes:

if ($value) {
    if ($value > 10) {
        return true;
    }
}

Después:

if (!$value) {
    return false;
}

if ($value > 10) {
    return true;
}

4. Type Declaration Rules (Reglas para Declaración de Tipos)

AddParamTypeFromPropertyTypeRector

Agrega tipos a los parámetros basados en el tipo de propiedad. Esto me ha ayudado a prevenir muchos errores.

Antes:

class MyClass {
    private int $id;

    public function setId($id) {
        $this->id = $id;
    }
}

Después:

class MyClass {
    private int $id;

    public function setId(int $id) {
        $this->id = $id;
    }
}

TypedPropertyFromAssignsRector

Agrega tipos a las propiedades basadas en las asignaciones que encuentra en el constructor u otros métodos.

Antes:

class MyClass {
    private $id;

    public function __construct() {
        $this->id = 123;
    }
}

Después:

class MyClass {
    private int $id;

    public function __construct() {
        $this->id = 123;
    }
}

5. Privatization Rules (Reglas para Privatización)

PrivatizeFinalClassPropertyRector

Convierte propiedades públicas en privadas dentro de clases finales para mejorar la encapsulación.

Antes:

final class MyClass {
    public $name;
}

Después:

final class MyClass {
    private $name;
}

6. Symfony Specific Rules (Reglas Específicas para Symfony)

ResponseReturnTypeControllerActionRector

Asegura que las acciones de los controladores devuelvan siempre un tipo Response. Esta regla es clave si trabajas con Symfony.

Antes:

public function index() {
    return 'Hello World';
}

Después:

use Symfony\Component\HttpFoundation\Response;

public function index(): Response {
    return new Response('Hello World');
}

7. Coding Style Rules (Reglas para Estilo de Código)

EncapsedStringsToSprintfRector

Convierte cadenas encapsuladas ("...") en sprintf() para mayor claridad.

Antes:

echo "Hello, $name!";

Después:

echo sprintf("Hello, %s!", $name);

ConsistentImplodeRector

Asegura el uso consistente de implode().

Antes:

implode(',', $array);

Después:

implode(',', $array);  // Ningún cambio, pero asegura consistencia en el orden de los parámetros.

8. Function Rules (Reglas para Llamadas a Funciones)

CallUserFuncToMethodCallRector

Convierte call_user_func() en una llamada directa al método.

Antes:

call_user_func([$this, 'methodName']);

Después:

$this->methodName();

ArrayMergeOfNonArraysToSimpleArrayRector

Simplifica la fusión de arrays cuando no es necesaria.

Antes:

$result = array_merge([], $array);

Después:

$result = $array;

9. Boolean Simplification Rules (Reglas para Simplificación de Booleanos)

SimplifyIfReturnBoolRector

Simplifica sentencias if que retornan directamente un valor booleano.

Antes:

if ($value) {
    return true;
} else {
    return false;
}

Después:

return (bool) $value;

10. Dead Code Elimination (Eliminación de Código Muerto)

RemoveUnusedPromotedPropertyRector

Elimina propiedades promovidas en constructores que no se utilizan.

Antes:

class MyClass {
    public function __construct(private string $unusedProperty) {}
}

Después:

class MyClass {
    public function __construct() {}
}

Conclusión

Desde que uso Rector, refactorizar mi código PHP se ha vuelto mucho más sencillo. Si todavía no lo has probado, te animo a que lo hagas. Es una herramienta que puede ahorrarte horas de trabajo y ayudarte a mantener tu proyecto limpio y actualizado.