Gerenciando solicitações de pull empilhadas

À medida que você trabalha iterativamente em uma pilha, muitas vezes precisa fazer alterações em uma camada inferior, fazer rebase para manter um histórico linear ou reestruturar seus ramos. A extensão gh stack no GitHub CLI gerencia essas tarefas com operações em cascata que atualizam todas as ramificações afetadas. Consulte Comandos da CLI de solicitações de pull empilhadas.

Fazendo alterações em uma camada inferior

Quando você estiver trabalhando na camada mais alta e precisar alterar algo mais abaixo na pilha, faça a alteração no branch ao qual ela pertence e faça o rebase, em vez de contornar isso na camada atual.

Navegue até a ramificação que precisa ser alterada.
Shell
```
gh stack down
```
```
gh stack down
```
Você também pode alternar para uma branch específica com gh stack checkout BRANCH-NAME.

Faça a alteração e confirme-a.

Shell

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

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

Faça rebase nas branches acima para incorporar a alteração.
Shell
```
gh stack rebase --upstack
```
```
gh stack rebase --upstack
```
Faça push das branches atualizadas e volte para onde você estava trabalhando.
Shell
```
gh stack push
gh stack top
```
```
gh stack push
gh stack top
```

Rebaseando sua pilha

Uma pilha deve ter um histórico linear entre suas ramificações antes de poder ser mesclada. Executar gh stack rebase realiza um rebase em cascata no qual cada branch passa por rebase sobre o branch abaixo dele, começando de main, de modo que cada branch incorpora as alterações mais recentes de todas as camadas inferiores.

Faça rebase da pilha. Por padrão, isso rebaseia todas as ramificações da parte inferior para a parte superior.
Shell
```
gh stack rebase
```
```
gh stack rebase
```
Para limitar o rebase, use --downstack para fazer rebase da camada inferior até o branch atual ou --upstack para fazer rebase do branch atual até o topo.
Faça push das branches atualizadas. Isso usa --force-with-lease para atualizar com segurança as branches com rebase.
Shell
```
gh stack push
```
```
gh stack push
```

Se uma rebase encontrar um conflito, gh stack rebase pare e liste os arquivos conflitantes.

Resolva os marcadores nos arquivos afetados, prepare-os com git adde execute gh stack rebase --continue.
Para recomeçar, execute gh stack rebase --abort para restaurar todas as ramificações ao estado em que estavam antes do rebase.

Observação

Você também pode acionar um rebase no servidor a partir do pull request, mas esses commits não são assinados. Se o repositório exigir confirmações assinadas, rebasee para GitHub CLI que as confirmações sigam a configuração de assinatura de confirmação do Git local.

Rebase a partir do GitHub site

Quando uma pilha não é linear, um botão Rebase da pilha aparece na caixa de merge. Ao selecioná-lo, aciona um rebase em cascata no servidor que:

Rebases a pilha inteira em cima do tronco mais recente, como main.
Faz rebase de cada branch não mesclada sobre sua branch base, trabalhando da base da pilha para o topo.
Efetua push de cada branch rebased para atualizar o remoto.

Depois que o rebase for concluído, cada pull request refletirá as branches atualizadas, e as verificações de CI serão acionadas novamente.

Observação

As confirmações criadas por uma rebase do lado do servidor não são assinadas. Se o seu repositório exigir commits assinados, faça rebase a partir de GitHub CLI usando gh stack rebase para que os commits sigam a sua configuração local de assinatura de commits do Git e, em seguida, faça push com gh stack push.

Reestruturar uma pilha

Talvez você queira alterar a composição de uma pilha. Por exemplo, se você precisar excluir um branch, mesclar branches, inserir um branch, reordenar ou renomear, use o comando interativo gh stack modify.

Antes de executar gh stack modify, verifique o seguinte:

Você tem uma pilha ativa em check-out.
Sua árvore de trabalho está limpa.
Não há rebase em andamento.
Nenhum pull request está na fila para mesclagem.
O histórico de commits é linear.

Abra a interface do terminal de modificação.
Shell
```
gh stack modify
```
```
gh stack modify
```
Selecione um branch e prepare uma operação. A reordenação e as alterações estruturais (soltar, dobrar, inserir, renomear) não podem ser misturadas na mesma sessão.
- x — exclua um branch e seus commits
- d — dobre a ramificação na que está abaixo dela
- u — dobre a ramificação na que está acima dela
- i / I — insira um novo branch abaixo ou acima do cursor
- r — renomeie um branch
- Shift+ / ↑Shift+↓ — reordenar uma ramificação
- z — desfazer a última ação preparada
Aplique as alterações preparadas salvando-as. Nada é alterado até que você salve.

Use ctrl/cmd+s.

Se ocorrer um conflito durante a aplicação, resolva-o e execute-o gh stack modify --continueou execute-o gh stack modify --abort para restaurar o estado de pré-modificação.
Faça push das branches atualizadas e recrie a pilha em GitHub.
Shell
```
gh stack submit
```
```
gh stack submit
```

Desfazer empilhamento do site GitHub

Para dissolver uma pilha do site, por exemplo, para reordená-la ou reorganizar, use a opção Unstack na pilha.

O descomprupamento remove as solicitações de pull abertas, de rascunho e fechadas da pilha. Cada um mantém seu ramo base atual, mas deixa de estar vinculado aos demais, e o mapa da pilha e os requisitos de mesclagem da pilha deixam de se aplicar a eles.

As solicitações de pull mescladas e enfileiradas permanecem na pilha. Depois que um pull request é mesclado ou colocado na fila para mesclagem como parte de uma stack, ele não pode ser removido da stack. Uma pilha é dissolvida inteiramente somente quando nenhum de seus pull requests tiver sido mesclado ou estiver na fila para mesclagem; caso contrário, ela continuará existindo com esses pull requests ainda nela.

Para reordenar ou reestruturar uma pilha sem dissolvê-la, use o gh stack modify comando em vez disso. Consulte Reestruturar uma pilha.

Sincronizando seu ambiente local após mesclagens

Quando uma solicitação de pull na parte inferior da pilha se mescla, atualize o estado local com um único comando de sincronização. Para remover automaticamente os branches locais dos pull requests mesclados ao mesmo tempo, adicione a opção --prune.

Shell

gh stack sync --prune

gh stack sync --prune

Isso busca as alterações mais recentes, encaminha rapidamente o tronco, rebaseia os branches restantes nele, envia por push os branches atualizados e sincroniza o status da solicitação de pull.GitHub

Puxando solicitações de pull adicionadas à pilha em GitHub

Se outra pessoa adicionar pull requests à pilha em GitHub, gh stack sync busca as novas ramificações e as acrescenta à sua pilha local para que ela espelhe o repositório remoto. Uma atualização remota limpa como essa é retirada automaticamente, portanto gh stack sync , é segura para ser executada na automação.

Resolvendo uma pilha divergente

Suas pilhas locais e remotas divergem quando nenhuma das duas é uma extensão limpa da outra, por exemplo, quando você adiciona uma ramificação localmente enquanto diferentes solicitações de pull são adicionadas à mesma pilha.GitHub Quando isso acontece, gh stack sync não é possível mesclar os dois automaticamente. Em um terminal interativo, ele oferece três opções:

Use a pilha remota como a fonte da verdade. Substitui a composição da stack local pela do remoto, trazendo quaisquer branches ausentes. Se você estava em um branch que a pilha remota não contém mais, você é movido para o branch sobrevivente mais próximo. Isso requer uma árvore de trabalho limpa sem alterações não confirmadas.
Exclua a pilha em GitHub. Exclui o objeto de pilha em GitHub e interrompe a sincronização. Seus pull requests e branches locais não são afetados. Recrie a pilha com gh stack submit, o que também cria pull requests para quaisquer ramificações que você ainda não submeteu. Execute gh stack modify primeiro se você quiser alterar sua estrutura.
Cancelar. Cancela a sincronização sem fazer push de branches nem atualizar pull requests.

Em um terminal não interativo, como em CI, uma divergência interrompe a sincronização sem enviar ramificações nem atualizar pull requests. Resolva-o descompilhando e recriando a pilha.

Gerenciando solicitações de pull empilhadas

Neste artigo