Git no solo es una herramienta poderosa para el control de versiones, sino que también ofrece una gran flexibilidad para automatizar tareas y personalizar el flujo de trabajo de un proyecto. Con la ayuda de aliases, hooks, integración con CI/CD, y archivos de configuración como .gitignore y .gitattributes, puedes hacer que tu experiencia con Git sea más eficiente y organizada.

Aliases en Git

Los aliases en Git permiten crear atajos personalizados para comandos de uso frecuente o combinaciones complejas de comandos. Esto no solo ahorra tiempo, sino que también hace que tu flujo de trabajo sea más fluido.

Crear un alias en Git

Puedes definir un alias con el comando git config. Los aliases se almacenan en el archivo de configuración de Git (.gitconfig) y pueden ser configurados a nivel global o local (por repositorio).

Uso:

1git config --global alias.<alias> "<comando>"

Ejemplos comunes de aliases:

Alias para git status:

1git config --global alias.st "status"

Ahora puedes ejecutar git st en lugar de git status.

Alias para git log --oneline --graph --decorate (ver un historial gráfico simplificado):

1git config --global alias.lg "log --oneline --graph --decorate --all"

Este alias te muestra un historial de commits en formato gráfico con una sola línea por commit.

Alias para añadir todos los archivos y hacer commit:

1git config --global alias.ac "!git add . && git commit -m"

Este alias permite añadir todos los archivos modificados y hacer commit con un solo comando.

Ver los aliases configurados:

Para ver los aliases configurados, puedes usar el comando:

1git config --global --get-regexp alias

Hooks de Git para automatizar tareas

Git hooks son scripts que se ejecutan automáticamente en ciertos eventos del ciclo de vida de Git, como antes o después de un commit, o cuando se empujan cambios al repositorio remoto. Los hooks permiten automatizar tareas repetitivas o críticas, como ejecutar pruebas, verificar estilo de código o impedir commits incorrectos.

Tipos de hooks

Hooks del lado del cliente: Se ejecutan en eventos locales, como commit, merge, o checkout.
Hooks del lado del servidor: Se ejecutan en eventos relacionados con un repositorio remoto, como pre-receive, update y post-receive.

Ejemplos de hooks comunes:

pre-commit: Se ejecuta antes de que un commit sea guardado. Puedes usarlo para verificar el estilo del código o correr pruebas automáticas.
- Ejemplo: Un pre-commit que ejecuta ESLint antes de cada commit:
  - Crear el archivo .git/hooks/pre-commit:
```
1#!/bin/sh
2npm run lint
```
- Asegúrate de que el script sea ejecutable:
```
1chmod +x .git/hooks/pre-commit
```
post-merge: Se ejecuta después de que una fusión (merge) ha tenido éxito. Puedes usarlo para realizar tareas como actualizar dependencias.
- Ejemplo: Un post-merge que ejecuta npm install:
```
1#!/bin/sh
2npm install
```

Crear hooks personalizados

Los hooks se almacenan en el directorio .git/hooks/. Puedes modificar los archivos de ejemplo o crear nuevos scripts para personalizar el comportamiento según tus necesidades.

Integración con CI/CD (GitHub Actions, GitLab CI)

La integración continua (CI) y la entrega continua (CD) son prácticas fundamentales en el desarrollo moderno de software. Con Git, puedes automatizar el proceso de construcción, prueba y despliegue de tu código utilizando herramientas como GitHub Actions y GitLab CI.

GitHub Actions:

GitHub Actions permite definir flujos de trabajo automáticos directamente en tu repositorio. Estos flujos se ejecutan en respuesta a eventos como commits o pull requests.

Crear un archivo de flujo de trabajo:

Los flujos de trabajo se definen en archivos .yml dentro del directorio .github/workflows/.

Ejemplo de un flujo de trabajo simple para ejecutar pruebas:

Crea el archivo .github/workflows/ci.yml:

1name: CI Workflow
2
3on:
4  push:
5    branches:
6      - main
7
8jobs:
9  test:
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v2
13      - name: Instalar dependencias
14        run: npm install
15      - name: Ejecutar pruebas
16        run: npm test

Este flujo se ejecuta cada vez que se empuja un cambio a la rama main. Realiza las siguientes tareas:

Clona el repositorio (checkout).
Instala las dependencias con npm install.
Ejecuta las pruebas con npm test.

GitLab CI:

GitLab CI usa un archivo llamado .gitlab-ci.yml para definir los pasos del flujo de trabajo.

Crear un archivo de configuración para GitLab CI:

Crea el archivo .gitlab-ci.yml en el directorio raíz del repositorio.

Ejemplo de configuración:

1stages:
2  - build
3  - test
4
5build_job:
6  stage: build
7  script:
8    - npm install
9
10test_job:
11  stage: test
12  script:
13    - npm test

Este archivo define dos etapas (stages): build y test. En la etapa build, se instalan las dependencias, y en la etapa test, se ejecutan las pruebas.

Uso de `.gitignore` para gestionar archivos no deseados

El archivo .gitignore es utilizado para indicarle a Git qué archivos o directorios no debe incluir en el control de versiones. Es útil para excluir archivos temporales, binarios o configuraciones locales que no deberían ser compartidos en el repositorio.

Ejemplo básico de `.gitignore`:

1# Ignorar archivos de sistema
2.DS_Store
3
4# Ignorar archivos compilados
5*.log
6*.o
7*.out
8
9# Ignorar directorio de dependencias de Node.js
10node_modules/
11
12# Ignorar archivos de configuración local
13.env

Ubicación del archivo `.gitignore`

El archivo .gitignore se coloca en el directorio raíz del proyecto.
Puedes tener varios .gitignore en diferentes subdirectorios si necesitas reglas más específicas.

Ignorar archivos ya versionados

Si deseas ignorar archivos que ya están siendo rastreados por Git, primero debes eliminarlos del seguimiento:

1git rm --cached <archivo>

Luego, añádelo a .gitignore para que no vuelva a ser rastreado en futuros commits.

Configuración de archivos `.gitattributes` para control de ficheros

El archivo .gitattributes permite definir cómo Git debe manejar archivos específicos dentro del repositorio. Se utiliza para controlar la normalización de los saltos de línea, el tratamiento de archivos binarios, la combinación automática y más.

Funciones principales de `.gitattributes`:

Control de saltos de línea (line endings):
- Puedes definir cómo Git debe manejar los saltos de línea (CRLF o LF) para diferentes archivos:
```
1*.txt text eol=lf
2*.bat text eol=crlf
```
Definir archivos binarios:
- Para evitar que Git intente hacer "diff" o fusiones en archivos binarios, puedes marcarlos como tales:
```
1*.jpg binary
2*.png binary
```
Fusionar archivos de forma personalizada:
- Puedes definir cómo deben ser fusionados ciertos archivos durante una fusión (merge). Por ejemplo, podrías preferir una estrategia de fusión manual para ciertos tipos de archivos:
```
1*.md merge=manual
```
Almacenamiento de archivos grandes con Git LFS:
- Si usas Git Large File Storage (LFS) para manejar archivos grandes, puedes configurarlo en .gitattributes:
```
1*.psd filter=lfs diff=lfs merge=lfs -text
```

Resumen

La automatización y personalización en Git te permite mejorar tu flujo de trabajo, hacer el control de versiones más eficiente, y automatizar tareas repetitivas. Aliases te ahorran tiempo al acortar comandos frecuentes, mientras que los hooks de Git te permiten ejecutar scripts automáticamente en eventos importantes. La integración con sistemas de CI/CD como GitHub Actions o GitLab CI automatiza pruebas y despliegues. Los archivos de configuración como .gitignore y .gitattributes son fundamentales para gestionar archivos no deseados y definir el comportamiento de Git sobre archivos específicos.

Curso git nivel medio