En un artículo de hace ya un tiempo, nuestro compañero Eduardo Riol nos hablaba de la Deuda Técnica y cómo reducirla a través de un ciclo automatizado.
Pues bien hoy vengo a hablaros de Codacy, una herramienta que nos ayuda al control de la Deuda Técnica y a mejorar la calidad y producción de nuestros equipos de desarrollo.

Bajo la premisa "Review less, merge faster" los creadores de Codacy nos proporcionan una plataforma de análisis automatizado de código, capaz de integrarse con múltiples repositorios y servicios como GitHub, Bitbucket, Slack o Jira, de forma que no solo nos permite ver la calidad de nuestros proyectos sino gestionar desde un único lugar las tareas a realizar para mejorar o solucionar incidencias detectadas por la herramienta.

Suena bien, ¿qué tal si lo probamos?

Para empezar, buscaremos un repositorio interesante para analizar: por ejemplo la librería de programación reactiva para Java RxJava. Hacemos un fork del repositorio en nuestro GitHub.

A continuación entramos en el marketplace de GitHub, buscamos Codacy (https://github.com/marketplace/codacy) e instalamos el plugin:

Ahora vamos a la web de Codacy (https://www.codacy.com/) y hacemos login con nuestra cuenta de GitHub, y en la siguiente pantalla podremos elegir qué repositorio queremos añadir o bien si deseamos importar otro repositorio ya sea desde Bitbucket u otro repositorio git:

Una vez seleccionado el repositorio podemos integrar servicios de comunicaciones o gestión de incidencias:

Listo, ¡ya tenemos nuestro repositorio integrado con Codacy! Por defecto, Codacy nos configura disparadores para realizar análisis automáticos si se realiza un commit o un pull request, por lo que a partir de aquí podemos empezar a utilizar Codacy sin preocuparnos de configurar nada más. Cómodo, ¿no?.

Una vez haya finalizado el análisis inicial se nos mostrará el siguiente panel de control:

El análisis inicial nos califica el proyecto y nos indica el número de incidencias encontradas agrupadas en "Error prone", "Code style" o "Unused code". A su vez, cada uno de los grupos se divide según su nivel de importancia: "info", "warning" y "error".

Como podemos ver en el panel de control, tambien existe una sección para comprobar el nivel de cobertura. Para ello debemos disponer de un generador de cobertura o coverage. En nuestro caso será JaCoCo, y descargarnos la herramienta para coverage que nos proporciona Codacy (https://github.com/codacy/codacy-coverage-reporter#setup).

Configurando Codacy

Aunque Codacy viene preparada para funcionar "out of the box" una vez integrada, también nos proporciona un buen número de parámetros a configurar de forma que nos permite adaptarnos a los distintos requerimientos técnicos de cada proyecto.

Por ejemplo, nos proporciona una buena base de patrones de código por defecto que además nos permite configurarlo según nuestras necesidades.

Al acceder al gestor de patrones seleccionamos qué conjunto de reglas queremos configurar o si preferimos utilizar un fichero de configuración que tenemos en el repositorio:

En cuanto a las reglas de las que disponemos, podemos seleccionarlas y ver por cada una de ellas la sección de detalles con una breve descripción y parámetros de configuración. Esto nos abre un gran abanico de posibilidades, ya que no solo indicamos qué métricas se van a verificar sino además como se verificarán. De esta forma tenemos una método muy efectivo de localizar errores que de otra forma las herramientas de análisis genéricas pueden dejar pasar:

Entre otras opciones, Codacy nos permite configurar la métrica a la hora analizar las incidencias que encuentra, de forma que nos permite ajustar los parámetros de análisis a los requerimientos del proyecto. De esta forma podemos controlar el código que se sube al repositorio ya que si se superan los umbrales definidos, Codacy nos informará que ese Pull request que acaba de hacer el compañero (o nosotros mismos) contiene errores que pueden hacer vulnerable el sistema completo:

Analizando los resultados

Codacy nos proporciona cuatro formas de visualizar el análisis de las incidencias:

• A través de Commits:

Como podemos apreciar en la imagen, disponemos de una lista de los commits realizados en una rama determinada, en donde se nos indica a traves de dos contadores el numero de nuevas incidencias encontradas y el numero de incidencias solucionadas en dicho commit.

Si seleccionamos un commit en concreto accederemos a los detalles del análisis. Al igual que con el repositorio completo, Codacy nos califica lo bien o mal que hemos realizado el commit según el número de incidencias que se han detectado o solucionado.

Dentro del análisis por commits tenemos varias secciones. De especial interés son la sección de "New Duplication" ya que nos permitirá ver qué código es el que se ha duplicado y qué ficheros están implicados:

Por otra parte la sección "Files" nos proporciona una lista de los ficheros que se han modificado junto con su calificación, número de incidencias encontradas y solucionadas, cantidad de complejidad añadida y la cobertura de la clase:

• A través de Ficheros:

Es similar a la sección "Files" del análisis de commits, salvo que en esta ocasión se realiza a nivel de rama. Se nos presenta una lista de archivos calificados según nuestra métrica. Esto es bastante útil, ya que podemos localizar cuales son los ficheros con peor puntuación y refactorizarlos.

Si seleccionamos un fichero se nos mostrará un resumen de las métricas analizadas, el tiempo aproximado para solucionar las incidencias de la clase y la opción de ignorar el fichero.

En cuanto a las incidencias, se nos presenta todo el código del fichero marcado por las incidencias o duplicación de código encontrados, de forma que podemos localizar rápidamente que partes del código deben ser refactorizado.

• Por incidencias:

De esta visualización de incidencias poco tenemos que añadir respecto a lo visto anteriormente. Se presenta una lista de todas las incidencias encontradas en la rama. Lo que si podemos destacar es la posibilidad de filtrar incidencias por una serie de opciones tales como lenguaje, categoría, nivel de incidencia, patrón o autor.

De esta forma podemos centrarnos en la solución de un tipo en concreto de problema que encontremos en nuestro proyecto, mejorar en una determinada categoría o incluso buscar todos los errores de esa persona que nos cae mal ;-).

En cuanto a las incidencias, al pulsar sobre cualquiera de ellas se nos mostrará los detalles de ésta, donde podemos revisar qué código es el que ha producido la incidencia, el tiempo aproximado de refactoring, una breve descripción de la incidencia, un ejemplo donde nos ilustran con el mismo problema y la solución a realizar y por ultimo el patrón relacionado con la incidencia:

Cabe destacar que disponemos de una serie de acciones a realizar según los servicios integrados que hayamos activado, por ejemplo podemos abrir una issue de la incidencia en GitHub o Jira.

• A través de Pull Request:

Para este ultimo caso hemos creado una rama, solucionado algunos de los problemas que nos ha reportado Codacy y por ultimo hemos creado un Pull request contra la rama base.

En cuanto creamos el pull request se activa un disparador que permite a Codacy saber que debe analizarla. Una vez finalizado este proceso, si todo ha ido bien, GitHub nos indicará que es seguro aceptar el pull request.

Por otra parte, podemos ver los detalles del análisis, esto es, calificación de los ficheros modificados, nuevas incidencias, incidencias resueltas, etc ...
Una vez aceptada la pull request se vuelve a analizar la rama base para comprobar de nuevo las métricas a nivel global.

En conclusión

Como hemos podido comprobar, Codacy nos proporciona una plataforma bastante interesante respecto a posibilidades ya que nos brinda un amplio abanico de servicios que integrar en nuestro proyecto para adaptarnos a los requisitos del cliente, y a su vez un potente producto listo para funcionar inmediatamente y prácticamente sin configuración alguna.

Para terminar y a modo de resumen vamos a repasar el post:

• Hemos visto brevemente qué es Codacy.
• Utilizando un repositorio de ejemplo, hemos integrado Codacy con nuestro GitHub.
• Repasamos los parámetros de configuración básicos.
• Hemos visto la posibilidades de análisis que nos proporciona la plataforma.
• Probamos algunos de los servicios integrados como los disparadores de Pull Request de GitHub o la gestión de incidencias.

Dicho esto finalizamos el post, espero que os haya parecido interesante y no dudéis en dejar vuestras impresiones en los comentarios o en nuestro Twitter.