Resolver conflitos de mesclagem do Git em favor de suas alterações durante um pull

Como resolvo um conflito de mesclagem do git em favor de alterações puxadas?

Basicamente, preciso remover todas as alterações conflitantes de uma árvore de trabalho sem ter que passar por todos os conflitos por um git mergetooltempo mantendo todas as alterações sem conflitos. De preferência, fazendo isso enquanto puxa, não depois.

git pull -s recursive -X theirs <remoterepo or other repo>

Ou, simplesmente, para o repositório padrão:

git pull -X theirs

Se você já está em estado de conflito ...

git checkout --theirs path/to/file

Você pode usar a opção de estratégia "deles" recursiva :

git merge --strategy-option theirs

Do homem :

ours
    This option forces conflicting hunks to be auto-resolved cleanly by 
    favoring our version. Changes from the other tree that do not 
    conflict with our side are reflected to the merge result.

    This should not be confused with the ours merge strategy, which does 
    not even look at what the other tree contains at all. It discards 
    everything the other tree did, declaring our history contains all that
    happened in it.

theirs
    This is opposite of ours.

Nota: como a página de manual diz, a opção de estratégia de mesclagem "nossa" é muito diferente da estratégia de mesclagem "nossa" .

Se você já está em estado de conflito e deseja apenas aceitar todos :

git checkout --theirs .
git add .

Se você quiser fazer o oposto:

git checkout --ours .
git add .

Isso é bastante drástico, por isso, certifique-se de que realmente deseja limpar tudo dessa maneira antes de fazê-lo.

OK, imagine o cenário em que eu estava:

Você tenta um merge, ou talvez um cherry-pick, e é interrompido com

$ git cherry-pick 1023e24
error: could not apply 1023e24... [Commit Message]
hint: after resolving the conflicts, mark the corrected paths
hint: with 'git add <paths>' or 'git rm <paths>'
hint: and commit the result with 'git commit'

Agora, você visualiza o arquivo em conflito e não deseja realmente manter suas alterações. No meu caso acima, o arquivo estava em conflito com apenas uma nova linha que meu IDE havia adicionado automaticamente. Para desfazer suas alterações e aceitar as delas, a maneira mais fácil é:

git checkout --theirs path/to/the/conflicted_file.php
git add path/to/the/conflicted_file.php

O inverso disso (para substituir a versão recebida pela sua versão) é

git checkout --ours path/to/the/conflicted_file.php
git add path/to/the/conflicted_file.php

Surpreendentemente, não consegui encontrar essa resposta com muita facilidade na Internet.

As git pull -X theirsrespostas podem criar uma confirmação de mesclagem feia ou emitir um

erro: suas alterações locais nos seguintes arquivos seriam substituídas por mesclagem:

Se você deseja simplesmente ignorar quaisquer modificações locais nos arquivos do repositório, por exemplo, em um cliente que sempre deve ser um espelho de uma origem, execute isso (substitua masterpela ramificação desejada):

git fetch && git reset --hard origin/master

Como funciona? git fetchfaz git pullmas sem mesclar . Em seguida, git reset --hardfaz sua árvore de trabalho corresponder ao último commit. Todas as alterações locais nos arquivos no repositório serão descartadas , mas os novos arquivos locais serão deixados em paz.

Após a fusão do git, se você tiver conflitos e quiser o seu

git checkout --theirs .
git checkout --ours .

Para resolver todos os conflitos com a versão em uma ramificação específica:

git diff --name-only --diff-filter=U | xargs git checkout ${branchName}

Portanto, se você já está no estado de mesclagem e deseja manter a versão principal dos arquivos conflitantes:

git diff --name-only --diff-filter=U | xargs git checkout master

Por favor, não que às vezes isso não funcione :

git checkout - o nosso caminho / para / arquivo

ou

git checkout - seu caminho / para / arquivo

Eu fiz isso, assumindo que HEAD é nosso e MERGE_HEAD é deles

git checkout HEAD -- path/to/file

ou:

git checkout MERGE_HEAD -- path/to/file

Depois que fazemos isso e somos bons:

git add .

Se você quiser entender mais, consulte o maravilhoso post do torek aqui: git checkout --ours não remove arquivos da lista de arquivos não imersos

Usuários do IDE do código VS (Git integrado):

Se você deseja aceitar todas as alterações recebidas no arquivo de conflito , execute as seguintes etapas.

1. Go to command palette - Ctrl + Shift + P
2. Select the option - Merge Conflict: Accept All Incoming

Da mesma forma, você pode fazer outras opções, como Aceitar todos os dois, Aceitar todos os atuais etc.,

Eu tinha uma next-versionramificação de longa duração com toneladas de exclusões em arquivos que foram alteradosdevelop , arquivos que foram adicionados em locais diferentes nos dois ramos etc.

Eu queria levar todo o conteúdo do next-versionramo paradevelop , tudo em um imenso commit de mesclagem.

A combinação dos comandos acima que funcionou para mim foi:

git merge -X theirs next-version
# lots of files left that were modified on develop but deleted on next-version
git checkout next-version .
# files removed, now add the deletions to the commit
git add .
# still have files that were added on develop; in my case they are all in web/
git rm -r web

Não é uma resposta nova, apenas combina bits de muitas respostas, em parte para garantir que você pode precisar de todas essas respostas.

Se você já está em estado de conflito e não deseja fazer o checkout do caminho um por um. Você pode tentar

git merge --abort
git pull -X theirs

from https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging

Isso basicamente fará uma fusão falsa. Ele gravará um novo commit de mesclagem com os dois ramos como pais, mas nem olhará para o ramo no qual você está mesclando. Ele simplesmente registrará como resultado da mesclagem do código exato no seu ramo atual.

$ git merge -s ours mundo

Mesclagem feita pela estratégia 'nossa'.

$ git diff HEAD HEAD~

Você pode ver que não há diferença entre o ramo em que estávamos e o resultado da mesclagem.

Geralmente, isso pode ser útil para convencer o Git a pensar que um ramo já foi mesclado ao fazer uma mesclagem posteriormente. Por exemplo, digamos que você ramificou um ramo de lançamento e fez algum trabalho nele que desejará mesclar de volta ao seu ramo mestre em algum momento. Enquanto isso, algumas correções de bugs no mestre precisam ser portadas para o seu ramo de lançamento. Você pode mesclar o ramo de correções de erros no ramo de lançamento e também mesclar o mesmo ramo em seu ramo mestre (mesmo que a correção já esteja lá); portanto, quando você mesclar o ramo de lançamento mais tarde, não haverá conflitos com o ramo de correção.

Uma situação que considero útil se quiser que o mestre reflita as alterações de um novo ramo de tópico. Notei que -Xtheirs não se fundem sem conflitos em algumas circunstâncias ... por exemplo

$ git merge -Xtheirs topicFoo 

CONFLICT (modify/delete): js/search.js deleted in HEAD and modified in topicFoo. Version topicFoo of js/search.js left in tree.

Nesse caso, a solução que encontrei foi

$ git checkout topicFoo

do topicFoo, primeiro mescle no master usando a estratégia -s our, isso criará o commit falso que é apenas o estado do topicFoo. $ git merge -s nosso mestre

verifique a consolidação de mesclagem criada

$ git log

agora faça o checkout do ramo principal

$ git checkout master

mesclar o ramo do tópico de volta, mas desta vez usar a estratégia recursiva -Xtheirs, agora você apresentará um ramo mestre com o estado do topicFoo.

$ git merge -X theirs topicFoo