Como posso visualizar uma mesclagem no git?

Eu tenho um ramo git (a linha principal, por exemplo) e quero mesclar em outro ramo de desenvolvimento. Ou eu?

Para decidir se realmente quero mesclar esse ramo, gostaria de ver algum tipo de visualização do que a mesclagem fará. De preferência com a capacidade de ver a lista de confirmações que estão sendo aplicadas.

Até agora, o melhor que posso fazer é merge --no-ff --no-commite então diff HEAD.

Descobri que a solução que melhor funciona para mim é apenas executar a mesclagem e abortá-la se houver conflitos . Essa sintaxe específica parece limpa e simples para mim. Esta é a Estratégia 2 abaixo.

No entanto, se você deseja garantir que você não estrague sua ramificação atual ou simplesmente não está pronto para mesclar, independentemente da existência de conflitos, basta criar uma nova sub ramificação e mesclar isso:

Estratégia 1: A maneira segura - fundir um ramo temporário:

git checkout mybranch
git checkout -b mynew-temporary-branch
git merge some-other-branch

Dessa forma, você pode simplesmente jogar fora o ramo temporário se quiser apenas ver quais são os conflitos. Você não precisa se preocupar em "abortar" a mesclagem e pode voltar ao seu trabalho - basta fazer checkout de 'mybranch' novamente e você não terá nenhum código mesclado ou conflitos de mesclagem em sua ramificação.

Isso é basicamente um teste a seco.

Estratégia 2: quando você definitivamente deseja mesclar, mas apenas se não houver conflitos

git checkout mybranch
git merge some-other-branch

Se o git relatar conflitos (e SOMENTE SE EXISTIR conflitos), você poderá:

git merge --abort

Se a mesclagem for bem-sucedida, você não poderá abortá-la (somente redefinir).

Se você não estiver pronto para mesclar, use o caminho mais seguro acima.

[EDIT: 2016-Nov - Troquei a estratégia 1 por 2, porque parece que a maioria das pessoas está procurando "o caminho seguro". A estratégia 2 agora é mais uma observação de que você pode simplesmente interromper a mesclagem se a mesclagem tiver conflitos com os quais você não está pronto para lidar. Lembre-se de ler comentários!]

• git log ..otherbranch
  • lista de alterações que serão mescladas na ramificação atual.
• git diff ...otherbranch
  • diff do ancestral comum (base de mesclagem) para a cabeça do que será mesclado. Observe os três pontos , que têm um significado especial em comparação com dois pontos (veja abaixo).
• gitk ...otherbranch
  • representação gráfica dos ramos desde que foram mesclados da última vez.

String vazia implica HEAD, é por isso que apenas em ..otherbranchvez de HEAD..otherbranch.

Os dois vs. três pontos têm um significado ligeiramente diferente para diff do que para os comandos que listam revisões (log, gitk etc.). Para log e outros, dois pontos ( a..b) significa tudo o que está dentro, bmas não ae três pontos ( a...b) significa tudo o que está em apenas um de aou b. Mas diff trabalha com duas revisões e, nesse caso, o caso mais simples representado por dois pontos ( a..b) é uma diferença simples de aaté be três pontos ( a...b) diferença média entre o ancestral comum e b( git diff $(git merge-base a b)..b).

Se você é como eu, está procurando o equivalente a svn update -n. A seguir, parece fazer o truque. Observe que não se esqueça de fazer o git fetchprimeiro, para que seu repositório local tenha as atualizações apropriadas para comparação.

$ git fetch origin
$ git diff --name-status origin/master
D       TableAudit/Step0_DeleteOldFiles.sh
D       TableAudit/Step1_PopulateRawTableList.sh
A       manbuild/staff_companies.sql
M       update-all-slave-dbs.sh

ou se você quiser um diff da sua cabeça para o controle remoto:

$ git fetch origin
$ git diff origin/master

Na IMO, esta solução é muito mais fácil e menos propensa a erros (e, portanto, muito menos arriscada) do que a solução principal que propõe "mesclar e abortar".

A maioria das respostas aqui exige um diretório de trabalho limpo e várias etapas interativas (ruins para scripts), ou não funciona para todos os casos, por exemplo, mesclagens anteriores que já trazem algumas das alterações pendentes para o seu ramo de destino, ou escolhas mesmo.

Para realmente ver o que mudaria na masterramificação se você se unisse developa ela, agora:

git merge-tree $(git merge-base master develop) master develop

Como é um comando de encanamento, não adivinha o que você quer dizer, você precisa ser explícito. Também não coloriza a saída ou usa seu pager, portanto, o comando completo seria:

git merge-tree $(git merge-base master develop) master develop | colordiff | less -R

- https://git.seveas.net/previewing-a-merge-result.html

(obrigado a David Normington pelo link)

PS:

Se você obter conflitos de mesclagem, eles aparecerão com os marcadores de conflito usuais na saída, por exemplo:

$ git merge-tree $(git merge-base a b ) a b 
added in both
  our    100644 78981922613b2afb6025042ff6bd878ac1994e85 a
  their  100644 61780798228d17af2d34fce4cfbdf35556832472 a
@@ -1 +1,5 @@
+<<<<<<< .our
 a
+=======
+b
+>>>>>>> .their

O usuário @dreftymac faz uma boa observação: isso não é adequado para scripts, porque você não pode capturar isso facilmente a partir do código de status. Os marcadores de conflito podem ser bem diferentes, dependendo da circunstância (excluídos x modificados etc.), o que também dificulta o grep. Cuidado.

Se você já buscou as alterações, o meu favorito é:

git log ...@{u}

Isso precisa do git 1.7.x, no entanto, acredito. A @{u}notação é uma "abreviação" para o ramo upstream, por isso é um pouco mais versátil do que git log ...origin/master.

Nota: Se você usar o zsh e o glog estendido, provavelmente precisará fazer algo como:

git log ...@\{u\}

Adicionando às respostas existentes, um alias pode ser criado para mostrar o diff e / ou log antes de uma mesclagem. Muitas respostas omitem o que fetchdeve ser feito antes de "visualizar" a mesclagem; este é um alias que combina essas duas etapas em uma (emulando algo semelhante ao mercurial's hg incoming/ outgoing)

Portanto, com base em " git log ..otherbranch", você pode adicionar o seguinte a ~/.gitconfig:

...
[alias]
    # fetch and show what would be merged (use option "-p" to see patch)
    incoming = "!git remote update -p; git log ..@{u}"

Para simetria, o alias a seguir pode ser usado para mostrar o que foi confirmado e seria enviado antes de ser enviado:

    # what would be pushed (currently committed)
    outgoing = log @{u}..

E então você pode executar " git incoming" para mostrar muitas alterações ou " git incoming -p" para mostrar o patch (ou seja, o "diff") " git incoming --pretty=oneline", para obter um resumo conciso, etc. Você pode (opcionalmente) executar " git pull" para realmente se fundem. (Embora você já tenha buscado, a mesclagem pode ser feita diretamente.)

Da mesma forma, " git outgoing" mostra o que seria enviado se você executasse " git push".

git log currentbranch..otherbranchfornecerá a lista de confirmações que entrarão na ramificação atual se você fizer uma mesclagem. Os argumentos usuais para registrar, que fornecem detalhes sobre as confirmações, fornecerão mais informações.

git diff currentbranch otherbranchlhe dará a diferença entre os dois commits que se tornarão um. Será um diff que fornece tudo o que será mesclado.

Isso ajudaria?

Solicitação de recebimento - usei a maioria das idéias já enviadas, mas uma que também uso com frequência é (especialmente se for de outro desenvolvedor) fazer uma solicitação de recebimento que fornece uma maneira útil de revisar todas as alterações em uma mesclagem antes que seja necessário Lugar, colocar. Eu sei que o GitHub não é o git, mas com certeza é útil.

A menos que efetue a mesclagem de maneira descartável (consulte a resposta da Kasapo), não parece haver uma maneira confiável de ver isso.

Dito isto, aqui está um método que se aproxima marginalmente:

git log TARGET_BRANCH...SOURCE_BRANCH --cherry

Isso fornece uma indicação justa de quais confirmações entrarão na mesclagem. Para ver as diferenças, adicione -p. Para ver os nomes dos arquivos, adicionar qualquer um --raw, --stat, --name-only, --name-status.

O problema com a git diff TARGET_BRANCH...SOURCE_BRANCHabordagem (consulte a resposta de Jan Hudec) é que você verá diferenças nas alterações já no seu ramo de destino se o ramo de origem contiver mesclagens cruzadas.

Talvez isso possa te ajudar ? git-diff-tree - Compara o conteúdo e o modo dos blobs encontrados através de dois objetos em árvore

Não quero usar o comando git merge como precursor da revisão de arquivos conflitantes. Não quero fazer uma mesclagem, quero identificar problemas em potencial antes de mesclar - problemas que a mesclagem automática pode ocultar de mim. A solução que eu tenho procurado é como o git cospe uma lista de arquivos que foram alterados nos dois ramos que serão mesclados no futuro, em relação a algum ancestral comum. Depois de ter essa lista, posso usar outras ferramentas de comparação de arquivos para explorar ainda mais as coisas. Pesquisei várias vezes e ainda não encontrei o que desejo em um comando git nativo.

Aqui está minha solução alternativa, caso isso ajude outras pessoas por aí:

Nesse cenário, tenho um ramo chamado controle de qualidade que possui muitas alterações desde o último lançamento de produção. Nosso último lançamento de produção está marcado com "15.20.1". Eu tenho outro ramo de desenvolvimento chamado new_stuff que desejo mesclar no ramo de controle de qualidade. O controle de qualidade e o new_stuff apontam para confirmações que "seguem" (conforme relatado pelo gitk) a tag 15.20.1.

git checkout QA
git pull
git diff 15.20.1 --name-only > QA_files
git checkout new_stuff
git pull
git diff 15.20.1 --name-only > new_stuff_files
comm -12 QA_files new_stuff_files

Aqui estão algumas discussões sobre o motivo pelo qual estou interessado em segmentar esses arquivos específicos:

Como posso confiar na mesclagem do Git?

/software/199780/how-far-do-you-trust-automerge