¿Cómo usar Git Hooks?

Git se ha convertido en algo esencial para que los desarrolladores de software, los programadores y los ingenieros realicen un seguimiento de los cambios realizados en sus proyectos para una colaboración más eficiente.

Los Git Hooks (ganchos de Git) son una de las muchas características integradas de Git. Permiten a los usuarios automatizar acciones personalizadas cada vez que se produce un evento determinado.

Algunas de las ventajas de implementar Git Hooks son los flujos de trabajo de integración continua, el mantenimiento de una política de confirmaciones y la prevención de acciones que no cumplan con las normas definidas.

En este artículo, aprenderás más sobre qué son los Git Hooks y cómo utilizarlos tanto en el lado del cliente como en el del servidor. También proporcionaremos algunos ejemplos de Git Hooks para que los implementes en tu propio proyecto.

¿Qué es Git?

Antes de abordar el tema de cómo funcionan los Git Hooks y cómo usarlos, repasemos rápidamente qué es Git.

Git es una aplicación de control de versiones de código abierto. Con él, los usuarios pueden supervisar y hacer un seguimiento detallado del desarrollo del software. Puedes crear ramas de desarrollo, registrar los cambios y tener un control absoluto sobre las versiones de los archivos de tu proyecto.

Git es muy popular entre los desarrolladores de software, y la mayoría de los proyectos de código abierto lo utilizan.

¿Qué son los Git Hooks?

Los Git Hooks son scripts que se ejecutan automáticamente antes o después de ejecutar comandos Git como Commit y Push. Con los scripts de Git Hooks, los usuarios pueden personalizar el comportamiento interno de Git automatizando acciones específicas a nivel de programas y deployment.

Git incluye ejemplos de hooks en cualquier repositorio Git. Sin embargo, sitios como GitHub o GitLab no permiten su uso en primera instancia. Por ello, los Git Hooks se utilizan principalmente en instancias locales o privadas.

Ten en cuenta que el sistema debe tener permisos de ejecución para ejecutar un determinado hook o gancho.

Cómo usar los Git Hooks

Los Hooks se almacenan en la carpeta .git/hooks/ del directorio de cada proyecto. Con la función de directorios de plantillas de Git, los usuarios pueden instalarlos automáticamente. Siempre que uses “git init” o “git clone”, todos los archivos y directorios del directorio de plantillas se copiarán en el nuevo repositorio Git vacío.

En .git/hooks/ encontraremos una serie de hooks de ejemplo, tales como commit-msg.sample, post-update.sample, y pre-commit.sample, que son un buen punto de partida.

La instalación de los hooks implica crear un archivo ejecutable y guardarlo en el directorio .git/hooks/.

Cómo utilizar los Hooks locales

Los hooks locales o del lado del cliente se activan por eventos que se ejecutan en el ordenador local, como cuando confirmas o fusionas un proyecto.

En general, hay tres tipos de Hooks locales o del lado del cliente:

• Committing-workflow hooks. Son scripts de gancho relacionados con el proceso de confirmación – precommit, prepare-commit-msg, commit-msg, y post-commit.
• Email workflow hooks. Son scripts gancho para proyectos con un flujo de trabajo basado en el correo electrónico que utiliza el comando “git am”. Esto incluye applypatch-msg, pre-applypatch y post-applypatch.
• Otros. Incluyen otros scripts gancho locales como pre-rebase, post-reescritura, post-control, post-fusión, pre-empuje y pre-auto-gc.

Para instalar un git hook:

1. Abre el directorio .git/hooks/ de tu repositorio.
2. Busca el archivo de ejemplo del gancho que quieres utilizar.
3. Elimina “.sample” del nombre del archivo del hook. Por ejemplo, “pre-commit.sample” debe cambiarse por “pre-commit”.
4. Haz que el gancho sea ejecutable cambiando sus permisos mediante el siguiente comando Git: chmod +x [hook-name]
5. Elige qué lenguaje de scripting quieres utilizar para el hook. Eres libre de usar cualquier lenguaje de scripting, incluyendo Python, Bash o shell.
6. Abre el archivo hook en tu programa editor de código y define el lenguaje de scripting que hayas elegido. Incluye la ruta del intérprete en el comando.

Si quieres utilizar Python:

#!/usr/bin python

Si quieres utilizar Bash:

#!/bin/bash

Si quieres utilizar shell:

#!/bin/sh

7. Escribe la secuencia de comandos del hook en el lenguaje de programación elegido.

Ten en cuenta que para que un gancho se ejecute correctamente, el valor de salida debe ser 0. Para que falle, el valor de salida debe ser igual a 1. Si quieres incluir varias condiciones, deben estar presentes en el mismo archivo.

También es importante recordar que los scripts de hook no se comprueban en el control de versiones de Git por defecto. En otras palabras, no pueden ser confirmados. Si se elimina el directorio local de hooks, Git eliminará todos los hooks o ganchos y sus versiones anteriores del proyecto.

Como solución, puedes añadir un enlace simbólico al repositorio de Git. Como resultado, los scripts de hooks habilitados pueden ser confirmados en el control de versiones. A continuación te explicamos cómo hacerlo:

1. Crea un nuevo directorio Git llamado “hooks” en tu proyecto principal.
2. Copia y pega el archivo hook de .git/hooks/ en el nuevo directorio “hooks”. Si todavía es un archivo de muestra, hazlo ejecutable eliminando “.sample” del nombre del archivo.
3. Navega hasta .git/hooks/ y crea un nuevo archivo vacío con el mismo nombre.
4. Crea un nuevo enlace simbólico introduciendo el siguiente comando en Git:

ln -s -f ../hooks/[hook-name] .git/hooks/[hook-name]

Además, si por alguna razón quieres evitar un gancho activo, añade “-no-verify” al comando correspondiente. Por ejemplo, introduce el siguiente comando para omitir los ganchos de confirmación:

git commit --no-verify -m [commit message]

Uso de los Pre-Hooks

Un pre-hook se ejecuta antes de un evento en particular en el repositorio Git.

El hook de pre-commit, por ejemplo, puede utilizarse para aplicar una política de confirmación y evitar confirmaciones incorrectas. Si el gancho sale con un estado distinto de cero, Git lo abortará.

Aquí tienes algunos ejemplos de ganchos previos locales:

• pre-applypatch. Comprueba el estado del árbol de trabajo antes de confirmar los cambios. Se llama después de aplicar una nueva versión, pero antes de confirmar los cambios.
• pre-commit. Inspecciona el contenido de la confirmación, como el estilo del código o los espacios en blanco finales. Se ejecuta antes de que se escriba el mensaje de confirmación.
• pre-merge-commit. Llama a una confirmación de fusión automática invocada por “git merge”. Se llama después de la fusión, pero antes de obtener el archivo del mensaje de confirmación propuesto.
• pre-push. Válida un conjunto de actualizaciones de ref antes de que se produzca un push. Se ejecuta durante “git push” después de que las refs remotas se hayan actualizado, pero antes de que se transfieran los nuevos cambios.
• pre-rebase. Impide el rebasado de cualquier confirmación de Git que ya haya sido empujada. Se llama antes de que se produzca el “git rebase”.

Algunos de estos ganchos pueden parecer similares entre sí, como los scripts pre-push y pre-commit. Es importante saber qué gancho satisfará mejor tus necesidades.

El script pre-commit se ejecuta antes de que escribas un mensaje de confirmación, mientras que pre-push se ejecuta antes de que el nuevo contenido se suba a un repositorio remoto. Funcionan en diferentes puntos del ciclo del proyecto, pero puedes utilizar ambos para evitar confirmaciones y empujes incorrectos, asegurando un mejor flujo de trabajo.

Utilizar los post-ganchos

Git ejecuta un post-gancho después de que se produzca un determinado evento en el repositorio.

Los post-ganchos se utilizan a menudo para automatizar las respuestas a otras acciones, como el envío de correos electrónicos de notificación cuando se añade un nuevo commit de Git.

Estos son algunos ejemplos de post-ganchos locales:

• post-applypatch. Notifica a un grupo o al autor del parche después de aplicarlo. Se llama después de aplicar y confirmar una nueva versión.
• post-commit. Crea notificaciones después de que el proceso de confirmación haya terminado.
• post-checkout. Verifica las condiciones, muestra las diferencias y establece un directorio de trabajo adecuado para el entorno del proyecto. Se ejecuta después de que se complete un “git checkout” con éxito.
• post-merge. Guarda, aplica los permisos y restaura otros datos no rastreados en el árbol de trabajo. Se ejecuta después de un comando “git merge” exitoso.
• post-rewrite. Se puede utilizar de forma similar a los ganchos “post-checkout” y “post-merge”. Se ejecuta mediante comandos Git que reemplazan confirmaciones, como “git rebase”.

Cómo utilizar los ganchos del lado del servidor

Los scripts gancho del lado del servidor se ejecutan en repositorios o servidores remotos que reciben pushes de un equipo local. Pueden ejecutarse antes o después de los pushes del servidor. Los pre-hooks del lado del servidor, por ejemplo, pueden interrumpir cualquier Git push que salga con un mensaje distinto de cero.

Aquí tienes algunos ejemplos de hooks del lado del servidor:

• pre-receive. Enumera las referencias que se están enviando al repositorio remoto. Se puede utilizar para asegurar que ninguna de las referencias actualizadas sea no-rápida o para hacer un control de acceso de todas las refs y archivos que se modifican con el Git push.
• update. Tiene una finalidad similar a la de pre-recibir. La única diferencia es que la actualización se ejecuta una vez para cada rama, mientras que la pre-recepción puede ejecutarse una vez para varias ramas.
• post-receive.  Envía un correo electrónico a una lista, notifica a un servidor de integración continua o actualiza un sistema de seguimiento de tickets. Se ejecuta en el servidor remoto durante el empuje después de que se hayan actualizado todas las referencias.
• post-update.  Implementa las notificaciones para las referencias empujadas. Funciona de forma similar a la post-recepción, la única diferencia es que no recibe los valores de las referencias antiguas o nuevas. Se ejecuta una vez después de que todas las referencias hayan sido enviadas al servidor remoto.

Los pasos para instalar los ganchos del lado del servidor son los mismos que los del lado del cliente. La única diferencia es que debes colocar los scripts en el directorio .git/hooks situado en el servidor remoto en lugar de en el directorio local.

Ejemplos de Git Hooks

Existen muchos casos de uso para los scripts de hook. Echa un vistazo a los siguientes ejemplos.

Mostrar información sobre una acción commit

Este ejemplo muestra la información de una acción commit. Este hook se llama después de recibir el mensaje de confirmación por defecto y antes de que se abra el editor de mensajes de confirmación

Crea un archivo llamado prepare-commit-msg en la carpeta .git/hooks/ de tu repositorio. Luego, escribe el siguiente script:

#!/bin/sh

SOB=$(git config github.user)
grep -qs "^$SOB" "$1" || echo ". Cambio por @$SOB" >> "$1"

Luego, guárdalo. Y establece los permisos de ejecución para el archivo.

:~$ chmod +x prepare-commit-msg

Con este simple Hook, al realizar una acción commit, instantáneamente recibirás información relevante al respecto cuando se realice.

Generar documentación a medida que se cargan los cambios

Este Hook pre-push permite generar la documentación de tu código si cuentas con un generador. Cada vez que haces un cambio, la documentación se ejecutará automáticamente.

Crea un pre-push en la misma carpeta que antes y agrega el script:

#!/bin/bash

doxygen Doxyfile
git add docs/
git commit -m "Update documentation ($(date +%F@%R))"

Guarda el archivo y, finalmente, establece el permiso de ejecución.

:~$ chmod +x pre-push

Buscar y corregir espacios en blanco en commits

Este Git Hook tipo pre-commit es bastante simple de ejecutar. Crea un archivo llamado pre-commit y agrega lo siguiente:

#!/bin/bash -l
.git/hooks/pre-commit-master-no-no
if [[ $? == 1 ]]
then
exit 1
fi

.git/hooks/pre-commit-debugger
.git/hooks/pre-commit-trailing-spaces
.git/hooks/pre-commit-images
.git/hooks/pre-commit-pair

Ahora se encontrarán y corregirán los espacios en blanco en todos los commits.

Conclusión

Los Hooks permiten a los desarrolladores de software, programadores e ingenieros automatizar acciones personalizadas cada vez que se produce un evento específico en su repositorio Git.

En este tutorial, hemos explorado cómo utilizar hooks tanto locales como del lado del servidor para múltiples propósitos. También hemos ofrecido algunos ejemplos de Git Hooks y cómo instalarlos.

Esperamos que este artículo te haya ayudado a utilizar Git en todo su potencial. Si tienes alguna pregunta o consejo, no dudes en dejarlos en la sección de comentarios más abajo.