No Mac, resolva um conflito de cherry-pick editando cada arquivo em conflito no Terminal ou em um editor de código, preparando os arquivos finalizados com git add e executando git cherry-pick --continue. O Git é pausado porque não conseguiu aplicar um commit de forma limpa; sua ramificação atual ainda não recebeu esse commit. Revise os dois lados de cada conflito antes de continuar e use git cherry-pick --abort se decidir não prosseguir. A documentação do cherry-pick do Git descreve esse estado de pausa e suas opções de continuidade.

1. Abra o Terminal na pasta do projeto

Abra o Terminal pelo Spotlight ou pela pasta Aplicativos > Utilitários do Finder. No Terminal, vá para a pasta do repositório com cd e o seu caminho. Para um caminho de pasta que contenha espaços, coloque o caminho entre aspas, por exemplo, cd "/Users/sam/Work/My Project". Você também pode digitar cd com um espaço no final, arrastar a pasta do projeto do Finder para a janela do Terminal e pressionar Return. A Apple descreve o Terminal como a interface de linha de comando do macOS; seu prompt geralmente termina com % ao usar o shell padrão zsh. O guia do Terminal da Apple explica como abri-lo e reconhecer o prompt.

Confirme se você está no repositório e veja o que o Git informa antes de alterar os arquivos:

git status

Se a saída indicar que um cherry-pick está em andamento e listar os caminhos em conflito, continue abaixo. Se você não tiver certeza de qual repositório ou commit está envolvido, pare e confirme esse contexto antes de resolver qualquer coisa. Não inicie um segundo cherry-pick enquanto o primeiro estiver pausado.

2. Inspecione o conflito e decida o que o arquivo deve conter

Abra cada arquivo de texto em conflito no seu editor. O Git insere marcadores ao redor das seções que não conseguiu reconciliar. Uma seção típica é semelhante a esta:

<<<<<<< HEAD
content on the current branch
=======
content from the commit being cherry-picked
>>>>>>> commit subject or identifier

HEAD é a versão da ramificação atual; a outra seção é do commit que está sendo aplicado. Esses rótulos descrevem os dois lados desta operação, mas não indicam qual versão está correta. Use o código ao redor, a alteração pretendida e o propósito do commit para decidir se deve manter um dos lados ou combiná-los. A documentação do Git explica que os arquivos em conflito contêm marcadores e que os caminhos aplicados de forma limpa já podem ter sido atualizados. Git cherry-pick

Edite o arquivo para que ele contenha o resultado pretendido, removendo todas as linhas de marcadores de conflito. Verifique todos os conflitos nesse arquivo, salve-o e repita o processo para cada caminho listado por git status. Para um arquivo binário ou um conflito cujo resultado pretendido não esteja claro, não adivinhe: consulte o autor da alteração ou as diretrizes do projeto antes de escolher uma versão. Evite substituir um arquivo inteiro por um dos lados apenas para fazer o conflito desaparecer; isso pode descartar alterações válidas.

3. Prepare (stage) as resoluções e revise-as

Depois de resolver um arquivo, informe ao Git que o conflito foi resolvido preparando-o para o commit (staging). Use o caminho exato mostrado por git status; coloque entre aspas os caminhos que contenham espaços:

git add "Sources/Example File.swift"

Repita o processo para cada caminho resolvido. O git add prepara o conteúdo atual do arquivo, portanto, revise o que está preparando caso ele contenha edições não relacionadas. O manual do git-add do Git documenta que ele adiciona o conteúdo do arquivo ao índice, a área de preparação (staging area) usada para o próximo commit. Git add

Verifique se ainda resta algum conflito e inspecione a resolução preparada:

git status
git diff --cached

O git status não deve mais listar caminhos não resolvidos. Leia o diff preparado e confirme se a alteração pretendida está presente e se não há marcadores de conflito ou edições acidentais. O git diff --cached exibe as alterações preparadas; o Git diff documenta essa opção de revisão. Se encontrar um erro, edite o arquivo, prepare-o novamente e revise o diff mais uma vez.

4. Continue o cherry-pick

Quando todos os conflitos estiverem resolvidos e preparados, execute:

git cherry-pick --continue

O Git retoma a operação pausada e, quando bem-sucedido, registra a alteração do cherry-pick como um novo commit. Se o Git abrir um editor para a mensagem de commit, salve e feche-o usando os controles normais desse editor. Em seguida, verifique git status e revise o commit mais recente, se necessário:

git status
git log -1 --oneline

Para uma sequência de commits aplicados via cherry-pick, --continue prossegue com a operação; um commit posterior também pode parar devido a conflitos. Resolva e prepare os conflitos desse commit da mesma maneira. O Git documenta --continue para retomar um cherry-pick que falhou e --skip para omitir o commit atual. Use --skip somente quando você desejar intencionalmente omitir a alteração daquele commit, e não como um atalho para arquivos não resolvidos. Opções do git cherry-pick

Se preferir interromper

Se decidir que o cherry-pick não deve prosseguir, execute git cherry-pick --abort. O Git documenta isso como o cancelamento da operação e o retorno ao estado anterior ao início da sequência. Se você tinha trabalho local antes de começar, verifique-o depois com git status; não use comandos de redefinição (reset) destrutivos para contornar a falta de compreensão do estado atual. Git cherry-pick

Uma regra prática útil para interromper é simples: continue apenas depois de entender o conteúdo pretendido de cada arquivo em conflito e de ter revisado o resultado preparado. Se a intenção do código não estiver clara, mantenha o estado pausado e peça orientações específicas do projeto antes de criar o commit.

Fontes