Cómo resolver conflictos durante una operación de Git rebase

Introducción

Git rebase es una herramienta poderosa para gestionar tu base de código, pero a veces puede generar conflictos que deben resolverse. Este tutorial te guiará a través del proceso de identificación y resolución de conflictos durante una operación de Git rebase, ayudándote a mantener un historial de Git limpio y organizado.

Skills Graph

Comprender Git Rebase

Git rebase es una función poderosa en el sistema de control de versiones Git que te permite integrar cambios de una rama a otra. A menudo se utiliza para mantener una rama de función (feature branch) actualizada con la rama principal (main branch), o para limpiar el historial de confirmaciones (commit history) combinando o reordenando las confirmaciones.

¿Qué es Git Rebase?

Git rebase es el proceso de tomar una serie de confirmaciones de una rama y "reproducirlas" encima de otra rama. Esto efectivamente mueve la base de la rama a una nueva confirmación, mientras se preservan los cambios introducidos por las confirmaciones originales.

¿Por qué usar Git Rebase?

Hay varias razones por las que podrías querer usar Git rebase:

1. Mantener una rama de función actualizada: Cuando trabajas en una rama de función, la rama principal puede haber avanzado mientras tú trabajabas. Rebasando tu rama de función encima de la rama principal, se asegura de que tus cambios se integren con las últimas actualizaciones.

2. Limpiar el historial de confirmaciones: Rebase se puede utilizar para combinar o reordenar confirmaciones, lo que hace que el historial de confirmaciones sea más conciso y fácil de entender.

3. Integrar cambios: Rebase se puede utilizar para integrar cambios de una rama a otra, efectivamente fusionando las dos ramas sin crear una confirmación de fusión (merge commit).

Cómo realizar un Git Rebase

Para realizar un Git rebase, puedes usar el siguiente comando:

git rebase <base-branch>

Reemplaza <base-branch> con el nombre de la rama sobre la cual quieres rebasar tu rama actual. Por ejemplo, si estás trabajando en una rama de función y quieres rebasarla sobre la rama main, usarías:

git rebase main

Esto iniciará el proceso de rebase, durante el cual es posible que encuentres conflictos que deben resolverse.

Identificación y resolución de conflictos

Durante una operación de Git rebase, pueden surgir conflictos cuando los cambios que has realizado en tu rama entran en conflicto con los cambios realizados en la rama base. Identificar y resolver estos conflictos es un paso crucial en el proceso de rebase.

Identificación de conflictos

Cuando se produce un conflicto durante un rebase, Git pausará el proceso de rebase y marcará los archivos en conflicto en tu directorio de trabajo. Puedes identificar estos archivos ejecutando el siguiente comando:

git status

Esto mostrará una lista de los archivos en conflicto, que se marcarán con el estado unmerged (no fusionado).

Resolución de conflictos

Para resolver los conflictos, debes editar manualmente los archivos en conflicto y elegir qué cambios mantener. Git marcará las secciones en conflicto con los siguientes marcadores:

<<<<<<< HEAD
## Your changes
=======
## Changes from the base branch
>>>>>>> base-branch

Debes eliminar estos marcadores y elegir los cambios que deseas mantener. Una vez que hayas resuelto los conflictos, puedes preparar los cambios (stage) utilizando el siguiente comando:

git add <conflicting-file>

Después de resolver todos los conflictos, puedes continuar el proceso de rebase con el siguiente comando:

git rebase --continue

Esto reanudará la operación de rebase y aplicará las confirmaciones (commits) restantes.

Abortar un rebase

Si no eres capaz de resolver los conflictos o decides abandonar el proceso de rebase, puedes abortar el rebase con el siguiente comando:

git rebase --abort

Esto devolverá tu rama a su estado antes de que comenzara el rebase.

Completar el proceso de rebase

Después de resolver cualquier conflicto que pueda haber surgido durante el rebase, puedes completar el proceso de rebase y enviar tus cambios al repositorio remoto.

Revisar el rebase

Antes de finalizar el rebase, es una buena idea revisar los cambios que se han realizado en tu rama. Puedes hacer esto ejecutando el siguiente comando:

git log --oneline

Esto mostrará el historial de confirmaciones (commits) de tu rama, incluyendo los cambios que se aplicaron durante el rebase.

Enviar el rebase

Una vez que estés satisfecho con los cambios, puedes enviar tu rebase al repositorio remoto. Sin embargo, dado que el rebase ha cambiado el historial de confirmaciones, tendrás que forzar el envío de tus cambios utilizando el siguiente comando:

git push --force-with-lease

La opción --force-with-lease asegura que no sobrescribas accidentalmente ningún cambio que se haya realizado en la rama remota desde tu última extracción (pull).

Actualizar la rama remota

Después de enviar tu rebase, la rama remota se actualizará con tus cambios. Si estás trabajando en una rama compartida, debes notificar a tus compañeros de equipo que la rama ha sido rebasada, ya que es posible que necesiten actualizar sus copias locales de la rama.

Limpiar el rebase

Si has completado el rebase y enviado tus cambios al repositorio remoto, es posible que desees limpiar tu rama local eliminando la rama original y creando una nueva rama basada en el historial de confirmaciones rebasado. Esto se puede hacer con los siguientes comandos:

git checkout main
git branch -d feature-branch
git checkout -b new-feature-branch

Esto te devolverá a la rama main, eliminará la rama original feature-branch y creará una nueva rama new-feature-branch basada en el historial de confirmaciones rebasado.

Resumen

Al final de este tutorial, tendrás una comprensión sólida de cómo manejar los conflictos que pueden surgir durante una operación de Git rebase. Aprenderás los pasos para identificar y resolver estos conflictos, asegurando un proceso de rebase exitoso y manteniendo un repositorio de Git bien estructurado.