Quando digito git diff, quero visualizar a saída com a minha ferramenta visual diff de escolha (SourceGear "diffmerge" no Windows). Como eu configuro o git para fazer isso?

Desde o Git1.6.3, você pode usar o script git difftool : veja minha resposta abaixo .

Pode ser que este artigo o ajude. Aqui estão as melhores partes:

Existem duas maneiras diferentes de especificar uma ferramenta de comparação externa.

O primeiro é o método que você usou, definindo a variável GIT_EXTERNAL_DIFF. No entanto, a variável deve apontar para o caminho completo do executável. Além disso, o executável especificado por GIT_EXTERNAL_DIFF será chamado com um conjunto fixo de 7 argumentos:

path old-file old-hex old-mode new-file new-hex new-mode

Como a maioria das ferramentas diff requer uma ordem diferente (e apenas alguns) dos argumentos, você provavelmente precisará especificar um script de wrapper, que por sua vez chama a ferramenta diff real.

O segundo método, que eu prefiro, é configurar a ferramenta diff externa via "git config" . Aqui está o que eu fiz:

1) Crie um script de wrapper "git-diff-wrapper.sh" que contenha algo como

-->8-(snip)--
#!/bin/sh

# diff is called by git with 7 parameters:
# path old-file old-hex old-mode new-file new-hex new-mode

"<path_to_diff_executable>" "$2" "$5" | cat
--8<-(snap)--

Como você pode ver, apenas o segundo argumento ("arquivo antigo") e o quinto ("arquivo novo") serão passados ​​para a ferramenta diff.

2) Tipo

$ git config --global diff.external <path_to_wrapper_script>

no prompt de comando, substituindo pelo caminho para "git-diff-wrapper.sh", para que seu ~ / .gitconfig contenha

-->8-(snip)--
[diff]
    external = <path_to_wrapper_script>
--8<-(snap)--

Certifique-se de usar a sintaxe correta para especificar os caminhos para o script do wrapper e a ferramenta diff, ou seja, use barras invertidas em vez de barras invertidas. No meu caso, eu tenho

[diff]
    external = \"c:/Documents and Settings/sschuber/git-diff-wrapper.sh\"

em .gitconfig e

"d:/Program Files/Beyond Compare 3/BCompare.exe" "$2" "$5" | cat

no script do wrapper. Cuidado com o "gato" à direita!

(Suponho que ' | cat' seja necessário apenas para alguns programas que talvez não retornem um status de retorno adequado ou consistente. Você pode tentar sem o gato à direita, se sua ferramenta diff tiver um status de retorno explícito)

( Diomidis Spinellis acrescenta nos comentários :

O catcomando é necessário, porque diff(1), por padrão, sai com um código de erro se os arquivos diferirem.
O Git espera que o programa diff externo saia com um código de erro apenas se ocorrer um erro real, por exemplo, se ficar sem memória.
Ao canalizar, a saída gitpara cato código de erro diferente de zero é mascarada.
Mais eficientemente, o programa pode ser executado exitcom um argumento de 0.)

Que (o artigo citado acima) é a teoria para a ferramenta externa definida através do arquivo de configuração (não através da variável de ambiente).
Na prática (ainda para a definição do arquivo de configuração da ferramenta externa), você pode consultar:

• Como configuro o DiffMerge com o msysgit / gitk? que ilustra as configurações concretas do DiffMerge e WinMerge para MsysGit e gitk
• Como posso configurar um editor para trabalhar com o Git no Windows? para a definição do Notepad ++ como um editor externo.

Para concluir minha resposta de configuração "diff.external" anterior acima:

Conforme mencionado por Jakub , o Git1.6.3 introduziu o git difftool , originalmente proposto em setembro de 2008:

USAGE = '[--tool=tool] [--commit=ref] [--start=ref --end=ref] [--no-prompt] [file to merge]'
(Veja --extcmdna última parte desta resposta)

$LOCALcontém o conteúdo do arquivo a partir da revisão inicial e $REMOTEo conteúdo do arquivo na revisão final.
$BASEcontém o conteúdo do arquivo no wor

É basicamente git-mergetoolmodificado para operar no índice git / worktree.

O caso de uso habitual para este script é quando você quer ter encenado ou alterações unstaged e você gostaria de ver as alterações em um visualizador de comparação lado-a-lado (por exemplo xxdiff, tkdiff, etc).

git difftool [<filename>*]

Outro caso de uso é quando você deseja ver as mesmas informações, mas está comparando confirmações arbitrárias (essa é a parte em que a análise de revarg pode ser melhor)

git difftool --start=HEAD^ --end=HEAD [-- <filename>*]

O último caso de uso é quando você deseja comparar sua árvore de trabalho atual com algo diferente de HEAD (por exemplo, uma tag)

git difftool --commit=v1.0.0 [-- <filename>*]

Nota: desde o Git 2.5, git config diff.tool winmergeé suficiente!
Veja " git mergetool winmerge "

E desde o Git 1.7.11 , você tem a opção --dir-diffde gerar ferramentas de diferenças externas que podem comparar duas hierarquias de diretório por vez após preencher dois diretórios temporários, em vez de executar uma instância da ferramenta externa uma vez por par de arquivos.

Antes do Git 2.5:

Caso prático para configurar difftoolcom sua ferramenta diff personalizada:

C:\myGitRepo>git config --global diff.tool winmerge
C:\myGitRepo>git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\""
C:\myGitRepo>git config --global difftool.prompt false

Com o winmerge.sh armazenado em um diretório, parte do seu PATH:

#!/bin/sh
echo Launching WinMergeU.exe: $1 $2
"C:/Program Files/WinMerge/WinMergeU.exe" -u -e "$1" "$2" -dl "Local" -dr "Remote"

Se você tiver outra ferramenta (kdiff3, P4Diff, ...), crie outro script de shell e a difftool.myDiffTool.cmddiretiva de configuração apropriada .
Então você pode alternar facilmente as ferramentas com a diff.toolconfiguração.

Você também tem esta entrada de blog de Dave para adicionar outros detalhes.
(Ou esta pergunta para as winmergeuopções)

O interesse por essa configuração é o winmerge.shscript : você pode personalizá-lo para levar em consideração casos especiais.

Veja, por exemplo , a resposta de David Marble abaixo para um exemplo que lida com:

• novos arquivos na origem ou destino
• arquivos removidos na origem ou destino

Como Kem Mason menciona em sua resposta , você também pode evitar qualquer invólucro usando a --extcmdopção :

--extcmd=<command>

Especifique um comando personalizado para exibir as diferenças. git-difftoolignora os padrões configurados e é executado $command $LOCAL $REMOTEquando esta opção é especificada.

Por exemplo, é assim que gitké possível executar / usar qualquer diffferramenta .

No espírito de responder perguntas que são um pouco diferentes do que foram feitas. Experimente esta solução:

$ meld my_project_using_git

Meld entende git e fornece navegação pelas mudanças recentes.

Com o novo git difftool , é tão simples quanto adicionar isso ao seu arquivo .gitconfig :

[diff]
    tool = any-name
[difftool "any-name"]
    cmd = "\"C:/path/to/my/ext/diff.exe\" \"$LOCAL\" \"$REMOTE\""

Opcionalmente, adicione também:

[difftool]
    prompt = false

Verifique também o diffall , um script simples que escrevi para estender o comportamento diff padrão irritante (IMO) de abrir cada um em série.

O .gitconfig global no Windows está em %USERPROFILE%\.gitconfig

Desde o git versão 1.6.3, existe o " git difftool ", que você pode configurar para usar sua ferramenta gráfica favorita do diff. Atualmente, o suporte imediato é kdiff3, kompare, tkdiff, meld, xxdiff, emergem, vimdiff, gvimdiff, esmerge, difuso e opendiff ; se a ferramenta que você deseja usar não estiver nessa lista, você sempre poderá usar a difftool.<tool>.cmdopção de configuração ' '.

"git difftool" aceita as mesmas opções que "git diff".

Eu tenho uma adição a isso. Eu gosto de usar regularmente um aplicativo diff que não é suportado como uma das ferramentas padrão (por exemplo, caleidoscópio), via

git difftool -t

Também gosto de ter o padrão diffapenas como a linha de comando regular, portanto, definir a GIT_EXTERNAL_DIFFvariável não é uma opção.

Você pode usar um diffaplicativo arbitrário como único com este comando:

git difftool --extcmd=/usr/bin/ksdiff

Ele apenas passa os 2 arquivos para o comando que você especificar, então você provavelmente também não precisa de um wrapper.

Com base na resposta do VonC para lidar com remoções e adições de arquivos, use os seguintes comandos e scripts:

> git config --global diff.tool winmerge
> git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\" \"$BASE\""
> git config --global difftool.prompt false

O que é o mesmo que colocar isso na sua global .gitconfig:

[diff]
    tool = winmerge
[difftool "winmerge"]
    cmd = winmerge.bat "$LOCAL" "$REMOTE" "$BASE"
[difftool]
    prompt = false

Em seguida, coloque o seguinte no winmerge.shqual deve estar no seu caminho:

#!/bin/sh
NULL="/dev/null"
if [ "$2" = "$NULL" ] ; then
    echo "removed: $3"
elif [ "$1" = "$NULL" ] ; then
    echo "added: $3"
else
    echo "changed: $3"
    "C:/Program Files (x86)/WinMerge/WinMergeU.exe" -e -ub -dl "Base" -dr "Mine" "$1" "$2"
fi

Solução para Windows / msys git

Depois de ler as respostas, descobri uma maneira mais simples que envolve alterar apenas um arquivo.

1. Crie um arquivo em lotes para chamar seu programa diff, com os argumentos 2 e 5. Esse arquivo deve estar em algum lugar no seu caminho. (Se você não souber onde está, coloque-o em c: \ windows). Chame-o, por exemplo, "gitdiff.bat". O meu é:

   @echo off
   REM This is gitdiff.bat
   "C:\Program Files\WinMerge\WinMergeU.exe" %2 %5
   

2. Defina a variável de ambiente para apontar para seu arquivo em lotes. Por exemplo: GIT_EXTERNAL_DIFF=gitdiff.bat. Ou através do PowerShell, digitando git config --global diff.external gitdiff.bat.

   É importante não usar aspas ou especificar qualquer informação de caminho, caso contrário não funcionará. É por isso que o gitdiff.bat deve estar no seu caminho.

Agora, quando você digita "git diff", ele invocará seu visualizador de diferenças externas.

Se você está fazendo isso através do cygwin, pode ser necessário usar o cygpath :

$ git config difftool.bc3.cmd "git-diff-bcomp-wrapper.sh \$LOCAL \$REMOTE"
$ cat git-diff-bcomp-wrapper.sh
#!/bin/sh
"c:/Program Files (x86)/Beyond Compare 3/BComp.exe" `cygpath -w $1` `cygpath -w $2`

Depois de examinar algumas outras ferramentas de diferenças externas, descobri que a diffvisualização no IntelliJ IDEA (e no Android Studio) é a melhor para mim.

Etapa 1 - configure o IntelliJ IDEA para ser executado na linha de comando

Se você deseja usar o IntelliJ IDEA como sua ferramenta diff, você deve primeiro configurar o IntelliJ IDEA para ser executado na linha de comando, seguindo as instruções aqui :

No macOS ou UNIX:

1. Verifique se o IntelliJ IDEA está em execução.
2. No menu principal, escolha Tools | Create Command-line Launcher. A caixa de diálogo Criar script do iniciador é aberta, com o caminho sugerido e o nome do script do iniciador. Você pode aceitar o padrão ou especificar seu próprio caminho. Anote isso, pois você precisará mais tarde. Fora do IntelliJ IDEA, inclua o caminho e o nome do script do iniciador no seu caminho.

No Windows:

1. Especifique o local do executável do IntelliJ IDEA na variável de ambiente do sistema Path. Nesse caso, você poderá chamar o executável do IntelliJ IDEA e outros comandos do IntelliJ IDEA de qualquer diretório.

Etapa 2 - configure o git para usar o IntelliJ IDEA como o difftool

Seguindo as instruções nesta postagem do blog :

Bater

export INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
PATH=$IDEA_HOME $PATH

Peixe

set INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
set PATH $INTELLIJ_HOME $PATH

Agora adicione o seguinte à sua configuração do git:

[merge]
   tool = intellij
[mergetool "intellij"]
   cmd = idea merge $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE") $(cd $(dirname "$BASE") && pwd)/$(basename "$BASE") $(cd $(dirname "$MERGED") && pwd)/$(basename "$MERGED")
   trustExitCode = true
[diff]
   tool = intellij
[difftool "intellij"]
   cmd = idea diff $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE")

Você pode experimentá-lo com git difftoolougit difftool HEAD~1

isso funciona para mim no Windows 7. Não há necessidade de scripts sh intermediários

conteúdo de .gitconfig:

    [diff]
      tool = kdiff3

    [difftool]
       prompt = false

    [difftool "kdiff3"]
      path = C:/Program Files (x86)/KDiff3/kdiff3.exe
      cmd = "$LOCAL" "$REMOTE"

Um breve resumo das ótimas respostas acima:

git difftool --tool-help
git config --global diff.tool <chosen tool>
git config --global --add difftool.prompt false

Em seguida, use-o digitando (opcionalmente, especificando o nome do arquivo):

git difftool

Introdução

Para referência, gostaria de incluir minha variação na resposta do VonC. Lembre-se de que estou usando a versão MSys do Git (1.6.0.2 no momento) com PATH modificado e executando o próprio Git no Powershell (ou cmd.exe), não no shell Bash.

Eu introduzi um novo comando gitdiff. A execução desse comando redireciona temporariamente git diffpara usar um programa visual diferencial de sua escolha (ao contrário da solução do VonC que faz isso permanentemente). Isso me permite ter tanto a funcionalidade padrão do Git diff ( git diff) quanto a funcionalidade visual do diff ( gitdiff). Ambos os comandos usam os mesmos parâmetros, portanto, por exemplo, para diferenciar visualmente as alterações em um arquivo específico, você pode digitar

gitdiff path/file.txt

Configuração

Observe que $GitInstallé usado como um espaço reservado para o diretório em que o Git está instalado.

1. Crie um novo arquivo, $GitInstall\cmd\gitdiff.cmd

   @echo off
   setlocal
   for /F "delims=" %%I in ("%~dp0..") do @set path=%%~fI\bin;%%~fI\mingw\bin;%PATH%
   if "%HOME%"=="" @set HOME=%USERPROFILE%
   set GIT_EXTERNAL_DIFF=git-diff-visual.cmd
   set GIT_PAGER=cat
   git diff %*
   endlocal
   

2. Crie um novo arquivo $GitInstall\bin\git-diff-visual.cmd(substituindo o [visual_diff_exe]espaço reservado pelo caminho completo para o programa diff de sua escolha)

   @echo off
   rem diff is called by git with 7 parameters:
   rem path old-file old-hex old-mode new-file new-hex new-mode
   echo Diffing "%5"
   "[visual_diff_exe]" "%2" "%5"
   exit 0
   

3. Você está pronto agora. A execução a gitdiffpartir de um repositório Git agora deve chamar seu programa visual diff para cada arquivo que foi alterado.

Aqui está um arquivo em lotes que funciona para Windows - assume que o DiffMerge está instalado no local padrão, lida com x64, lida com a substituição de barra invertida conforme necessário e tem capacidade de se instalar. Deve ser fácil substituir o DiffMerge pelo seu programa diff favorito.

Para instalar:

gitvdiff --install 

gitvdiff.bat:

@echo off

REM ---- Install? ----
REM To install, run gitvdiff --install

if %1==--install goto install



REM ---- Find DiffMerge ----

if DEFINED ProgramFiles^(x86^) (
    Set DIFF="%ProgramFiles(x86)%\SourceGear\DiffMerge\DiffMerge.exe"
) else (
    Set DIFF="%ProgramFiles%\SourceGear\DiffMerge\DiffMerge.exe"
)



REM ---- Switch forward slashes to back slashes ----

set oldW=%2
set oldW=%oldW:/=\%
set newW=%5
set newW=%newW:/=\%


REM ---- Launch DiffMerge ----

%DIFF% /title1="Old Version" %oldW% /title2="New Version" %newW%

goto :EOF



REM ---- Install ----
:install
set selfL=%~dpnx0
set selfL=%selfL:\=/%
@echo on
git config --global diff.external %selfL%
@echo off


:EOF

Se você estiver em um Mac e tiver o XCode, o FileMerge estará instalado. O comando terminal é opendiff, então você pode fazergit difftool -t opendiff

Instalar fusão

 # apt-get install meld

Então escolha isso como difftool

 $ git config --global diff.tool meld

Se você quiser executá-lo no console, digite:

 $ git difftool

Se você deseja usar o modo gráfico, digite:

 $ git mergetool

E a saída seria:

 'git mergetool' will now attempt to use one of the following tools:
 meld opendiff kdiff3 tkdiff xxdiff tortoisemerge gvimdiff diffuse
 diffmerge ecmerge p4merge araxis bc3 codecompare emerge vimdiff
 Merging:
 www/css/style.css
 www/js/controllers.js

 Normal merge conflict for 'www/css/style.css':
   {local}: modified file
   {remote}: modified file
 Hit return to start merge resolution tool (meld):

Então, basta pressionar enter para usar o meld (padrão), isso abriria o modo gráfico, salvaria a mágica e pressione a tecla que resolve a mesclagem. Isso é tudo

Para uma versão linux de como configurar uma ferramenta diff nas versões git anteriores à 1.6.3 (1.6.3 adicionou difftool ao git), este é um ótimo tutorial conciso,

em resumo:

Etapa 1: adicione isso ao seu .gitconfig

[diff]
  external = git_diff_wrapper
[pager]
  diff =

Etapa 2: crie um arquivo chamado git_diff_wrapper, coloque-o em algum lugar no seu $ PATH

#!/bin/sh

vimdiff "$2" "$5"

No Mac OS X,

git difftool -t diffuse 

faz o trabalho para mim na pasta git. Para instalar difusa, pode-se usar a porta -

sudo port install diffuse

você pode usar git difftool.

por exemplo, se você tiver mesclado , poderá editar as ramificações mastere devel:

git config --global diff.external meld
git difftool master..devel

O seguinte pode ser obtido das outras respostas aqui, mas para mim é difícil (muita informação), então aqui está a resposta 'basta digitar' para tkdiff:

git difftool --tool=tkdiff <path to the file to be diffed>

Você pode substituir o nome do executável da sua ferramenta de difusão favorita por tkdiff. Enquanto (por exemplo, tkdiff) (ou sua ferramenta de busca favorita) estiver no seu PATH, ele será iniciado.

Eu tentei as coisas chiques aqui (com tkdiff) e nada funcionou para mim. Então, eu escrevi o seguinte script, tkgitdiff. Faz o que eu preciso fazer.

$ cat tkgitdiff
#!/bin/sh

#
# tkdiff for git.
# Gives you the diff between HEAD and the current state of your file.
#

newfile=$1
git diff HEAD -- $newfile > /tmp/patch.dat
cp $newfile /tmp
savedPWD=$PWD
cd /tmp
patch -R $newfile < patch.dat
cd $savedPWD
tkdiff /tmp/$newfile $newfile

Eu uso o kompare no ubuntu:

sudo apt-get install kompare

Para comparar dois ramos:

git difftool -t kompare <my_branch> master

Estou usando esse bit ~/.gitconfighá muito tempo:

[diff]
    external = ~/Dropbox/source/bash/git-meld

Com git-meld:

#!/bin/bash
if [ "$DISPLAY" = "" ];
then
    diff $2 $5
else
    meld $2 $5
fi

Mas agora eu me cansei de sempre usar o meld no ambiente gráfico, e não é trivial invocar o diff normal com essa configuração, então mudei para isso:

[alias]
    v =  "!sh -c 'if [ $# -eq 0 ] ; then git difftool -y -t meld ; else git difftool -y $@ ; fi' -"

Com essa configuração, coisas como esta funcionam:

git v
git v --staged
git v -t kompare
git v --staged -t tkdiff

E ainda continuo mantendo o bom e velho git diff.

Se você já possui uma ferramenta diff associada a tipos de arquivos (por exemplo, porque você instalou o TortoiseSVN que vem com um visualizador de diferenças), basta canalizar a git diffsaída regular para um arquivo "temp" e abrir esse arquivo diretamente, sem precisar saber qualquer coisa sobre o espectador:

git diff > "~/temp.diff" && start "~/temp.diff"

Configurá-lo como um alias global funciona ainda melhor: git what

[alias]
    what = "!f() { git diff > "~/temp.diff" && start "~/temp.diff"; }; f"

Se você não é da linha de comando, se instalar o tortoise git, poderá clicar com o botão direito do mouse em um arquivo para obter um submenu do tortoisegit com a opção "Diff later".

Quando você seleciona isso no primeiro arquivo, você pode clicar com o botão direito do mouse no segundo arquivo, ir para o submenu tortoisegit e selecionar "Difere com == yourfilehere ==" Isso fornecerá ao guto tortoisegitmerge o resultado.

Você pode experimentar o xd http://github.com/jiqingtang/xd , que é o wrapper da GUI para o GIT / SVN diff. NÃO é uma ferramenta diff em si. Você executa xdquando deseja executar git diffousvn diff e ele mostra uma lista de arquivos, uma janela de visualização e você pode iniciar qualquer ferramenta diff que desejar, incluindo tkdiff, xxdiff, gvimdiff, emacs (ediff), xemacs (ediff), meld, difuso, kompare e kdiff3. Você também pode executar qualquer ferramenta personalizada.

Infelizmente, a ferramenta não suporta Windows.

Divulgação : eu sou o autor desta ferramenta.