Existe uma opção git-merge --dry-run?

Estou me fundindo em um ramo remoto que pode ter muitos conflitos. Como posso saber se haverá conflitos ou não?

Eu não vejo nada como um --dry-runon git-merge.

Como observado anteriormente, passe o --no-commitsinalizador, mas para evitar um commit de avanço rápido, também passe --no-ffo seguinte:

$ git merge --no-commit --no-ff $BRANCH

Para examinar as alterações faseadas:

$ git diff --cached

E você pode desfazer a mesclagem, mesmo que seja uma mesclagem de avanço rápido:

$ git merge --abort

Eu apenas tive que implementar um método que encontre automaticamente conflitos entre um repositório e seu controle remoto. Essa solução mescla a memória para não tocar no índice nem na árvore de trabalho. Penso que esta é a forma mais segura possível de resolver este problema. Veja como funciona:

1. Busque o controle remoto no seu repositório. Por exemplo: git fetch origin master
2. Execute git merge-base: git merge-base FETCH_HEAD master
3. Execute a árvore de mesclagem git: git merge-tree mergebase master FETCH_HEAD(a base de fusão é o ID hexadecimal que a base de mesclagem imprimiu na etapa anterior)

Agora, suponha que você queira mesclar o mestre remoto com o mestre local, mas você pode usar quaisquer ramificações. git merge-treeexecutará a mesclagem na memória e imprimirá o resultado na saída padrão. Grep para o padrão <<ou >>. Ou você pode imprimir a saída em um arquivo e verificar isso. Se você encontrar uma linha que começa com 'alterado em ambos', provavelmente haverá um conflito.

Minha solução simples de força bruta para isso é:

1. Crie uma ramificação "pré-mestre" (do mestre, é claro)

2. Mesclar todas as coisas que você deseja neste pré-mestre.
   Então você pode ver como a fusão aconteceu sem tocar no mestre.

3. • Mesclar o pré-mestre no mestre OU
   • Mesclar todas as ramificações liberadas por aspirantes a mestre

Enfim, eu seguiria o conselho da @ orange80.

Desfazer uma mesclagem com o git é tão fácil que você nem precisa se preocupar com a execução a seco:

$ git pull $REMOTE $BRANCH
# uh oh, that wasn't right
$ git reset --hard ORIG_HEAD
# all is right with the world

EDIT: Como observado nos comentários abaixo, se você tiver alterações no diretório de trabalho ou na área de armazenamento temporário, provavelmente desejará armazená-las antes de fazer o procedimento acima (caso contrário, elas desaparecerão após o procedimento git resetacima)

Fiz um alias para fazer isso e funciona como um encanto, faço o seguinte:

 git config --global alias.mergetest '!f(){ git merge --no-commit --no-ff "$1"; git merge --abort; echo "Merge aborted"; };f '

Agora eu só ligo

git mergetest <branchname>

Para descobrir se há algum conflito.

Apenas diferencie sua ramificação atual em relação à ramificação remota, isso informará o que será alterado quando você fizer uma extração / mesclagem.

#see diff between current master and remote branch
git diff master origin/master

Eu uso o comando request-pull git para fazer isso. Ele permite que você veja todas as alterações que aconteceriam durante a mesclagem, mas sem fazer nada em seus repositórios locais ou remotos .

Por exemplo, imagine que você deseja mesclar um ramo chamado "feature-x" em seu ramo mestre

git request-pull master origin feature-x

mostrará um resumo do que aconteceria (sem fazer nada):

The following changes since commit fc01dde318:
    Layout updates (2015-06-25 11:00:47 +0200)
are available in the git repository at:
    http://fakeurl.com/myrepo.git/ feature-x
for you to fetch changes up to 841d3b41ad:
----------------------------------------------------------------
john (2):
    Adding some layout
    Refactoring
ioserver.js            |   8 +++---
package.json           |   7 +++++-
server.js              |   4 +--
layout/ldkdsd.js       | 277 +++++++++++++++++++++++++++++++++++++
4 files changed, 289 insertions(+), 7 deletions(-)
create mode 100644 layout/ldkdsd.js

Se você adicionar o -pparâmetro, também receberá o texto completo do patch, exatamente como se estivesse fazendo um diff git em cada arquivo alterado.

Estou surpreso que ninguém tenha sugerido o uso de patches ainda.

Digamos que você gostaria de testar uma mesclagem de your_branchdentro master(eu estou supondo que você tenha mastercheck-out):

$ git diff master your_branch > your_branch.patch
$ git apply --check your_branch.patch
$ rm your_branch.patch

Isso deve fazer o truque.

Se você receber erros como

error: patch failed: test.txt:1
error: test.txt: patch does not apply

isso significa que o patch não foi bem-sucedido e uma fusão produziria conflitos. Nenhuma saída significa que o patch está limpo e você poderá mesclar facilmente a ramificação

Observe que isso realmente não altera sua árvore de trabalho (além de criar o arquivo de correção, é claro, mas você pode excluí-lo com segurança depois). Na documentação do git-apply:

--check
    Instead of applying the patch, see if the patch is applicable to the
    current working tree and/or the index file and detects errors. Turns
    off "apply".

Observe para quem é mais esperto / mais experiente com o git do que eu: informe-me se eu estiver errado aqui e esse método mostra um comportamento diferente do que uma mesclagem regular. Parece estranho que, nos mais de 8 anos em que essa pergunta existisse, ninguém sugerisse essa solução aparentemente óbvia.

Isso pode ser interessante: Na documentação:

Se você tentou uma mesclagem que resultou em conflitos complexos e deseja recomeçar, é possível recuperar com o git merge --abort .

Mas você também pode fazê-lo da maneira ingênua (mas lenta):

rm -Rf /tmp/repository
cp -r repository /tmp/
cd /tmp/repository
git merge ...
...if successful, do the real merge. :)

(Nota: não funcionará apenas na clonagem em / tmp, você precisará de uma cópia para garantir que as alterações não confirmadas não entrem em conflito).

Estou ciente de que essa é uma pergunta antiga, mas é a primeira a aparecer em uma pesquisa no Google.

O Git introduziu uma opção --ff-only ao mesclar.

From: http://git-scm.com/docs/git-merge

---

--ff-only

Recuse-se a mesclar e sair com um status diferente de zero, a menos que o HEAD atual já esteja atualizado ou a mesclagem possa ser resolvida como um avanço rápido.

Fazer isso tentará mesclar e avançar rapidamente e, se não puder, interrompe e solicita que o avanço rápido não possa ser executado, mas deixa o ramo de trabalho intocado. Se puder avançar rapidamente, executará a mesclagem em sua ramificação de trabalho. Esta opção também está disponível em git pull. Assim, você pode fazer o seguinte:

git pull --ff-only origin branchA #See if you can pull down and merge branchA

git merge --ff-only branchA branchB #See if you can merge branchA into branchB

Eu uso o git log para ver o que mudou em um ramo de recurso do ramo mestre

git log does_this_branch..contain_this_branch_changes

por exemplo - para ver quais confirmações estão em um ramo de recurso que / não foi mesclado ao mestre:

git log master..feature_branch

Se você quiser avançar de B para A, certifique-se de que o git log B..A não mostre nada, ou seja, A não possui nada que B não possua. Mas mesmo que B..A possua alguma coisa, você ainda poderá mesclar sem conflitos, portanto, o acima mostra duas coisas: haverá um avanço rápido e, portanto, você não terá um conflito.

Minha solução é mesclar para trás.

Em vez de mesclar sua ramificação na ramificação "alvo" remota, mesclar essa ramificação na sua.

git checkout my-branch
git merge origin/target-branch

Você verá se há algum conflito e pode planejar como resolvê-lo.

Depois disso, você pode interromper a mesclagem via git merge --abortou (se não houver nenhum conflito e mesclagem) reverter para a consolidação anterior viagit reset --hard HEAD~1

Faça uma cópia temporária da sua cópia de trabalho, mescle-a e difira as duas.