Hoy retomo los artículos sobre Symfony con la intención de hablaros sobre dos paquetes que os ayudarán mucho a mejorar muchísimo vuestro código y ahorraros algún que otro disgusto:

• EasyCodingStandard es una librería que nos va a permitir comprobar el estilo de nuestro código para asegurar que cumple con los estándares y automáticamente corregir aquellos errores que detecte. Es compatible tanto con PHP_CodeSniffer como con PHP-CS-Fixer, por lo que podéis trabajar indistintamente con cualquiera
• PHPStan (PHP Static Analyzer) es un analizador estático de código, lo cual nos permite comprobar que la aplicación guarda un tipado coherente, la existencia de los métodos y propiedades de los objetos y vigilar que cumplimos con las principales buenas prácticas.

La instalación y configuración de ambas librerías lleva apenas 10 minutos, por lo que me ha resultado interesante escribir este artículo para que os animéis a incorporarlas en vuestros proyectos.

Instalación de EasyCodingStandard

La instalación de EasyCodingStandard la realizaremos mediante composer:

composer require symplify/easy-coding-standard --dev

Es importante que si estáis trabajando con Symfony 5 os encontréis como poco en la versión 5.1 ya que si no os dará fallo.

A continuación crearemos un archivo ecs.php en la raíz del proyecto, que será en donde estableceremos la configuración de la librería y especificaremos, entre otras cosas, el path de los archivos que queremos analizar.

Tras varias pruebas os dejo una configuración que a mí personalmente me ha funcionado muy bien:

En este archivo lo primero que haremos es configurar algunos de los servicios de PHPCsFixer para establecer el valor de ciertas reglas:

• En la línea 11 fuerzo a que en todo el código se emplee la sintaxis corta para crear arrays.
• En la línea 15 establezco que en el momento en que los argumentos de una función ocupan varias líneas, cada uno de ellos aparezca en una nueva línea.
• Y finalmente en la 19 establezco que las llamadas a determinadas funciones nativas del lenguaje (por ejemplo, in_array ) vayan precedidas de una barra para optimizar su invocación ( \in_array ).

A continuación definiremos los parámetros con los que se realizará análisis, es decir, las rutas de los archivos que queremos analizar y aquellas que queremos evitar.

Hecho esto, tan sólo nos queda añadir a nuestro archivo composer.json la siguiente línea dentro de la sección “scripts” para invocar a la librería y poder realizar el análisis de la sintaxis:

"scripts": {
    ...
    "cs": [
      "vendor/bin/ecs check --ansi --no-interaction"
    ],
    "cs-fix: [
      "vendor/bin/ecs check --fix --ansi --no-interaction"
    ]
}

Gracias a esto, podremos invocar desde la raíz de nuestro proyecto los siguientes comandos:

• composer cs para visualizar los errores detectados .
• composer cs-fix para visualizar y automáticamente dejar que la librería arregle los errores detectados.

Más fácil imposible, ¿no? Pasemos ahora a instalar PHPStan.

Instalación y configuración de PHPStan

La otra herramienta que instalaremos será PHPStan, un analizador de código estático con la siguiente descripción:

PHPStan focuses on finding errors in your code without actually running it. It catches whole classes of bugs even before you write tests for the code. It moves PHP closer to compiled languages in the sense that the correctness of each line of the code can be checked before you run the actual line.

Su instalación de nuevo la realizaremos con composer :

composer require --dev phpstan/phpstan

Además, instalaremos la siguiente librería phpstan-extension-installer, la cual se encargará de configurar automáticamente las extensiones que añadiremos, sin necesidad de que tengamos que modificar el archivo de configuración. ¡Todo comodidades!

composer require --dev phpstan/extension-installer

Para completar este primer paso, crearemos el archivo phpstan.neon en la raíz de nuestro proyecto (si no existe ya) y añadiremos lo siguiente:

• El parámetro level especifica lo estricto que queremos que sea, siendo 1 el valor más bajo (se recomienda empezar por un nivel bajo e ir subiendo a medida que corregimos los errores prinicipales).
• Y del mismo modo que hicimos con EasyCodingStandards, podemos configurar las rutas que queremos analizar y aquellas que queremos excluir.

Hecho esto y puesto que se supone que estamos trabajando con un proyecto de Symfony instalaremos unas cuantas librerías más para “enseñar” a PHPStan determinadas estructuras del framework.

PHPStan Symfony

La primera de ellas es phpstan-symfony:

composer require --dev phpstan/phpstan-symfony

Gracias a la librería phpstan-extension-installer tendremos prácticamente configurada esta extensión salvo por un detalle: tenemos que decirle a PHPStan dónde se encuentra el “Container” de Symfony compilado en XML. Para ello añadiremos una nueva linea a nuestro archivo phpstan.neon :

Con esta configuración, PHPStan podrá entender el código de Symfony y comprobará también que no estamos obteniendo servicios inexistentes (o privados) del contenedor.

PHPStan Doctrine

A continuación instalaremos la librería phpstan-doctrine, para añadir una serie de comprobaciones extra que necesitaremos si estamos empleando este ORM:

composer require --dev phpstan/phpstan-doctrine

Para dejar 100% configurada esta extensión necesitamos realizar dos acciones más.

La primera de ellas es crear un archivo que permita a PHPStan recuperar el EntityManager y así poder comprobar tanto la sintaxis DQL que usemos como el valor de retorno de ciertos métodos mágicos. Este archivo podemos situarlo en la carpeta build/phpstan/doctrine-orm-bootstrap.php y tendrá el siguiente contenido:

<?php declare(strict_types = 1);use App\Kernel;require dirname(__DIR__) . '/../config/bootstrap.php';
$kernel = new Kernel($_SERVER['APP_ENV'], (bool) $_SERVER['APP_DEBUG']);
$kernel->boot();
return $kernel->getContainer()->get('doctrine')->getManager();

Para que PHPStan Doctrine emplee nuestro EntityManager añadiremos la siguiente línea en el archivo phpstan.neon :

Y, finalmente, de cara ayudar a PHPStan a identificar los métodos mágicos de nuestros repositorios (los famosos findOneBy* y findBy* ) añadiremos una última línea más al archivo phpstan.neon :

❗️ Desde la última versión de PHP es necesario añadir la siguiente línea en las anotaciones que encabezan nuestros repositorios para que PHPStan compruebe que cuando invocamos un método mágico del tipo findOneBy* ofindBy* la entidad asociada tiene esa propiedad:

@extends \Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository<EntityName>

Por ejemplo:

👉🏼 El contenido completo del archivo phpstan.neon lo tenéis disponible en este enlace.

Invocación de PHPStan

Para invocar PHPStan haremos lo mismo que con la librería EasyCodingStandard: añadir un script al archivo composer.json para poder invocarlo directamente desde línea de comandos:

"scripts": {
    ...
    "stan": [
        "vendor/bin/phpstan analyse --ansi --no-interaction"
    ],
}

A partir de este momento desde la raíz de nuestro proyecto podremos invocar composer stan y ver todos los errores que ha detectado.

Recuerda bajar el nivel si al principio te salen demasiados. Muchos de ellos están referidos a buenas prácticas y no urgirá corregirlos.

Conclusiones

Aunque PHP esté tendiendo cada vez más a ser un lenguaje tipado, este tipo de herramientas son un añadido muy interesante para realizar determinadas comprobaciones en nuestro código y vivir algo más tranquilos.

Además como has visto su instalación lleva muy poco tiempo por lo que te animo a que las pruebes y me cuentes los resultados!

¿Quieres recibir más artículos como este?

Si te ha gustado este artículo te animo a que te suscribas a la newsletter que envío cada domingo con publicaciones similares a esta y más contenido recomendado: 👇👇👇

Apóyame en Patreon

🧡🧡🧡 Gracias a: Joseba, Óscar, Alex, Jorge y Carolina.