Resolución de conflictos de fusión

¿Qué es un conflicto de fusión?

Cuando trabajas en equipo con Git, es común que varias personas modifiquen los mismos archivos simultáneamente. Git es muy inteligente combinando cambios, pero hay situaciones donde no puede hacerlo automáticamente. Estas situaciones se denominan conflictos de fusión (merge conflicts).

Imagina que tú y tu compañero están trabajando en el mismo archivo. Tú modificas la línea 5 y tu compañero modifica exactamente la misma línea pero con contenido diferente. Cuando intentas fusionar vuestras ramas, Git no sabe cuál de los dos cambios debe prevalecer. Aquí es donde tú, como desarrollador, debes intervenir.

¿Por qué ocurren los conflictos?

Los conflictos de fusión ocurren por varias razones:

1. Ediciones en la misma línea: Dos personas modifican exactamente la misma línea de un archivo.
2. Eliminación vs. modificación: Alguien elimina un archivo mientras otro lo modifica.
3. Archivos modificados en ambas ramas: El mismo archivo se editó en ambas ramas sin relación entre los cambios.
4. Cambios en archivos renombrados: Un archivo se renombra en una rama y se modifica en otra.

Identificando un conflicto de fusión

Cuando intentas fusionar ramas y Git detecta conflictos, te lo notificará inmediatamente. Veamos el proceso paso a paso:

1. Inicias la fusión: Ejecutas git merge o git pull
2. Git detecta el problema: Verás un mensaje de error indicando conflictos
3. Revisas el estado: Ejecutas git status para ver los archivos en conflicto

Cuando Git no puede fusionar automáticamente, verás un mensaje como este:

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

Entendiendo las marcas de conflicto

Cuando abres un archivo en conflicto, verás algo similar a esto:

<<<<<<< HEAD
const nombre = 'María García';
=======
const nombre = 'María';
>>>>>>> feature/nueva-funcion

Cada sección tiene un significado importante:

Estrategias para resolver conflictos

Tienes varias opciones cuando te enfrentas a un conflicto:

1. Aceptar los cambios de la otra rama

Si decides que los cambios de la rama entrante son los correctos, puedes mantener solo esos:

git checkout --theirs archivo.js
git add archivo.js

2. Aceptar tus cambios actuales

Si tus cambios deben prevalecer:

git checkout --ours archivo.js
git add archivo.js

3. Resolver manualmente

Esta es la opción más común. Editas el archivo y decides qué va en cada sección:

1. Abre el archivo en tu editor de código
2. Revisa ambos bloques de código
3. Elimina las tres líneas de marca (<<<<<<<, =======, >>>>>>>)
4. Mantén el código que debe quedar o combina ambos cambios según sea necesario
5. Guarda el archivo
6. Ejecuta git add archivo.js

Usando herramientas visuales

Aunque puedes resolver conflictos editando texto, las herramientas visuales hacen el proceso mucho más sencillo:

• VS Code: Tiene un sistema de resolución de conflictos integrado con opciones para aceptar uno u otro cambio.
• GitHub Desktop: Muestra los conflictos de forma visual comparando ambos lados.
• Meld: Herramienta gratuita de comparación visual para múltiples sistemas operativos.
• Beyond Compare: Editor profesional con detección de conflictos de Git.

git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'
git config --global mergetool.prompt false

Completando la resolución

Una vez que has resuelto todos los conflictos en un archivo:

1. Ejecuta git add nombre-archivo para marcar el archivo como resuelto
2. Repite para cada archivo en conflicto
3. Ejecuta git status para verificar que no quedan conflictos pendientes
4. Finaliza con git commit para completar la fusión

Abortando una fusión

Si te encuentras perdido y prefieres empezar de nuevo, puedes abortar la fusión:

git merge --abort

Esto revertirá todo al estado anterior al intento de fusión. Es útil cuando te has confundido o decides que la fusión no era necesaria en este momento.

Prevención de conflictos

La mejor estrategia contra los conflictos es evitarlos en la medida de lo posible:

1. Comunica con tu equipo: Informa qué archivos estás modificando antes de comenzar.
2. Haz pull frecuentemente: Mantén tu rama actualizada con los últimos cambios de la rama principal.
3. Trabaja en módulos separados: Asigna diferentes archivos o funcionalidades a diferentes desarrolladores.
4. Realiza integraciones frecuentes: No dejes pasar mucho tiempo entre integraciones.
5. Usa ramas de corta duración: Cuanto más tiempo exista una rama, mayor probabilidad de conflictos.

«Los conflictos de fusión son como las reuniones de equipo: incómodos cuando son grandes y frecuentes, pero necesarios y manejables cuando se hacen correctamente.»

Conflictos en pull requests

Cuando trabajas con pull requests en GitHub o GitLab, puedes encontrarte con conflictos antes de poder fusionar. GitHub te mostrará qué archivos tienen conflictos y te permitirá resolverlos de dos formas:

1. Desde la interfaz web: GitHub permite editar directamente en el navegador.
2. Actualizando tu rama: Haz merge de la rama base en tu rama de trabajo y resuelve localmente.

Comandos útiles para conflictos

Ejemplo práctico completo

Veamos un ejemplo real paso a paso:

# Estás en la rama develop
# Intentas fusionar la rama feature/login
git merge feature/login

# Git reporta conflicto:
# Auto-merging src/auth.js
# CONFLICT (content): Merge conflict in src/auth.js
# Automatic merge failed.

Ahora revisas el archivo:

// src/auth.js
function validarUsuario(datos) {
    <<<<<<< HEAD
    if (datos.email.includes('@')) {
        return true;
    }
    =======
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(datos.email);
    >>>>>>> feature/login
}

Decides que la validación con expresión regular es mejor, así que editas:

// src/auth.js
function validarUsuario(datos) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(datos.email);
}

Luego completas el proceso:

git add src/auth.js
git commit -m "Merge feature/login: usando validación robusta de email"
# La fusión está completa

Conclusión

Los conflictos de fusión son parte natural del trabajo en equipo con Git. Ahora que comprendes cómo ocurren, cómo identificarlos y cómo resolverlos, estás mejor preparado para colaborar efectivamente con otros desarrolladores. Recuerda: los conflictos no son fracasos, son oportunidades para revisar y mejorar el código junto con tu equipo.