5 Ganchos de Git Simples para Administrar Tu Repositorio

Git es una herramienta brillante. Te permite no solo rastrear tus cambios en un archivo a través de ganchos, sino también colaborar sin problemas con otras personas. En ese sentido, Git es una herramienta que impulsó el desarrollo de FOSS hacia adelante.

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

Nota: También puedes administrar Git en Emacs. ¡Descubre cómo!

Tabla de Contenidos

• ¿Qué Son los Ganchos de Git?
• 1. Prevenir el Push a Master
• 2. Rechazar Pushes a la Rama Master
• 3. Bloquear el Repositorio de Rebasing
• 4. Forzar una Verificación de Estilo y Sintaxis en Tu Código
• 5. Notificar Automáticamente a los Usuarios sobre Cambios en el Repositorio
• Preguntas Frecuentes

¿Qué Son los Ganchos de Git?

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

El subcomando de gancho funciona leyendo la carpeta “hooks” en el directorio “.git” de tu repositorio. Esta carpeta contiene una serie de archivos prehechos que proporcionan un script de muestra para cada acción en Git que puedes automatizar.

En su mayor parte, puedes escribir un gancho de git en cualquier lenguaje de scripting que desees. Esto lo hace increíblemente flexible y accesible para cualquier desarrollador de software.

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

1. Prevenir el Push a Master

Uno de los errores más comunes que un usuario comete en Git es hacer un push de un commit desde una rama de desarrollo directamente a master. Esto puede ser increíblemente frustrante si estás usando Github para rastrear y mantener tus proyectos.

Puedes prevenir este problema creando un gancho de Git “pre-push” que verificará y confirmará cada vez que intentes hacer un push de un repositorio desde la rama master.

1. Ve al repositorio de Git que deseas proteger.

1. Crea un archivo de gancho de Git con tu script de verificación. Dado que este es un gancho que debe ejecutarse antes de un “push”, necesitas crear un archivo de gancho “pre-push”:

touch .git/hooks/pre-push

1. Abre tu nuevo archivo de gancho en un editor de texto.

nano .git/hooks/pre-push

1. Dentro, escribe tu nuevo gancho “pre-push”. Por ejemplo, el siguiente es un script que pedirá tu confirmación cuando estés haciendo un push desde la rama master:

#!/bin/sh  

protect='master'  
current=$(git symbolic-ref HEAD |sed-e's,.*/\(.*\),\1,')  

if[$protect = $current]  
then  
read-p"¿Confirmar push a master? Y/n."-n1-r/dev/null  
then  
exit0  
fi  
exit1  
else  
exit0  
fi

1. Guarda tu nuevo gancho. En nano, haz esto presionando Ctrl + O, luego Ctrl + X.

1. Ejecuta el siguiente comando para asegurarte de que Git pueda ejecutar tu nuevo gancho.

chmod +x .git/hooks/pre-push

2. Rechazar Pushes a la Rama Master

Además de prevenir que tú mismo hagas un push a master, también puedes crear un gancho del lado del servidor que rechazará cualquier push a su rama master. Esto es increíblemente útil si compartes un repositorio con múltiples desarrolladores.

Soluciona esto creando un gancho “pre-receive” que automáticamente evitará que cualquier usuario restringido haga un push a la rama master.

1. Crea el archivo de gancho “pre-receive” en tu repositorio remoto.

touch .git/hooks/pre-receive

1. Abre este archivo.

nano .git/hooks/pre-receive

1. Agrega el script de rechazo en tu gancho “pre-receive”. Por ejemplo, las siguientes líneas de código deberían funcionar sin problemas:

#!/bin/sh  

branch=$(git symbolic-ref HEAD |sed-e's,.*/\(.*\),\1,')  

blacklist=(alice bob)  

if[[${blacklist[*]} =~ $USER]]; then  
if["$branch" == "master"]; then  
echo"No tienes permitido hacer cambios en esta rama"  
exit1  
fi  
fi

1. Guarda tu nuevo archivo de gancho. En mi caso, necesito presionar Ctrl + O, luego Ctrl + X para guardar el archivo.

2. Guarda tu script de gancho y hazlo ejecutable.

chmod +x .git/hooks/pre-receive

Consejo: también puedes usar alias de Git para hacer el uso de Git más eficiente.

3. Bloquear el Repositorio de Rebasing

Otro error común que un usuario comete en Git es hacer rebasing de la rama activa actualmente. Esto puede ser un problema frustrante si estás trabajando en un repositorio con múltiples colaboradores, ya que el rebasing eliminará los commits que otros usuarios han hecho.

Puedes prevenir este problema creando un gancho “pre-rebase” que verificará si la rama actual está bloqueada.

1. Crea un archivo “pre-rebase” en tu directorio “.git/hooks”:

touch .git/hooks/pre-rebase

1. Abre este archivo para editar.

nano .git/hooks/pre-rebase

1. Agrega el script de rebasing dentro de tu nuevo archivo de gancho.

#!/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"gancho pre-rebase: "$lock" está configurado como verdadero. Negándose a hacer rebasing."  
exit1  
fi

1. Guarda tu nuevo archivo de gancho y hazlo ejecutable.

chmod +x .git/hooks/pre-rebase

4. Forzar una Verificación de Estilo y Sintaxis en Tu Código

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

1. Para enlazar un linter a tu repositorio de Git, primero crea un archivo de gancho “pre-commit”.

touch .git/hooks/pre-commit

1. Instala el linter apropiado para el lenguaje de tu proyecto. En este caso, estoy usando “shellcheck” para analizar mi código Bash:

sudo apt install shellcheck

1. Abre tu nuevo archivo de gancho y agrega el siguiente script.

#!/bin/bash  
forfilein $(git diff--cached--name-only--diff-filter=AM |grep-E'\.sh$')  
do  
  shellcheck "$file"# Ejecuta el linter para cada nuevo archivo.  
if[$?-ne0]; then  
exit1# Termina el commit si el linter falla.  
fi  
done

1. Guarda tu nuevo archivo de gancho y hazlo ejecutable:

chmod +x .git/hooks/pre-commit

5. Notificar Automáticamente a los Usuarios sobre Cambios en el Repositorio

Por último, también puedes crear un gancho de Git que enviará automáticamente un correo electrónico cada vez que tu repositorio reciba un nuevo commit. Esto es útil si deseas crear un sistema de notificación simple para tu repositorio.

1. Crea un archivo de gancho “post-receive” en el directorio .git/hooks de tu repositorio:

touch .git/hooks/post-receive

1. Abre tu nuevo archivo de gancho de Git e ingresa el siguiente script:

#!/bin/sh  

commit_message=$(git log-1--pretty=%B)  
users=("[email protected]""[email protected]""[email protected]")  

for user in"${users[@]}"; do  
    mail -s"Nuevo Commit: $commit_message"$user

1. Guarda tu nuevo archivo de gancho y hazlo 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, puedes crear un nuevo gancho de Git usando Python o Shell, pero no C o C++.

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

Sí. Mientras que los ejemplos anteriores muestran ganchos como características únicas y discretas, puedes mezclarlos fácilmente para crear tu propio flujo de trabajo único, haciendo que los ganchos de Git sean increíblemente flexibles y adaptables para cualquier situación de codificación. Por ejemplo, puedes usar tanto el gancho “Prevenir Push a Master” como el gancho “Verificación de Sintaxis” en tu propio repositorio.

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

Este problema se debe probablemente a que tu servidor remoto no puede enviar correctamente ningún correo electrónico saliente. Para solucionar esto, asegúrate de que tu servidor remoto sea seguro y que tenga un agente de entrega de correo en funcionamiento junto con un dominio SMTP.

Crédito de la imagen: Unsplash. Todas las alteraciones y capturas de pantalla Ramces Red.