Configurando e usando o Meld como seu diffitol e fusão

Embora muitas das informações nesta pergunta e resposta estejam disponíveis no StackOverflow , elas estão espalhadas por várias páginas e entre outras respostas erradas ou enganosas. Demorei um pouco para juntar tudo o que eu queria saber.

Existem muitos programas diferentes que podem ser usados ​​como o seu git difftool e mergetool, e certamente não há consenso sobre qual é o melhor (opiniões, requisitos e sistemas operacionais serão claramente diferentes).

O Meld é uma opção popular gratuita, de código aberto e de plataforma cruzada (UNIX / Linux, OSX, Windows), como mostra a pergunta StackOverflow : Qual é a melhor ferramenta de mesclagem visual para o Git? , em que a resposta que propõe Meld tem mais de 3 vezes os votos que qualquer outra ferramenta.

As 2 perguntas a seguir serão respondidas na minha resposta abaixo:

• Como faço para configurar e usar o Meld como meu diffitol git?
• Como configuro e uso o Meld como meu git mergetool?

Nota: Não é necessário usar o mesmo programa que o difftool e o mergetool; programas diferentes podem ser definidos para ambos.

Como faço para configurar e usar o Meld como meu diffitol git?

O git difftool exibe o diff usando um programa diff da GUI (por exemplo, Meld) em vez de exibir a saída do diff no seu terminal.

Embora você possa definir o programa GUI na linha de comando -t <tool> / --tool=<tool>, faz mais sentido configurá-lo em seu .gitconfigarquivo. [Nota: Veja as seções sobre como escapar aspas e caminhos do Windows na parte inferior.]

# Add the following to your .gitconfig file.
[diff]
    tool = meld
[difftool]
    prompt = false
[difftool "meld"]
    cmd = meld "$LOCAL" "$REMOTE"

[Nota: essas configurações não alterarão o comportamento das git diffquais continuarão funcionando normalmente.]

Você usa git difftoolexatamente da mesma maneira que você usa git diff. por exemplo

git difftool <COMMIT_HASH> file_name
git difftool <BRANCH_NAME> file_name
git difftool <COMMIT_HASH_1> <COMMIT_HASH_2> file_name

Se configurada corretamente, uma janela Meld será aberta, exibindo o diff usando uma interface GUI.

A ordem dos painéis da janela da GUI do Meld pode ser controlada pela ordem de $LOCALe $REMOTEpara cmd, ou seja, qual arquivo é mostrado no painel esquerdo e qual no painel direito. Se você quiser o contrário, troque-o assim:

    cmd = meld "$REMOTE" "$LOCAL"

Finalmente, a prompt = falselinha simplesmente impede que o git indique se você deseja iniciar o Meld ou não, por padrão, o git emitirá um prompt.

Como configuro e uso o Meld como meu git mergetool?

O git mergetool permite que você use um programa de mesclagem da GUI (por exemplo, Meld) para resolver os conflitos de mesclagem que ocorreram durante uma mesclagem.

Como o difftool, você pode definir o programa GUI na linha de comando usando -t <tool> / --tool=<tool>, mas, como antes, faz mais sentido configurá-lo em seu .gitconfigarquivo. [Nota: Veja as seções sobre como escapar aspas e caminhos do Windows na parte inferior.]

# Add the following to your .gitconfig file.
[merge]
    tool = meld
[mergetool "meld"]
    # Choose one of these 2 lines (not both!) explained below.
    cmd = meld "$LOCAL" "$MERGED" "$REMOTE" --output "$MERGED"
    cmd = meld "$LOCAL" "$BASE" "$REMOTE" --output "$MERGED"

Você NÃO usa git mergetoolpara executar uma mesclagem real. Antes de usar, git mergetoolvocê faz uma mesclagem da maneira usual com o git. por exemplo

git checkout master
git merge branch_name

Se houver um conflito de mesclagem, o git exibirá algo como isto:

$ git merge branch_name
Auto-merging file_name
CONFLICT (content): Merge conflict in file_name
Automatic merge failed; fix conflicts and then commit the result.

Neste ponto file_name, o arquivo será parcialmente mesclado com as informações de conflito de mesclagem (esse é o arquivo com todas as entradas >>>>>>>e <<<<<<<).

Agora, o Mergetool pode ser usado para resolver os conflitos de mesclagem. Você o inicia muito facilmente com:

git mergetool

Se configurada corretamente, uma janela Meld será aberta, exibindo 3 arquivos. Cada arquivo estará contido em um painel separado de sua interface GUI.

Na .gitconfigentrada de exemplo acima, 2 linhas são sugeridas como a [mergetool "meld"] cmdlinha. De fato, existem todos os tipos de maneiras para os usuários avançados configurarem a cmdlinha, mas isso está além do escopo desta resposta.

Essa resposta tem duas cmdlinhas alternativas que, entre elas, atenderão à maioria dos usuários e serão um bom ponto de partida para usuários avançados que desejam levar a ferramenta ao próximo nível de complexidade.

Primeiro, aqui está o que os parâmetros significam:

• $LOCAL é o arquivo na ramificação atual (por exemplo, mestre).
• $REMOTE é o arquivo no ramo que está sendo mesclado (por exemplo, branch_name).
• $MERGED é o arquivo parcialmente mesclado com as informações de conflito de mesclagem.
• $BASEé o ancestral de consolidação compartilhado de $LOCALe $REMOTE, ou seja, o arquivo como era quando o ramo que continha $REMOTEfoi criado originalmente.

Eu sugiro que você use:

[mergetool "meld"]
    cmd = meld "$LOCAL" "$MERGED" "$REMOTE" --output "$MERGED"

ou:

[mergetool "meld"]
    cmd = meld "$LOCAL" "$BASE" "$REMOTE" --output "$MERGED"
    # See 'Note On Output File' which explains --output "$MERGED".

A escolha é usar $MERGEDou $BASEentre $LOCALe $REMOTE.

De qualquer maneira Meld irá exibir 3 painéis com $LOCALe $REMOTEnos painéis esquerdo e direito e, ou $MERGEDou $BASEno painel central.

Nos dois casos, o painel do meio é o arquivo que você deve editar para resolver os conflitos de mesclagem. A diferença é exatamente em qual posição de edição inicial você prefere; $MERGEDpara o arquivo que contém o arquivo parcialmente mesclado com as informações de conflito de mesclagem ou $BASEpara o ancestral de confirmação compartilhado de $LOCALe $REMOTE. [Como as duas cmdlinhas podem ser úteis, mantenho as duas no meu .gitconfigarquivo. Na maioria das vezes, uso a $MERGEDlinha e a $BASElinha é comentada, mas o comentário pode ser trocado se eu quiser usar a $BASElinha.]

Nota No Arquivo de saída: não se preocupe que --output "$MERGED"é usado na cmdindependentemente de se $MERGEDou $BASEfoi utilizado no início da cmdlinha. A --outputopção simplesmente informa ao Meld em que nome do arquivo git deseja que o arquivo de resolução de conflitos seja salvo. O Meld salvará as edições de conflito nesse arquivo, independentemente de você usar $MERGEDou $BASEcomo seu ponto de edição inicial.

Após editar o painel do meio para resolver os conflitos de mesclagem, salve o arquivo e feche a janela Meld. O Git fará a atualização automaticamente e o arquivo na ramificação atual (por exemplo, mestre) agora conterá o que você acabou no painel do meio.

O git fará um backup do arquivo parcialmente mesclado com as informações de conflito de mesclagem anexando .origao nome do arquivo original. por exemplo file_name.orig. Depois de verificar se você está satisfeito com a mesclagem e executar os testes que desejar, o .origarquivo pode ser excluído.

Neste ponto, agora você pode fazer uma confirmação para confirmar as alterações.

Se, enquanto estiver editando os conflitos de mesclagem no Meld, você deseja abandonar o uso do Meld, saia do Meld sem salvar o arquivo de resolução da mesclagem no painel do meio. O git responderá com a mensagem file_name seems unchangede perguntará Was the merge successful? [y/n], se você responder n, a resolução do conflito de mesclagem será abortada e o arquivo permanecerá inalterado. Observe que se você salvou o arquivo no Meld a qualquer momento, não receberá o aviso nem o prompt do git. [É claro que você pode simplesmente excluir o arquivo e substituí-lo pelo .origarquivo de backup que o git criou para você.]

Se você tiver mais de um arquivo com conflitos de mesclagem, o git abrirá uma nova janela Meld para cada um, um após o outro até que tudo esteja pronto. Eles não serão todos abertos ao mesmo tempo, mas quando você terminar de editar os conflitos em um e fechar o Meld, o git abrirá o próximo e assim sucessivamente, até que todos os conflitos de mesclagem sejam resolvidos.

Seria sensato criar um projeto fictício para testar o uso git mergetoolantes de usá-lo em um projeto ao vivo . Certifique-se de usar um nome de arquivo que contenha um espaço em seu teste, caso seu sistema operacional exija que você escape das aspas na cmdlinha, veja abaixo.

Escapando caracteres de aspas

Alguns sistemas operacionais podem precisar ter as aspas em cmdescape. Usuários menos experientes devem lembrar que as linhas de comando de configuração devem ser testadas com nomes de arquivos que incluem espaços e, se as cmdlinhas não funcionarem com os nomes de arquivos que incluem espaços, tente escapar das aspas. por exemplo

cmd = meld \"$LOCAL\" \"$REMOTE\"

Em alguns casos, pode ser necessário um escape de cotação mais complexo. O primeiro dos links de caminho do Windows abaixo contém um exemplo de escape triplo de cada citação. É um tédio, mas às vezes necessário. por exemplo

cmd = meld \\\"$LOCAL\\\" \\\"$REMOTE\\\"

Caminhos do Windows

Os usuários do Windows provavelmente precisarão de uma configuração extra adicionada às cmdlinhas Meld . Eles podem precisar usar o caminho completo para meldc, projetado para ser chamado no Windows a partir da linha de comando, ou podem precisar ou querer usar um wrapper. Eles devem ler as páginas StackOverflow vinculadas abaixo, sobre como definir a cmdlinha Meld correta para Windows. Como sou usuário de Linux, não consigo testar as várias cmdlinhas do Windows e não tenho mais informações sobre o assunto além de recomendar usar meus exemplos com a adição de um caminho completo para o Meld ou meldc, ou adicionar a pasta do programa Meld ao seu path.

• Git Diff e Meld no Windows
• Como definir o Meld como git mergetool
• Git mergetool com Meld no Windows

Ignorando o espaço em branco à direita com Meld

O Meld possui várias preferências que podem ser configuradas na GUI.

Na Text Filtersguia preferências, existem vários filtros úteis para ignorar coisas como comentários ao executar uma comparação. Embora existam filtros para ignorar All whitespacee Leading whitespace, não haja Trailing whitespacefiltro para ignorar (isso foi sugerido como uma adição na lista de discussão Meld, mas não está disponível na minha versão).

Ignorar o espaço em branco à direita geralmente é muito útil, especialmente ao colaborar, e pode ser adicionado manualmente facilmente com uma simples expressão regular na Text Filtersguia Preferências do Meld .

# Use either of these regexes depending on how comprehensive you want it to be.
[ \t]*$
[ \t\r\f\v]*$

Eu espero que isso ajude a todos.

Enquanto a outra resposta estiver correta, aqui está a maneira mais rápida de seguir em frente e configurar o Meld como sua ferramenta visual diff. Basta copiar / colar este:

git config --global diff.tool meld
git config --global difftool.prompt false

Agora execute git difftoolem um diretório e o Meld será iniciado para cada arquivo diferente.

Nota lateral: O Meld é surpreendentemente lento na comparação de arquivos CSV, e nenhuma ferramenta de comparação do Linux que encontrei é mais rápida que essa ferramenta do Windows chamada Compare It! (última atualização em 2010).

Para Windows . Execute estes comandos no Git Bash:

git config --global diff.tool meld
git config --global difftool.meld.path "C:\Program Files (x86)\Meld\Meld.exe"
git config --global difftool.prompt false

git config --global merge.tool meld
git config --global mergetool.meld.path "C:\Program Files (x86)\Meld\Meld.exe"
git config --global mergetool.prompt false

(Atualize o caminho do arquivo Meld.exe se o seu for diferente.)

Para Linux . Execute estes comandos no Git Bash:

git config --global diff.tool meld
git config --global difftool.meld.path "/usr/bin/meld"
git config --global difftool.prompt false

git config --global merge.tool meld
git config --global mergetool.meld.path "/usr/bin/meld"
git config --global mergetool.prompt false

Você pode verificar o caminho de Meld usando este comando:

which meld

Eu prefiro configurar o meld como um comando separado, assim:

git config --global alias.meld '!git difftool -t meld --dir-diff'

Isso o torna semelhante ao script git-meld.pl aqui: https://github.com/wmanley/git-meld

Você pode então apenas correr

git meld

Para o Windows 10, tive que colocar isso no meu .gitconfig:

[merge]
  tool = meld
[mergetool "meld"]
  cmd = 'C:/Program Files (x86)/Meld/Meld.exe' $LOCAL $BASE $REMOTE --output=$MERGED
[mergetool]
  prompt = false

Tudo o mais que você precisa saber está escrito nesta super resposta por mattst acima.

PS: Por alguma razão, isso funcionou apenas com o Meld 3.18.x, o Meld 3.20.x me deu um erro.

Esta é uma resposta que visa principalmente desenvolvedores que usam o Windows, pois a sintaxe do caminho da ferramenta diff difere de outras plataformas.

Eu uso o Kdiff3 como o git mergetool, mas para configurar o git difftool como Meld, instalei a versão mais recente do Meld no Meldmerge.org e adicionei o seguinte ao meu .gitconfig global usando:

git config --global -e

Observe que, se você preferir o Sublime Text 3 em vez do Vim padrão como core ditor, poderá adicioná-lo ao arquivo .gitconfig:

[core]
editor = 'c:/Program Files/Sublime Text 3/sublime_text.exe'

Então você adiciona inn Meld como difftool

[diff]
tool = meld
guitool = meld 

[difftool "meld"]
cmd = \"C:/Program Files (x86)/Meld/Meld.exe\" \"$LOCAL\" \"$REMOTE\" --label \"DIFF 
(ORIGINAL MY)\"
prompt = false
path = C:\\Program Files (x86)\\Meld\\Meld.exe

Observe a barra no cmd acima; no Windows, é necessário.

Também é possível configurar um alias para mostrar o diff atual do git com um opção --dir-diff . Isso listará os arquivos alterados dentro do Meld, o que é útil quando você alterou vários arquivos (um cenário muito comum).

O alias se parece com isso dentro do arquivo .gitconfig, abaixo da seção [alias] :

showchanges = difftool --dir-diff

Para mostrar as alterações que fiz no código, basta digitar o seguinte comando:

git showchanges

A imagem a seguir mostra como esta opção --dir-diff pode mostrar uma lista de arquivos alterados (exemplo):

Então é possível clicar em cada arquivo e mostrar as alterações dentro do Meld.

Pode ser complicado calcular um diff em sua cabeça a partir das diferentes seções em $ MERGED e aplicá-lo. Na minha configuração, o meld ajuda mostrando essas diferenças visualmente, usando:

[merge]
    tool = mymeld
    conflictstyle = diff3

[mergetool "mymeld"]
    cmd = meld --diff $BASE $REMOTE --diff $REMOTE $LOCAL --diff $LOCAL $MERGED

Parece estranho, mas oferece um fluxo de trabalho muito conveniente, usando três guias:

1. na guia 1, você vê (da esquerda para a direita) a alteração que deve fazer na guia 2 para resolver o conflito de mesclagem.

2. no lado direito da guia 2, você aplica a "alteração que deve fazer" e copia todo o conteúdo do arquivo na área de transferência (usando ctrl-a e ctrl-c).

3. na guia 3, substitua o lado direito pelo conteúdo da área de transferência. Se tudo estiver correto, você verá agora - da esquerda para a direita - a mesma alteração mostrada na guia 1 (mas com contextos diferentes). Salve as alterações feitas nesta guia.

Notas:

• não edite nada na guia 1
• não salve nada na guia 2 porque isso produzirá pop-ups irritantes na guia 3