Cómo comprobar si una rama de Git es huérfana

Introducción

En este laboratorio, aprenderás cómo verificar si una rama (branch) de Git está huérfana. Exploraremos el comando git log para entender los commits sin commits padre, que es una característica del commit inicial en un repositorio.

Además, utilizarás el comando git branch --no-merged para identificar las ramas (branches) cuyos cambios no se han integrado en la rama (branch) actual. Finalmente, probarás estos conceptos creando y examinando una nueva rama (branch) huérfana.

Skills Graph

Verificar el registro (log) de Git para commits sin padre

En este paso, exploraremos más a fondo el comando git log, específicamente cómo se comporta en un repositorio con commits sin padre. Este es el caso del primer commit en un repositorio.

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

cd ~/project/my-time-machine

Ahora, usemos el comando git log con la opción --pretty=oneline. Esta opción muestra cada commit en una sola línea, lo cual es útil para obtener una vista concisa del historial. También agregaremos la opción --max-count=1 para mostrar solo el commit más reciente.

git log --pretty=oneline --max-count=1

Deberías ver una salida similar a esta:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master) Send a message to the future

Esta salida muestra el hash del commit (la larga cadena de caracteres), la rama (branch) en la que se encuentra (HEAD -> master) y el mensaje del commit.

Ahora, intentemos ver el padre de este commit. Dado que este es el primer commit, no tiene padre. Podemos usar la opción --no-walk=parent con git log para intentar mostrar el commit padre.

git log --no-walk=parent --pretty=oneline --max-count=1

Es probable que este comando no produzca ninguna salida o muestre un mensaje de error que indique que no hay un commit padre para mostrar. Este es el comportamiento esperado para el commit inicial.

Comprender que el primer commit no tiene padre es fundamental para entender cómo Git construye su historial. Cada commit subsiguiente tendrá uno o más padres, formando una cadena de cambios.

Usar git branch --no-merged

En este paso, aprenderemos sobre el comando git branch y, específicamente, la opción --no-merged. Esta opción nos ayuda a identificar las ramas (branches) que contienen cambios que aún no se han incorporado a la rama (branch) actual.

Primero, creemos una nueva rama (branch). Puedes pensar en una rama (branch) como una línea temporal alternativa donde puedes trabajar en nuevas características o experimentos sin afectar la línea temporal principal (master).

Asegúrate de estar en el directorio ~/project/my-time-machine.

cd ~/project/my-time-machine

Ahora, crea una nueva rama (branch) llamada experiment:

git branch experiment

Este comando crea la nueva rama (branch), pero no te cambia a ella. Todavía estás en la rama (branch) master.

Listemos todas las ramas (branches) de nuestro repositorio usando el comando git branch:

git branch

Deberías ver una salida similar a esta:

  experiment
* master

El asterisco (*) indica la rama (branch) en la que te encuentras actualmente, que es master.

Ahora, usemos el comando git branch --no-merged. Este comando lista las ramas (branches) que no se han fusionado (merged) en la rama (branch) actual (master).

git branch --no-merged

Deberías ver:

  experiment

Esta salida nos dice que la rama (branch) experiment contiene cambios que no están presentes en la rama (branch) master. En este caso, dado que acabamos de crear la rama (branch) experiment a partir de master y aún no hemos realizado ningún cambio en ella, esto puede parecer contraintuitivo. Sin embargo, la opción --no-merged está diseñada para mostrar las ramas (branches) cuyo commit final no es alcanzable desde el commit final de la rama (branch) actual. Dado que experiment apunta al mismo commit que master actualmente, pero master no ha "fusionado" (merged) experiment (lo cual no tiene sentido en este contexto), todavía lista experiment.

En un escenario del mundo real, normalmente crearías una nueva rama (branch), realizarías algunos commits en ella y luego usarías git branch --no-merged desde tu rama (branch) principal (como master) para ver qué ramas (branches) de características están listas para ser fusionadas (merged).

Probar con una nueva rama huérfana (orphan branch)

En este paso, crearemos una nueva "rama huérfana" (orphan branch). Una rama huérfana es una rama que comienza sin historia de ramas anteriores. Es como comenzar una línea temporal completamente nueva en tu máquina del tiempo. Esto es útil para cosas como ramas de documentación o ramas gh-pages para sitios web, donde no quieres que se incluya la historia de tu código principal.

Asegúrate de estar en el directorio ~/project/my-time-machine.

cd ~/project/my-time-machine

Ahora, creemos una nueva rama huérfana llamada new-start:

git checkout --orphan new-start

Deberías ver una salida similar a esta:

Switched to a new branch 'new-start'

Ahora hemos cambiado a la rama new-start. Observa que los archivos de la rama master todavía están presentes en tu directorio de trabajo. Esto se debe a que git checkout --orphan prepara tu directorio de trabajo y el índice (index) para un nuevo commit raíz, pero no elimina los archivos existentes.

Veamos el estado:

git status

Deberías ver algo como esto:

On branch new-start

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        message.txt

nothing added to commit but untracked files present (use "git add" to track)

Git ve message.txt como un archivo no rastreado porque la historia de la rama new-start es completamente independiente de master.

Para comenzar realmente de nuevo en esta rama huérfana, normalmente eliminamos los archivos antiguos y luego agregamos el nuevo contenido para esta rama. Eliminemos el archivo message.txt:

rm message.txt

Ahora, veamos el estado nuevamente:

git status

Deberías ver:

On branch new-start

No commits yet

nothing to commit (create/copy files and use "git add" to track)

El directorio de trabajo ahora está limpio y estamos listos para crear el primer commit en nuestra nueva línea temporal independiente.

Creemos un nuevo archivo específico para esta rama:

echo "This is a fresh start!" > readme.md

Agreguemos el nuevo archivo al área de preparación (staging area):

git add readme.md

Y finalmente, creemos el primer commit en la rama new-start:

git commit -m "Initial commit for new-start branch"

Deberías ver una salida similar a esta:

[new-start (root-commit) a1b2c3d] Initial commit for new-start branch
 1 file changed, 1 insertion(+)
 create mode 100644 readme.md

Observa que este commit también es un "(root-commit)", al igual que el primer commit en la rama master. Esto confirma que no tiene padre y es el comienzo de una nueva historia.

Ahora, veamos el registro (log) de esta rama:

git log --pretty=oneline

Deberías ver solo el único commit que acabamos de hacer:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> new-start) Initial commit for new-start branch

Esto demuestra que la rama new-start tiene su propia historia independiente, separada de la rama master.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si una rama (branch) de Git es huérfana (orphaned). Comenzamos explorando el comando git log, específicamente cómo identificar la ausencia de un commit padre para el primer commit en un repositorio utilizando --no-walk=parent. Esto demostró el concepto fundamental de la historia de Git donde el primer commit no tiene padre.

A continuación, se nos presentó el comando git branch --no-merged. Este comando se utiliza para listar las ramas (branches) que no se han fusionado (merged) en la rama (branch) actual, lo cual es una técnica clave para identificar ramas (branches) que podrían ser huérfanas o contener cambios no integrados. El laboratorio (lab) también incluyó un paso para probar estos conceptos creando y examinando una nueva rama huérfana (orphan branch).