# Gerenciando solicitações de pull empilhadas

Reestruturar solicitações de pull empilhadas, basear novamente seus branches e fazer alterações em camadas inferiores usando GitHub CLI.

> \[!NOTE] Esse recurso está em versão prévia pública e está sujeito a alterações.

À medida que você itera em uma pilha, muitas vezes você precisa fazer alterações em uma camada inferior, se basear novamente para manter um histórico linear ou reestruturar seus branches. A `gh stack` extensão lida com essas tarefas com operações em GitHub CLI cascata que atualizam todas as ramificações afetadas. Consulte [Comandos da CLI de solicitações de pull empilhadas](/pt/pull-requests/reference/stacked-prs-cli-commands).

## Fazendo alterações em uma camada inferior

Quando você estiver trabalhando na camada superior e precisar alterar algo mais baixo na pilha, faça a alteração no branch em que ela pertence e rebasee, em vez de trabalhar em torno dela na camada atual.

1. Navegue até o branch que precisa da alteração.

   ```shell copy
   gh stack down
   ```

   Você também pode fazer check-out de um branch específico com `gh stack checkout BRANCH-NAME`.

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

   ```shell copy
   git add .
   git commit -m "helpful-commit-message"
   ```

3. Basear novamente os branches acima para pegar a alteração.

   ```shell copy
   gh stack rebase --upstack
   ```

4. Envie por push as ramificações atualizadas e retorne para onde você estava trabalhando.

   ```shell copy
   gh stack push
   gh stack top
   ```

## Rebasing sua pilha

Uma pilha deve ter um histórico linear entre seus branches antes de poder mesclar. A execução `gh stack rebase` executa uma rebase em cascata em que cada ramificação é rebased na parte superior do branch abaixo dela, a partir dele `main`, de modo que cada ramificação pega as alterações mais recentes de todas as camadas inferiores.

1. Basear novamente a pilha. Por padrão, isso rebaseia todas as ramificações da parte inferior para a parte superior.

   ```shell copy
   gh stack rebase
   ```

   Para limitar a rebase, use `--downstack` para se basear novamente da camada mais baixa até o branch atual ou `--upstack` para se basear novamente do branch atual até a parte superior.

2. Envie por push as ramificações atualizadas. Isso usa `--force-with-lease` para atualizar com segurança as ramificações rebased.

   ```shell copy
   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 add`e execute `gh stack rebase --continue`.
* Para começar, execute `gh stack rebase --abort` para restaurar todos os branches para seu estado de pré-rebase.

> \[!NOTE]
> Você também pode disparar uma rebase do lado do servidor da solicitação de pull, mas essas confirmações não são assinadas. 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.

### Rebasing do GitHub site

Quando uma pilha não é linear, um botão **de pilha rebase** é exibido na caixa de mesclagem. Selecioná-lo dispara uma rebase em cascata do lado do servidor que:

1. Rebases a pilha inteira em cima do tronco mais recente, como `main`.
2. Rebaseia cada branch não mesclado na parte superior de seu branch base, trabalhando da parte inferior da pilha para cima.
3. Efetua push de cada branch rebased para atualizar o remoto.

Depois que a rebase for concluída, cada solicitação de pull refletirá os branches atualizados e as verificações de CI serão disparadas novamente.

> \[!NOTE]
> As confirmações criadas por uma rebase do lado do servidor **não** são assinadas. Se o repositório exigir confirmações assinadas, recue para GitHub CLI que `gh stack rebase` as confirmações sigam a configuração de assinatura de confirmação do Git local e, em seguida, envie por push com `gh stack push`.

## Reestruturar uma pilha

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

Antes de executar `gh stack modify`, verifique o seguinte:

* Você tem uma pilha ativa com check-out.
* Sua árvore de trabalho está limpa.
* Nenhuma rebase está em andamento.
* Nenhuma solicitação de pull é enfileirada para mesclagem.
* O histórico de confirmação é linear.

1. Abra a interface do usuário do terminal de modificação.

   ```shell copy
   gh stack modify
   ```

2. 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` — solte um branch e suas confirmações
   * `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
   * <kbd>Shift</kbd>+<kbd></kbd> / ↑<kbd>Shift</kbd>+<kbd>↓</kbd> — reordenar uma ramificação
   * `z` — desfazer a última ação em etapas

3. Aplique as alterações em etapas salvando-as. Nada é modificado até você salvar.

   Use <kbd>ctrl/cmd</kbd>+<kbd>s</kbd>.

   Se ocorrer um conflito durante a aplicação, resolva-o e execute-o `gh stack modify --continue`ou execute-o `gh stack modify --abort` para restaurar o estado de pré-modificação.

4. Envie por push os branches atualizados e recrie a pilha.GitHub

   ```shell copy
   gh stack submit
   ```

## Desempredando do GitHub site

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 branch base atual, mas não está mais vinculado aos outros, e os requisitos de mesclagem de pilha e de mapa de pilha desaparecem deles.

**As solicitações de pull mescladas e enfileiradas permanecem na pilha.** Depois que uma solicitação de pull é mesclada ou enfileirada para mesclagem, como parte de uma pilha, ela não pode ser descompilhada. Uma pilha é dissolvida inteiramente somente quando nenhuma de suas solicitações de pull foi mesclada ou está na fila para mesclagem; caso contrário, ele persistirá com essas solicitações de pull ainda nele.

Para reordenar ou reestruturar uma pilha sem dissolvê-la, use o `gh stack modify` comando em vez disso. Consulte [Reestruturar uma pilha](#restructuring-a-stack).

## 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 podar automaticamente branches locais para solicitações de pull mescladas ao mesmo tempo, adicione a opção `--prune` .

```shell copy
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 solicitações de pull à pilha GitHub, `gh stack sync` busque os novos branches e acrescente-os à pilha local para que ele espelha o controle 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 pilha local pelos controles remotos, puxando os 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 GitHub de pilha e interrompe a sincronização. Suas solicitações de pull e ramificações locais não são intocadas. Recrie a pilha com `gh stack submit`, que também cria solicitações de pull para quaisquer branches que você ainda não enviou. Execute `gh stack modify` primeiro se você quiser alterar sua estrutura.
* **Cancelar.** Anula a sincronização sem enviar branches por push ou atualizar nenhuma solicitação de pull.

Em um terminal não interativo, como CI, uma divergência anula a sincronização sem enviar branches por push ou atualizar solicitações de pull. Resolva-o descompilhando e recriando a pilha.

## Próximas Etapas 

* [Revisão de solicitações de pull empilhadas](/pt/pull-requests/how-tos/review-pull-requests/reviewing-stacked-pull-requests)
* [Mesclar solicitações de pull empilhadas](/pt/pull-requests/how-tos/merge-and-close-pull-requests/merging-stacked-pull-requests)