Fusión de ramas

Una vez que has desarrollado y probado una nueva característica o corrección en una rama separada, el siguiente paso es integrar esos cambios de vuelta a la rama principal o a otra rama de desarrollo. Este proceso se conoce como "fusión" (merge) y es una operación fundamental en Git.

¿Qué es la fusión de ramas?

La fusión es el proceso de combinar los cambios de una rama con otra. Cuando fusionas una rama (por ejemplo, feature) en otra (por ejemplo, main), Git intenta combinar automáticamente todos los cambios realizados en la rama feature con el contenido actual de main.

El comando git merge

El comando básico para fusionar una rama en tu rama actual es:

git merge nombre-de-rama-a-fusionar

Por ejemplo, para fusionar una rama de característica en la rama principal:

# Primero, asegúrate de estar en la rama de destino (donde quieres integrar los cambios)
git checkout main

# Luego, fusiona la rama de característica
git merge feature/nueva-funcionalidad

Tipos de fusiones

Git realiza diferentes tipos de fusiones dependiendo del estado de las ramas involucradas:

1. Fusión Fast-Forward

Cuando no hay commits nuevos en la rama de destino desde que se creó la rama que quieres fusionar, Git simplemente mueve el puntero de la rama de destino hacia adelante. Esto se conoce como "fast-forward" (avance rápido).

Antes:
main:     A---B---C
                  \
feature:           D---E

Después:
main:     A---B---C---D---E
                      ^
feature:              |

2. Fusión recursiva (o de tres vías)

Cuando ambas ramas tienen commits nuevos desde su punto común de divergencia, Git crea un nuevo commit de fusión que combina los cambios de ambas ramas.

Antes:
main:     A---B---C---F
              \
feature:       D---E

Después:
main:     A---B---C---F---G (commit de fusión)
              \         /
feature:       D---E---/

Opciones comunes de git merge

Fusión con mensaje personalizado

git merge nombre-de-rama -m "Mensaje para el commit de fusión"

Fusión sin fast-forward

Fuerza la creación de un commit de fusión incluso cuando podría hacerse un fast-forward:

git merge --no-ff nombre-de-rama

Esto es útil para mantener un registro explícito de cuándo se fusionó una característica.

Fusión solo fast-forward

Rechaza la fusión si no se puede hacer un fast-forward:

git merge --ff-only nombre-de-rama

Fusión en modo squash

Combina todos los commits de la rama a fusionar en un solo commit:

git merge --squash nombre-de-rama
git commit -m "Implementa característica X"

Esto es útil cuando quieres mantener un historial limpio, especialmente si la rama tiene muchos commits pequeños o de "trabajo en progreso".

Conflictos de fusión

A veces, Git no puede fusionar automáticamente los cambios porque hay modificaciones conflictivas en las mismas partes de los mismos archivos. Esto se conoce como "conflicto de fusión".

Identificar conflictos

Cuando ocurre un conflicto, Git mostrará un mensaje como:

Auto-merging archivo.txt
CONFLICT (content): Merge conflict in archivo.txt
Automatic merge failed; fix conflicts and then commit the result.

Estructura de un archivo con conflictos

Git marca las áreas conflictivas en los archivos:

<<<<<<< HEAD
Contenido de la rama actual (destino)
=======
Contenido de la rama que estás fusionando
>>>>>>> feature/nueva-funcionalidad

Resolver conflictos

Para resolver un conflicto:

1. Abre los archivos con conflictos y edítalos para elegir qué cambios mantener.
2. Elimina los marcadores de conflicto (<<<<<<<, =======, >>>>>>>).
3. Guarda los archivos.
4. Añade los archivos resueltos al área de preparación:

   git add archivo-con-conflicto.txt
   

5. Completa la fusión creando un commit:

   git commit
   

   Git abrirá un editor con un mensaje predeterminado para el commit de fusión.

Herramientas para resolver conflictos

Git ofrece herramientas para ayudar a resolver conflictos:

git mergetool

Este comando abrirá la herramienta de fusión configurada (como vimdiff, kdiff3, meld, etc.).

También puedes usar editores modernos como VS Code, que tienen soporte integrado para resolver conflictos de Git.

Estrategias alternativas de fusión

Rebase en lugar de merge

Una alternativa a la fusión es el "rebase", que reescribe el historial para crear una línea de tiempo lineal:

# En lugar de fusionar main en tu rama de característica
git checkout feature/nueva-funcionalidad
git rebase main

# Luego, cuando estés listo para integrar en main
git checkout main
git merge feature/nueva-funcionalidad  # Ahora será un fast-forward

Ventajas del rebase:

• Historial más limpio y lineal
• Evita commits de fusión innecesarios

Desventajas:

• Reescribe el historial (no usar en ramas compartidas/publicadas)
• Los conflictos pueden ser más difíciles de manejar

Cherry-pick

Si solo quieres aplicar commits específicos de otra rama:

git cherry-pick hash-del-commit

Buenas prácticas para fusiones

1. Mantén las ramas actualizadas

Sincroniza regularmente tu rama de característica con la rama principal para reducir la probabilidad de conflictos grandes:

git checkout feature/nueva-funcionalidad
git merge main
# o
git rebase main

2. Haz fusiones pequeñas y frecuentes

Es más fácil manejar fusiones pequeñas y frecuentes que una gran fusión al final del desarrollo.

3. Prueba antes y después de fusionar

Asegúrate de que tu código funciona correctamente antes de fusionar y vuelve a probarlo después de la fusión.

4. Usa mensajes de commit descriptivos

Escribe mensajes de commit claros que expliquen qué se está fusionando y por qué.

5. Revisa los cambios antes de fusionar

Usa git diff para revisar los cambios que se fusionarán:

git diff main...feature/nueva-funcionalidad

6. Considera la estrategia de fusión adecuada

Elige entre merge regular, --no-ff, --squash o rebase según las necesidades del proyecto y el flujo de trabajo del equipo.

Flujos de trabajo comunes

Fusión de una rama de característica

# Asegúrate de que tu rama de característica está actualizada
git checkout feature/nueva-funcionalidad
git pull origin main  # O rebase: git rebase main

# Prueba que todo funciona correctamente

# Fusiona en la rama principal
git checkout main
git pull  # Asegúrate de tener la última versión
git merge feature/nueva-funcionalidad

# Envía los cambios al repositorio remoto
git push

Fusión con squash para características complejas

git checkout main
git merge --squash feature/compleja
git commit -m "Implementa característica compleja"

Flujo de trabajo con pull requests

En plataformas como GitHub, GitLab o Bitbucket:

1. Desarrolla en una rama de característica
2. Crea un pull request/merge request
3. Revisa el código y discute los cambios
4. Fusiona a través de la interfaz web o localmente

Solución de problemas comunes

Abortar una fusión

Si encuentras demasiados conflictos o problemas durante una fusión:

git merge --abort

Esto restaurará tu rama al estado anterior a la fusión.

"Already up to date"

Problema: Git dice que la rama ya está actualizada cuando intentas fusionar.

Solución: Verifica que estás en la rama correcta y que ambas ramas tienen los cambios esperados.

Conflictos recurrentes

Problema: Los mismos archivos siempre entran en conflicto.

Solución:

• Mejora la organización del código para reducir superposiciones
• Coordina mejor con otros desarrolladores
• Considera usar herramientas como git-rerere para recordar resoluciones de conflictos

Conclusión

La fusión de ramas es una operación fundamental en Git que permite integrar cambios de diferentes líneas de desarrollo. Dominar las diferentes estrategias de fusión y saber cómo manejar conflictos eficientemente te permitirá mantener un flujo de trabajo productivo y un historial de proyecto limpio y comprensible.

Recuerda que no hay una única "forma correcta" de fusionar ramas. La mejor estrategia depende del flujo de trabajo de tu equipo, la naturaleza del proyecto y tus preferencias personales en cuanto a la organización del historial de commits.