Cómo comprobar si un commit de Git ha sido revertido

Introducción

En este laboratorio, aprenderás cómo identificar si un commit de Git ha sido revertido. Exploraremos cómo usar el comando git log para encontrar commits de reversión y luego utilizaremos git show para verificar los detalles de estas reversiones. Finalmente, examinaremos los commits no revertidos para entender la diferencia en su historial y contenido. Este ejercicio práctico te guiará a través de la creación de un historial de proyecto de muestra, incluyendo un commit que luego se revierte, lo que te permitirá practicar las técnicas para identificar y verificar commits revertidos.

Skills Graph

Ejecutar git log para encontrar commits de reversión

En este paso, aprenderemos cómo usar git log para encontrar commits que han sido revertidos. Revertir un commit significa crear un nuevo commit que deshace los cambios introducidos por un commit anterior. Esto es útil cuando has cometido un error y quieres deshacerlo fácilmente sin perder el historial del commit original.

Primero, asegúrate de estar en el directorio de tu proyecto. Abre tu terminal y navega hasta el directorio my-time-machine:

cd ~/project/my-time-machine

Ahora, creemos algunos commits para simular un historial de proyecto, incluyendo un commit que luego revertiremos.

Crea el primer archivo:

echo "Initial content" > file1.txt
git add file1.txt
git commit -m "Add file1"

Deberías ver una salida similar a esta:

[master (root-commit) a1b2c3d] Add file1
 1 file changed, 1 insertion(+)
 create mode 100644 file1.txt

Ahora, agreguemos más contenido y hagamos otro commit:

echo "Adding more content" >> file1.txt
git add file1.txt
git commit -m "Add more content to file1"

Deberías ver una salida similar a esta:

[master 4e5f6g7] Add more content to file1
 1 file changed, 1 insertion(+)

A continuación, hagamos un commit que luego revertiremos:

echo "This commit will be reverted" > file2.txt
git add file2.txt
git commit -m "Add file2 (will be reverted)"

Deberías ver una salida similar a esta:

[master 8h9i0j1] Add file2 (will be reverted)
 1 file changed, 1 insertion(+)
 create mode 100644 file2.txt

Ahora, revertamos el último commit. Podemos usar git revert HEAD para revertir el commit más reciente:

git revert HEAD --no-edit

La bandera --no-edit le dice a Git que cree automáticamente el mensaje del commit de reversión sin abrir un editor. Deberías ver una salida similar a esta:

[master k2l3m4n] Revert "Add file2 (will be reverted)"
 1 file changed, 1 deletion(-)
 delete mode 100644 file2.txt

¡Genial! Ahora hemos creado un commit que revierte los cambios del commit "Add file2 (will be reverted)".

Ahora, usemos git log para ver nuestro historial de commits y encontrar el commit de reversión:

git log --oneline

Deberías ver una salida similar a esta:

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

Observa el mensaje del commit "Revert 'Add file2 (will be reverted)'". Esto indica claramente que este commit es una reversión de un commit anterior. Usar git log con la bandera --oneline es una forma rápida de ver un resumen de tu historial de commits e identificar los commits de reversión por su mensaje.

Usar git show para verificar la reversión

En este paso, usaremos el comando git show para examinar los detalles del commit de reversión y verificar que deshizo correctamente los cambios del commit original. El comando git show es una herramienta poderosa para inspeccionar objetos de Git, incluyendo commits, etiquetas (tags) y blobs.

Primero, asegúrate de estar en el directorio ~/project/my-time-machine:

cd ~/project/my-time-machine

Ahora, necesitamos el hash del commit de reversión. Puedes obtenerlo de la salida de git log --oneline del paso anterior. Es el primer commit que se lista. Por ejemplo, si la salida de tu git log --oneline fue:

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

El hash del commit de reversión es k2l3m4n. Nota: Tu hash de commit será diferente.

Ahora, usa git show seguido del hash del commit de reversión. Reemplaza YOUR_REVERT_COMMIT_HASH con el hash real de la salida de tu git log --oneline:

git show YOUR_REVERT_COMMIT_HASH

Por ejemplo, usando el hash de ejemplo k2l3m4n:

git show k2l3m4n

Deberías ver una salida similar a esta:

commit k2l3m4n (HEAD -> master)
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:05:00 2023 +0000

    Revert "Add file2 (will be reverted)"

    This reverts commit 8h9i0j1.

diff --git a/file2.txt b/file2.txt
deleted file mode 100644
index 8b1a99c..0000000
--- a/file2.txt
+++ /dev/null
@@ -1 +0,0 @@
-This commit will be reverted

Desglosemos esta salida:

• La primera parte muestra los detalles del commit: el hash del commit, el autor, la fecha y el mensaje del commit. Observa que el mensaje indica explícitamente que revierte un commit específico (identificado por su hash).
• La sección diff muestra los cambios introducidos por este commit. En este caso, muestra que file2.txt fue eliminado (deleted file mode 100644). Esto confirma que el commit de reversión deshizo con éxito la creación de file2.txt.

Usar git show te permite inspeccionar los cambios exactos introducidos por cualquier commit en tu historial. Esto es increíblemente útil para entender el historial de tu proyecto y verificar que las reversiones u otros cambios se aplicaron correctamente.

Probar commits no revertidos

En los pasos anteriores, creamos varios commits y luego revertimos uno de ellos. Usamos git log para ver el historial y git show para inspeccionar el commit de reversión. Ahora, verifiquemos que los commits que no fueron revertidos todavía existen y contienen los cambios esperados.

Primero, asegúrate de estar en el directorio ~/project/my-time-machine:

cd ~/project/my-time-machine

Recuerda nuestro historial de commits de git log --oneline:

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

Los commits "Add file1" y "Add more content to file1" no fueron revertidos. Usemos git show para inspeccionar el commit "Add more content to file1" y ver sus cambios.

Encuentra el hash del commit para "Add more content to file1" en la salida de tu git log --oneline. En el ejemplo anterior, es 4e5f6g7. Recuerda usar tu hash de commit real.

Ahora, usa git show con ese hash de commit:

git show YOUR_MORE_CONTENT_COMMIT_HASH

Por ejemplo, usando el hash de ejemplo 4e5f6g7:

git show 4e5f6g7

Deberías ver una salida similar a esta:

commit 4e5f6g7
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:02:00 2023 +0000

    Add more content to file1

diff --git a/file1.txt b/file1.txt
index 8b1a99c..a1b2c3d 100644
--- a/file1.txt
+++ b/file1.txt
@@ -1 +1,2 @@
 Initial content
+Adding more content

Esta salida muestra los detalles del commit y la sección diff indica claramente que se agregó una línea "Adding more content" a file1.txt. Esto confirma que este commit y sus cambios todavía forman parte del historial del proyecto, incluso si un commit posterior fue revertido.

Esto demuestra un aspecto clave de Git: revertir un commit crea un nuevo commit que deshace los cambios. No borra el commit original del historial. Esto es importante porque mantiene un registro completo de todos los cambios, lo que te permite entender la evolución completa de tu proyecto.

De manera similar, puedes usar git show con el hash del commit "Add file1" (a1b2c3d en el ejemplo) para ver la creación inicial de file1.txt.

Al usar git log para ver el historial y git show para inspeccionar commits individuales, puedes navegar y entender de manera efectiva la línea de tiempo de tu proyecto, incluso cuando se han revertido commits.

Resumen

En este laboratorio (lab), aprendimos cómo identificar commits revertidos en un repositorio de Git. Comenzamos creando un historial de proyecto con varios commits, incluyendo uno específicamente destinado a ser revertido. Luego, usamos el comando git revert HEAD --no-edit para crear un nuevo commit que deshace los cambios del commit anterior. Este proceso demostró cómo revertir un commit agrega un nuevo commit al historial en lugar de eliminar el original.

Continuaremos explorando cómo usar git log para encontrar estos commits de reversión y git show para verificar su contenido, distinguiéndolos de los commits no revertidos.