5 ganchos Git simples para administrar su repositorio

Git es una herramienta brillante. Le permite no solo realizar un seguimiento de sus cambios en un archivo a través de enlaces, sino también colaborar sin problemas con otras personas. En ese sentido, Git es una herramienta que impulsó el desarrollo de FOSS.

Sin embargo, uno de los mayores problemas con Git es que lleva tiempo y esfuerzo administrar sus repositorios. Por ejemplo, confirmar y sincronizar estos repositorios puede requerir de dos a tres comandos de git. Esto hace que administrarlos no solo sea tedioso sino también propenso a errores del usuario. Aquí le mostramos algunos ganchos de Git simples pero efectivos para administrar mejor sus repositorios.

Nota: yTambién puede administrar Git en Emacs. ¡Aprender cómo!

¿Qué son los ganchos Git?

En esencia, git-hook es un subcomando flexible que puede usar para crear scripts personalizados que se ejecutan cada vez que Git realiza una acción en un repositorio. Por ejemplo, es posible usar hook para verificar automáticamente su repositorio en busca de errores de estilo incluso antes de comprometerse con él.

Fuente de imagen: jslint

El subcomando hook funciona leyendo la carpeta «hooks» en el directorio «.git» de tu repositorio. Esta carpeta contiene una serie de archivos prefabricados que proporcionan un script de muestra para cada acción en Git que puede automatizar.

En su mayor parte, puede escribir un git hook en cualquier lenguaje de secuencias de comandos que desee. Esto lo hace increíblemente flexible y accesible para cualquier desarrollador de software.

Propina: para comenzar con Git, primero deberá configurar el nombre de usuario y el correo electrónico de Git. Descubre cómo en esta guía.

1. Evite presionar para dominar

Uno de los errores más comunes que comete un usuario en Git es enviar una confirmación desde una rama de desarrollo directamente al maestro. Esto puede ser increíblemente frustrante si usa Github para rastrear y mantener sus proyectos.

Puede evitar este problema creando un gancho de Git «pre-empujado» que verificará y confirmará cada vez que intente empujar un repositorio desde la rama maestra.

Vaya al repositorio de Git que desea proteger.

Cree un archivo de enlace de Git con su secuencia de comandos de verificación. Dado que este es un enlace que debe ejecutarse antes de un «empuje», debe crear un archivo de enlace «pre-empuje»:

touch .git/hooks/pre-push

Abra su nuevo archivo de enlace en un editor de texto.

nano .git/hooks/pre-push

En el interior, escriba su nuevo gancho «pre-empuje». Por ejemplo, el siguiente es un script que le pedirá confirmación cuando esté presionando desde la rama maestra:

#!/bin/sh
 
protect='master'
current=$(git symbolic-ref HEAD | sed -e 's,.*/(.*),1,')
 
if [ $protect = $current ]
then
    read -p "Confirm push to master? Y/n." -n 1 -r < /dev/tty
    echo
    if echo $REPLY | grep -E '^[Yy]$' > /dev/null
    then
        exit 0
    fi
    exit 1
else
    exit 0
fi

Guarde su nuevo gancho. En nano, haga esto presionando Ctrl + O, luego Ctrl + X.

Ejecute el siguiente comando para asegurarse de que Git pueda ejecutar su nuevo enlace.

chmod +x .git/hooks/pre-push

2. Rechazar empujones a la rama principal

Además de evitar empujar al maestro, también puede crear un gancho del lado del servidor que rechazará cualquier empuje a su rama maestra. Esto es increíblemente útil si comparte un repositorio con varios desarrolladores.

Solucione esto creando un gancho de «recepción previa» que evitará automáticamente que cualquier usuario restringido ingrese a la rama maestra.

Cree el archivo de gancho Git «pre-receive» en su repositorio remoto.

touch .git/hooks/pre-receive

Abra este archivo.

nano .git/hooks/pre-receive

Agregue el script de rechazo en su gancho de «pre-recepción». Por ejemplo, las siguientes líneas de código deberían funcionar de inmediato:

#!/bin/sh
 
branch=$(git symbolic-ref HEAD | sed -e 's,.*/(.*),1,')
 
blacklist=(alice bob)
 
if [[ ${blacklist[*]} =~ $USER ]]; then
    if [ "$branch" == "master" ]; then
        echo "You are not allowed commit changes in this branch"
        exit 1
    fi
fi

Guarde su nuevo archivo de gancho. En mi caso, necesito presionar Ctrl + O, luego Ctrl + X para guardar el archivo.

Guarde su script de gancho y hágalo ejecutable.

chmod +x .git/hooks/pre-receive

Propina: también puede usar el alias de Git para hacer que el uso de Git sea más eficiente.

3. Bloquee el repositorio para que no se vuelva a basar

Otro error común que comete un usuario en Git es cambiar la base de la rama actualmente activa. Esto puede ser un problema frustrante si está trabajando en un repositorio con varios colaboradores, ya que la reorganización eliminará las confirmaciones que hayan realizado otros usuarios.

Puede evitar este problema creando un gancho «pre-rebase» que verificará si la rama actual está bloqueada.

Cree un archivo «pre-rebase» en su directorio «.git/hooks»:

touch .git/hooks/pre-rebase

Abra este archivo para editarlo.

nano .git/hooks/pre-rebase

Agregue el script de rebase dentro de su nuevo archivo de enlace.

#!/bin/sh
 
branch="$2"
[ -n "$branch" ] || branch=$(git rev-parse --abbrev-ref HEAD)
lock="branch.${branch}.rebaselock"
 
if [ "$(git config --bool "$lock")" = true ]; then
echo "pre-rebase hook: "$lock" is set to true. Refusing to rebase."
exit 1
fi

Guarde su nuevo archivo de enlace y hágalo ejecutable.

chmod +x .git/hooks/pre-rebase

4. Forzar una verificación de estilo y sintaxis en su código

Uno de los usos más útiles de un gancho de Git es vincularlo con un filtro de código. Este es un programa simple que verifica si su código sigue el estilo y el formato de un proyecto.

Para vincular un linter a su repositorio de Git, primero cree un archivo de enlace «pre-commit».

touch .git/hooks/pre-commit

Instale el linter apropiado para el idioma de su proyecto. En este caso, estoy usando «shellcheck» para analizar mi código Bash:

sudo apt install shellcheck

Abra su nuevo archivo de enlace y agregue el siguiente script.

#!/bin/bash
for file in $(git diff --cached --name-only --diff-filter=AM | grep -E '.sh$')
do
 
  shellcheck "$file" # Run the linter for every new file.
 
  if [ $? -ne 0 ]; then
    exit 1 # Terminate the commit if the linter fails.
  fi
done

Guarde su nuevo archivo de enlace y hágalo ejecutable:

chmod +x .git/hooks/pre-commit

5. Notificar automáticamente a los usuarios con cambios en el repositorio

Por último, también puede crear un enlace de Git que enviará automáticamente un correo electrónico cada vez que su repositorio reciba una nueva confirmación. Esto es útil si desea crear un sistema de notificación simple para su repositorio.

Cree un archivo de enlace «posterior a la recepción» en el directorio .git/hooks de su repositorio:

touch .git/hooks/post-receive

Abra su nuevo archivo de gancho de Git e ingrese el siguiente script:

#!/bin/sh
 
commit_message=$(git log -1 --pretty=%B)
users=("alice@example.invalid" "bob@example.invalid" "mary@example.invalid")
 
for user in "${users[@]}"; do
    mail -s "New Commit: $commit_message" $user < /dev/null
    done

Guarde su nuevo archivo de enlace y hágalo ejecutable.

chmod +x .git/hooks/post-receive

Preguntas frecuentes

¿Puedo escribir mis ganchos de Git en un lenguaje compilado, como C?

Una de las mayores limitaciones de los ganchos de Git es que requiere que uses un lenguaje que puedas ejecutar directamente desde la terminal. Esto significa que los ganchos de Git no admiten ningún lenguaje compilado para sus scripts. Por ejemplo, puede crear un nuevo gancho Git utilizando Python o Shell, pero no C o C++.

¿Es posible ejecutar múltiples ganchos en el mismo repositorio de Git?

Sí. Si bien los ejemplos anteriores muestran los ganchos como características únicas y discretas, puede combinarlos fácilmente para crear su propio flujo de trabajo único, lo que hace que los ganchos de Git sean increíblemente flexibles y adaptables para cualquier situación de codificación. Por ejemplo, puede usar tanto el gancho de pre-empuje «Prevenir Push to Master» como el gancho de pre-compromiso «Comprobación de sintaxis» en su propio repositorio.

¿Por qué los ganchos Git de correo electrónico no envían un correo electrónico a los usuarios?

Lo más probable es que este problema se deba a que su servidor remoto no puede enviar correctamente ningún correo electrónico saliente. Para solucionar esto, asegúrese de que su servidor remoto sea seguro y que tenga un agente de entrega de correo en funcionamiento junto con un dominio SMTP.

Credito de imagen: Unsplash. Todas las alteraciones y capturas de pantalla Ramces Red.