Administración de pull requests apiladas

A medida que itera en una pila, a menudo debe realizar cambios en una capa inferior, hacer rebase para mantener un historial lineal o reestructurar sus ramas. La gh stack extensión de GitHub CLI controla estas tareas con operaciones en cascada que actualizan todas las ramas afectadas. Consulte Comandos de la CLI para pull requests apiladas.

Realizar cambios en una capa inferior

Cuando esté trabajando en la capa superior y necesite cambiar algo más bajo en la pila, realice el cambio en la rama a la que pertenece y haga un rebase, en lugar de buscar una solución temporal en la capa actual.

Vaya a la branch en la que hay que realizar el cambio.
Shell
```
gh stack down
```
```
gh stack down
```
También puede cambiarse a una rama específica con gh stack checkout BRANCH-NAME.

Realice el cambio y haga commit.

Shell

git add .
git commit -m "helpful-commit-message"

git add .
git commit -m "helpful-commit-message"

Haz rebase de las ramas anteriores para recoger el cambio.
Shell
```
gh stack rebase --upstack
```
```
gh stack rebase --upstack
```
Envíe las ramas actualizadas y vuelva a donde estaba trabajando.
Shell
```
gh stack push
gh stack top
```
```
gh stack push
gh stack top
```

Rebase de tu stack

Una pila debe tener un historial lineal entre sus ramas para poder fusionarse. La ejecución gh stack rebase realiza un rebase en cascada donde cada rama se vuelve a basar sobre la rama inferior, empezando por main, por lo que cada rama recoge los cambios más recientes de todas las capas inferiores.

Rebase la pila. De forma predeterminada, esto reorganiza la base de cada rama de la parte inferior a la parte superior.
Shell
```
gh stack rebase
```
```
gh stack rebase
```
Para limitar el rebase, use --downstack para hacer rebase desde la capa más baja hasta la rama actual o --upstack para hacer rebase desde la rama actual hasta la parte superior.
Envíe las ramas actualizadas. Esto usa --force-with-lease para actualizar de forma segura las ramas reasentadas.
Shell
```
gh stack push
```
```
gh stack push
```

Si un rebase encuentra un conflicto, gh stack rebase se detiene y enumera los archivos en conflicto.

Resuelva los marcadores de los archivos afectados, prepárelos para la confirmación con git add y, a continuación, ejecute gh stack rebase --continue.
Para empezar, ejecute gh stack rebase --abort para restaurar todas las ramas a su estado anterior al rebase.

Nota:

También puede iniciar una reasignación de base en el servidor desde la solicitud de extracción, pero esos commits no están firmados. Si el repositorio requiere commits firmados, haz un rebase desde GitHub CLI para que los commits sigan la configuración local de firma de commits de Git.

Rebasar desde el sitio web GitHub

Cuando una pila no es lineal, aparece un botón Reorganizar pila en el cuadro de combinación. Al seleccionarlo, se desencadena un rebase en cascada en el servidor que:

Vuelve a basar toda la pila encima de la rama principal más reciente, como main.
Vuelve a basar cada rama no combinada encima de su rama base, trabajando desde la parte inferior de la pila hacia arriba.
Hace force-push de cada rama rebasada para actualizar el remoto.

Una vez completado el rebase, todas las solicitudes de incorporación de cambios reflejan las ramas actualizadas y las comprobaciones de CI se vuelven a desencadenar.

Nota:

Los commits creados por un rebase del lado del servidor no están firmados. Si el repositorio requiere commits firmados, haga un rebase desde GitHub CLI con gh stack rebase para que los commits sigan la configuración local de firma de commits de Git y, a continuación, haga push con gh stack push.

Reestructuración de una stack

Es posible que desee cambiar la composición de una pila. Por ejemplo, si necesita quitar una rama, combinar ramas, insertar una rama, reordenar o cambiar el nombre, use el comando gh stack modifyinteractivo .

Antes de ejecutar gh stack modify, asegúrese de lo siguiente:

Tiene una stack activa extraída.
Tu directorio de trabajo está limpio.
No hay ningún rebase en curso.
No se pone en cola ninguna pull request para fusionar.
El historial de confirmaciones es lineal.

Abra la interfaz de usuario para modificar el terminal.
Shell
```
gh stack modify
```
```
gh stack modify
```
Seleccione una rama y prepare una operación. Los cambios estructurales y de reordenación (drop, fold, insert, rename) no se pueden mezclar en la misma sesión.
- x : quitar una rama y sus commits
- d — plegar el elemento en el de debajo
- u — pliega la rama en la de arriba
- i / I — inserte un nuevo nodo debajo o encima del cursor
- r — cambiar el nombre de una rama
- Mayús+↑ / Mayús+↓ — reordenar una rama
- z — deshacer la última acción en fase
Aplique los cambios en preparación guardando. No se modifica nada hasta que guardes.

Usa ctrl/cmd+s.

Si se produce un conflicto durante la aplicación, resuélvalo y ejecute gh stack modify --continue o ejecute gh stack modify --abort para restaurar el estado anterior a la modificación.
Envíe las ramas actualizadas y vuelva a crear la pila en GitHub.
Shell
```
gh stack submit
```
```
gh stack submit
```

Desapilado del sitio web GitHub

Para desagrupar una pila del sitio web, por ejemplo, para reordenarla o reorganizarla, use la opción Unstack en la pila.

Desapilar quita las solicitudes de incorporación de cambios abiertas, borradores y cerradas de la pila. Cada uno mantiene su rama base actual, pero ya no está vinculado a los demás, y los requisitos de stack map y stack merge desaparecen de ellos.

Las pull requests fusionadas y en cola permanecen en el stack. Una vez que un pull request se ha fusionado, o se pone en cola para la fusión, como parte de una pila, no se puede quitar de la pila. Una pila se disuelve completamente solo cuando ninguna de sus pull requests se han fusionado o están en cola para la fusión; de lo contrario, se conserva con esas pull requests todavía en ella.

Para reordenar o reestructurar una pila sin disolverla, use el comando gh stack modify en su lugar. Consulte Reestructuración de una pila.

Sincronización del entorno local después de las fusiones

Cuando un pull request en la parte inferior de la pila se fusiona, actualice el estado local con un único comando de sincronización. Para eliminar automáticamente las ramas locales de las pull requests fusionadas al mismo tiempo, agregue la opción --prune.

Shell

gh stack sync --prune

gh stack sync --prune

Esto captura los cambios más recientes, avanza el tronco en avance rápido, rebasea las ramas restantes sobre él, envía las ramas actualizadas y sincroniza el estado de la solicitud de incorporación de cambios de GitHub.

Incorporación de solicitudes de incorporación de cambios agregadas a la pila en GitHub

Si otra persona agrega pull requests a la pila en GitHub, gh stack sync captura las nuevas ramas y las anexa a la pila local para que refleje el remoto. Una actualización limpia con commits remotos por delante, como esta, se extrae automáticamente, por lo que gh stack sync se puede ejecutar con seguridad en automatización.

Resolución de una pila divergente

Las pilas locales y remotas difieren cuando ninguna de ellas es una extensión limpia del otro, por ejemplo, cuando se agrega una rama localmente mientras se agregan solicitudes de incorporación de cambios diferentes a la misma pila en GitHub. Cuando esto sucede, gh stack sync no puede combinar los dos automáticamente. En un terminal interactivo, ofrece tres opciones:

Use la pila remota como fuente de referencia. Reemplaza la composición de tu stack local por la del repositorio remoto, trayendo las ramas que faltan. Si estaba en una rama que la pila remota ya no contiene, se le moverá a la rama de supervivencia más cercana. Esto requiere un directorio de trabajo limpio sin cambios sin confirmar.
Elimine la pila de GitHub. Elimina el objeto de pila en GitHub y detiene la sincronización. Las pull requests y las ramas locales no se modifican. Vuelva a crear la pila con gh stack submit, que también crea pull requests para las ramas que aún no haya enviado. Ejecute gh stack modify primero si desea cambiar su estructura.
Cancelar. Anula la sincronización sin enviar ramas ni actualizar las solicitudes de extracción.

En un terminal no interactivo, como CI, una divergencia anula la sincronización sin enviar ramas ni actualizar pull requests. Resuélvelo desapilando y volviendo a crear la pila.