Cómo comprobar si un commit de Git está vacío

Introducción

En este laboratorio, exploraremos cómo determinar si un commit de Git está vacío, es decir, si no introduce cambios en los archivos del proyecto. Aprenderemos a utilizar el comando git show para inspeccionar los detalles y los cambios dentro de un commit específico, lo que nos proporcionará una representación visual de su contenido.

Además, profundizaremos en el uso del comando git diff-tree, un método más directo para comprobar de forma programática si un commit tiene algún cambio asociado. Finalmente, probaremos estas técnicas tanto con commits regulares que incluyen modificaciones como con commits vacíos creados intencionalmente para consolidar nuestro conocimiento.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560058{{"Cómo comprobar si un commit de Git está vacío"}} git/status -.-> lab-560058{{"Cómo comprobar si un commit de Git está vacío"}} git/commit -.-> lab-560058{{"Cómo comprobar si un commit de Git está vacío"}} git/diff -.-> lab-560058{{"Cómo comprobar si un commit de Git está vacío"}} git/log -.-> lab-560058{{"Cómo comprobar si un commit de Git está vacío"}} end

Ejecutar git show para comprobar cambios

En este paso, aprenderemos cómo inspeccionar los detalles de un commit específico utilizando el comando git show. Este comando es como abrir una cápsula del tiempo para ver exactamente qué había dentro en ese momento.

Primero, asegúrate de que estás en el directorio de tu proyecto:

cd ~/project/my-time-machine

Ahora, usemos git show para ver nuestro primer commit. Podemos usar el hash del commit (la larga cadena de letras y números) del resultado de git log, o simplemente usar HEAD, que se refiere al último commit en la rama actual.

git show HEAD

Deberías ver una salida similar a esta:

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

    Send a message to the future

diff --git a/message.txt b/message.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

Desglosemos esta salida:

La primera parte es similar a git log, mostrando la información del commit (hash, autor, fecha, mensaje).
La sección diff muestra los cambios introducidos por este commit.
- diff --git a/message.txt b/message.txt: Indica una diferencia entre el estado antes y después del commit para el archivo message.txt.
- new file mode 100644: Muestra que message.txt es un archivo nuevo.
- index 0000000..e69de29: Información interna de Git sobre el contenido del archivo.
- --- /dev/null: Representa el estado antes del commit (el archivo no existía).
- +++ b/message.txt: Representa el estado después del commit.
- @@ -0,0 +1 @@: Este es un "encabezado de hunk" que indica los cambios. -0,0 significa que se eliminaron cero líneas a partir de la línea 0 en el archivo original, y +1 significa que se agregó una línea a partir de la línea 1 en el nuevo archivo.
- +Hello, Future Me: La línea que se agregó en este commit. El signo + indica una adición.

El comando git show es increíblemente útil para entender la historia de tu proyecto. Puedes usarlo para ver exactamente qué cambios se hicieron en cualquier commit específico, lo cual es esencial para depurar o entender cómo se implementó una característica.

Presiona q para salir de la vista de git show.

Usar git diff-tree para comprobar si un commit está vacío

En este paso, exploraremos otro comando, git diff-tree, que puede ser útil para examinar los cambios dentro de un commit, especialmente para comprobar si un commit está "vacío" (es decir, no introduce cambios en el contenido de los archivos, solo metadatos como el mensaje del commit).

Primero, asegúrate de que estás en el directorio de tu proyecto:

cd ~/project/my-time-machine

Ahora, usemos git diff-tree con las opciones --no-commit-id y --name-only en nuestro primer commit (HEAD).

git diff-tree --no-commit-id --name-only HEAD

Deberías ver la siguiente salida:

message.txt

Entendamos el comando y su salida:

git diff-tree: Este comando compara el contenido y el modo de los objetos en un árbol de Git.
--no-commit-id: Esta opción suprime el ID del commit de la salida, haciéndola más limpia.
--name-only: Esta opción solo muestra los nombres de los archivos que se modificaron en el commit.
HEAD: Especifica el commit que queremos examinar (nuestro último commit).

La salida message.txt nos dice que el commit apuntado por HEAD introdujo cambios en el archivo message.txt.

Ahora, veamos qué sucede si ejecutamos el mismo comando en un commit que no cambia ningún archivo. Dado que nuestro primer commit es el único, probemos un escenario hipotético. Si tuviéramos un commit que solo actualizara el mensaje del commit sin cambiar ningún archivo, git diff-tree --no-commit-id --name-only <commit-hash> no produciría salida. Así es como puedes usar git diff-tree para comprobar si un commit está "vacío" en términos de cambios en los archivos.

Mientras que git show te da una vista detallada de los cambios, git diff-tree con opciones como --name-only es útil para scripting o para comprobar rápidamente qué archivos se vieron afectados por un commit sin ver el diff completo.

Probar con commits regulares

En este paso, practicaremos la creación de más commits para construir un historial en nuestro repositorio y ver cómo git log y git status reflejan estos cambios. Esto simulará un flujo de trabajo más típico en el que se realizan múltiples cambios y se guardan de forma incremental.

Primero, asegúrate de que estás en el directorio de tu proyecto:

cd ~/project/my-time-machine

Ahora, agreguemos otra línea a nuestro archivo message.txt. Usaremos el comando echo con >> para anexar texto al archivo existente.

echo "Adding another line for testing." >> message.txt

Comprobemos el contenido del archivo para confirmar el cambio:

cat message.txt

Deberías ver:

Hello, Future Me
Adding another line for testing.

Ahora, comprobemos el estado de nuestro repositorio:

git status

Deberías ver una salida que indique que message.txt ha sido modificado:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

Git identifica correctamente que el archivo ha sido cambiado desde el último commit. Ahora, preparemos (stage) y confirmemos este cambio.

git add message.txt
git commit -m "Add a second line to message.txt"

Deberías ver una salida que confirme el commit:

[master a1b2c3d] Add a second line to message.txt
 1 file changed, 1 insertion(+)

Ahora hemos creado un segundo commit. Veamos el historial de commits usando git log:

git log

Ahora deberías ver dos entradas de commit, con el commit más reciente en la parte superior:

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

    Add a second line to message.txt

commit f0e1d2c3b4a5968776543210fedcba9876543210
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 09:55:00 2023 +0000

    Send a message to the future

(Ten en cuenta que los hashes de commit y las fechas serán diferentes en tu salida).

Esto demuestra el ciclo básico de realizar cambios, prepararlos con git add y guardarlos como un nuevo commit con git commit. Cada commit representa un punto distinto en la historia de tu proyecto, lo que te permite seguir el progreso y revertir a estados anteriores si es necesario.

Presiona q para salir del registro.

Resumen

En este laboratorio, aprendimos cómo inspeccionar los detalles de un commit de Git utilizando el comando git show. Este comando proporciona una vista integral de un commit específico, incluyendo sus metadatos (autor, fecha, mensaje) y los cambios exactos introducidos por ese commit en formato diff. Vimos cómo la salida del diff indica claramente las líneas agregadas, eliminadas o modificadas, lo que nos permite entender los cambios en el contenido dentro de un commit.

Seguiremos explorando métodos para comprobar si un commit está vacío y probaremos estas técnicas con diferentes tipos de commits.