En la práctica de Git de Implantación de Aplicaciones Web había un ejercicio pensado para que algo saliera mal: crear dos ramas desde la principal, cambiar en las dos el mismo título <h1> de un archivo HTML y fusionarlas después. La primera fusión entró sin problemas. La segunda se paró con esto:
$ git merge rama2
Auto-fusionando Prueba.html
CONFLICTO (contenido): Conflicto de fusión en Prueba.html
Fusión automática falló; arregle los conflictos y luego realice un commit con el resultado.
Vamos a ver por qué una fusión entra sola y la otra no, y qué hacer cuando Git se para así.
El escenario
Partía de un repositorio con un único commit (“Initial Commit”) en la rama main, con un Prueba.html sencillo. Desde ahí:
- Creé dos ramas a la vez desde ese mismo commit:
git branch rama1ygit branch rama2. - En
rama1cambié el texto del<h1>e hice commit (“Updated Main File”). - En
rama2cambié ese mismo<h1>con otro texto y, además, añadí una etiqueta<meta>en la cabecera (“Added Metadata to Main File”). - Volví a
mainy fusioné primerorama1y despuésrama2.
Primera fusión: fast-forward
$ git merge rama1
Actualizando be1b97b..cfed4c0
Fast-forward
Prueba.html | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
“Fast-forward” significa que Git no ha tenido que mezclar nada. Desde que rama1 salió de main, main no había cambiado: rama1 era simplemente main con un commit más. Así que Git se limita a mover el puntero de main hasta el último commit de rama1. No hay dos versiones distintas que comparar, así que no puede haber conflicto.
Segunda fusión: el conflicto
Con rama2 la situación cambia. main ya no está donde estaba cuando nació rama2: ha avanzado con el commit de rama1. Ahora Git tiene que hacer una fusión de verdad, comparando tres versiones del archivo:
- La base común: el “Initial Commit”, del que salieron las dos ramas.
- Lo que hay en
main: el<h1>derama1. - Lo que trae
rama2: su propio<h1>y la<meta>nueva.
Para cada zona del archivo, Git mira quién la ha cambiado respecto a la base:
- La
<meta>solo la tocórama2. No hay nada que decidir: Git la incorpora sola. - El
<h1>lo cambiaron las dos ramas, cada una a su manera. Git no tiene forma de saber cuál es el bueno, y en lugar de elegir por ti, se para y te deja decidir a ti.
Es lo que expliqué en la práctica: Git fusiona por zonas del archivo, y si dos ramas que salen del mismo commit cambian la misma línea, el conflicto está asegurado. Un matiz importante: también suele chocar si los cambios están en líneas pegadas, aunque no sean exactamente la misma.
Qué ves dentro del archivo
Durante el conflicto, git status marca el archivo como “ambos modificados”. Si lo abres, verás que Git ha escrito dentro las dos versiones separadas por unos marcadores. Esta parte nos la explicó el profesor en clase y es la clave de todo. Con los textos de cada rama, se ve así:
<<<<<<< HEAD
<h1>Texto que puso rama1</h1>
=======
<h1>Texto que puso rama2</h1>
>>>>>>> rama2
- Entre
<<<<<<< HEADy=======está la versión de la rama en la que estás (main, que ya incluía lo derama1). - Entre
=======y>>>>>>> rama2está la versión que intentas traer.
Cómo lo resolví
Resolver un conflicto consiste en editar el archivo para dejarlo como debe quedar y decirle a Git que ya está:
- Abrir el archivo con cualquier editor. Yo usé
nano. - Dejar el contenido final. Puedes quedarte con una versión, con la otra o escribir una tercera. Yo dejé un
<h1>nuevo: “Título H1 corregido del conflicto”. - Borrar los tres marcadores (
<<<<<<<,=======y>>>>>>>). Si se te olvida alguno, acabará publicado tal cual en tu web. - Marcar el archivo como resuelto y hacer el commit de fusión:
$ git add Prueba.html
$ git commit -m "Merge rama2: resolved h1 conflict"
[main 8198752] Merge rama2: resolved h1 conflict
Después, cat Prueba.html mostraba el <h1> corregido y también la <meta> de rama2, que había entrado sola. git status ya decía que no había nada para hacer commit y que el árbol de trabajo estaba limpio.
Si en mitad de un conflicto prefieres no seguir, git merge --abort deshace la fusión y deja todo como estaba antes del git merge.
Comprobar el resultado en el historial
Para ver de un vistazo lo que ha pasado, git log --oneline --graph dibuja el historial como un árbol en la propia terminal. Después de las dos fusiones se ve la bifurcación: la línea de rama2 se separa en el “Initial Commit” y vuelve a unirse a main en el commit de fusión, que es el único con dos commits padre. La fusión de rama1, en cambio, no deja rastro propio: al ser un fast-forward, su commit queda en línea recta, como si se hubiera hecho directamente en main.
Cómo tener menos conflictos
- Fusiona a menudo. Cuanto más tiempo vive una rama separada, más probable es que alguien toque lo mismo que tú.
- Haz commits pequeños y con un solo propósito. Si un commit cambia veinte cosas, el conflicto mezclará veinte cosas.
- Antes de fusionar, mira qué va a cambiar con
git diff main rama2.
Los conflictos no son errores: son Git negándose a adivinar. Y si tu repositorio está recién clonado, antes de llegar a fusionar ramas puede que te encuentres otro aviso que despista bastante: qué significa «upstream ha desaparecido» en Git.
Pon a prueba lo que has entendido
Creas rama1 desde main, haces un commit en rama1 y vuelves a main sin haber cambiado nada en ella. ¿Qué pasa al ejecutar git merge rama1?
Resumen rápido
Si la rama principal no ha avanzado, git merge hace un fast-forward y no puede haber conflicto. Si las dos ramas han avanzado, Git compara tres versiones (base, la tuya y la que entra) y fusiona sola cada zona que solo cambió una de ellas. Cuando las dos cambian la misma línea, se para con “CONFLICTO (contenido)”: editas el archivo, eliges cómo queda, borras los marcadores y terminas con git add y git commit.