Quando git diffscrivo, voglio visualizzare l'output con il mio strumento di visualizzazione diff diff (SourceGear "diffmerge" su Windows). Come configuro git per fare questo?

Da Git1.6.3, puoi usare lo script git difftool : vedi la mia risposta qui sotto .

Potrebbe essere questo articolo che ti aiuterà. Ecco le parti migliori:

Esistono due modi diversi per specificare uno strumento diff esterno.

Il primo è il metodo che hai usato, impostando la variabile GIT_EXTERNAL_DIFF. Tuttavia, la variabile dovrebbe puntare al percorso completo dell'eseguibile. Inoltre, l'eseguibile specificato da GIT_EXTERNAL_DIFF verrà chiamato con un set fisso di 7 argomenti:

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

Poiché la maggior parte degli strumenti diff richiederà un ordine diverso (e solo alcuni) degli argomenti, molto probabilmente dovrai specificare uno script wrapper, che a sua volta chiama il vero strumento diff.

Il secondo metodo, che preferisco, è configurare lo strumento diff esterno tramite "git config" . Ecco cosa ho fatto:

1) Crea uno script wrapper "git-diff-wrapper.sh" che contiene qualcosa di simile

-->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)--

Come puoi vedere, solo il secondo ("vecchio file") e il quinto ("nuovo file") verranno passati allo strumento diff.

2) Digitare

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

al prompt dei comandi, sostituendolo con il percorso di "git-diff-wrapper.sh", quindi il file ~ / .gitconfig contiene

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

Assicurarsi di utilizzare la sintassi corretta per specificare i percorsi dello script wrapper e dello strumento diff, ovvero utilizzare la barra diretta anziché le barre rovesciate. Nel mio caso, l'ho fatto

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

in .gitconfig e

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

nello script wrapper. Badate al "gatto" finale!

(Suppongo che " | cat" sia necessario solo per alcuni programmi che potrebbero non restituire uno stato di ritorno corretto o coerente. Potresti provare senza il gatto finale se il tuo strumento diff ha uno stato di ritorno esplicito)

( Diomidis Spinellis aggiunge nei commenti :

Il catcomando è richiesto, perché diff(1), per impostazione predefinita, esce con un codice di errore se i file differiscono.
Git si aspetta che il programma diff esterno esca con un codice di errore solo se si è verificato un errore reale, ad esempio se ha esaurito la memoria.
Reindirizzando l'uscita gitper catil codice di errore diverso da zero viene mascherato.
Più efficacemente, il programma potrebbe essere eseguito exitcon argomento 0)

Quella (l'articolo citato sopra) è la teoria dello strumento esterno definita attraverso il file di configurazione (non attraverso la variabile d'ambiente).
In pratica (ancora per la definizione del file di configurazione dello strumento esterno), puoi fare riferimento a:

• Come configuro DiffMerge con msysgit / gitk? che illustra le impostazioni concrete di DiffMerge e WinMerge per MsysGit e gitk
• Come posso configurare un editor per lavorare con Git su Windows? per la definizione di Notepad ++ come editor esterno.

Per completare la mia precedente risposta di configurazione "diff.external" sopra:

Come menzionato da Jakub , Git1.6.3 ha introdotto git difftool , originariamente proposto nel settembre 2008:

USAGE = '[--tool=tool] [--commit=ref] [--start=ref --end=ref] [--no-prompt] [file to merge]'
(Vedi --extcmdnell'ultima parte di questa risposta)

$LOCALcontiene il contenuto del file dalla revisione iniziale e $REMOTEcontiene il contenuto del file nella revisione finale.
$BASEcontiene il contenuto del file nel wor

È sostanzialmente git-mergetoolmodificato per operare sull'indice git / worktree.

Il caso di utilizzo di consueto per questo script è quando si hanno sia messo in scena o modifiche unstaged e ti piacerebbe vedere i cambiamenti in un visualizzatore diff side-by-side (per esempio xxdiff, tkdiff, ecc).

git difftool [<filename>*]

Un altro caso d'uso è quando desideri vedere le stesse informazioni ma stai confrontando commit arbitrari (questa è la parte in cui l'analisi del revarg potrebbe essere migliore)

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

L'ultimo caso d'uso è quando desideri confrontare il tuo attuale worktree con qualcosa di diverso da HEAD (ad esempio un tag)

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

Nota: da Git 2.5, git config diff.tool winmergeè abbastanza!
Vedi " git mergetool winmerge "

E da Git 1.7.11 , hai la possibilità --dir-diffdi generare strumenti diff esterni che possono confrontare due gerarchie di directory alla volta dopo aver popolato due directory temporanee, invece di eseguire un'istanza dello strumento esterno una volta per coppia di file.

Prima di Git 2.5:

Caso pratico per la configurazione difftoolcon il tuo strumento diff personalizzato:

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

Con winmerge.sh memorizzato in una parte della directory del tuo PERCORSO:

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

Se hai un altro strumento (kdiff3, P4Diff, ...), crea un altro script di shell e la difftool.myDiffTool.cmddirettiva di configurazione appropriata .
Quindi puoi facilmente cambiare strumento con ildiff.tool configurazione.

Hai anche questo post sul blog di Dave per aggiungere altri dettagli.
(O questa domanda per ilwinmergeu opzioni)

L'interesse per questa impostazione è lo winmerge.shscript : puoi personalizzarlo per tenere conto di casi speciali.

Vedi ad esempio la risposta di David Marble di seguito per un esempio che tratta:

• nuovi file in origine o destinazione
• file rimossi in origine o destinazione

Come menziona Kem Mason nella sua risposta , puoi anche evitare qualsiasi wrapper usando l' --extcmdopzione :

--extcmd=<command>

Specificare un comando personalizzato per la visualizzazione delle differenze. git-difftoolignora le impostazioni predefinite configurate e viene eseguito $command $LOCAL $REMOTEquando viene specificata questa opzione.

Ad esempio, ecco come gitkè possibile eseguire / utilizzare qualsiasi diffstrumento .

Nello spirito di rispondere a domande leggermente diverse da quelle poste. Prova questa soluzione:

$ meld my_project_using_git

Meld comprende git e fornisce la navigazione tra le modifiche recenti.

Con il nuovo git difftool , è semplice come aggiungere questo al tuo file .gitconfig :

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

Facoltativamente, aggiungi anche:

[difftool]
    prompt = false

Dai un'occhiata anche a diffall , un semplice script che ho scritto per estendere il fastidioso comportamento diff diffondente (IMO) di apertura di ciascuno in seriale.

.Gitconfig globale su Windows è in %USERPROFILE%\.gitconfig

Dalla versione 1.6.3 di git esiste " git difftool " che puoi configurare per usare il tuo strumento diff grafico preferito. Attualmente supportati e pronti all'uso sono kdiff3, kompare, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, diffuse e opendiff ; se lo strumento che si desidera utilizzare non è in questo elenco, è sempre possibile utilizzare l' difftool.<tool>.cmdopzione di configurazione ' '.

"git difftool" accetta le stesse opzioni di "git diff".

Ho un'aggiunta a questo. Mi piace utilizzare regolarmente un'app diff non supportata come uno degli strumenti predefiniti (ad es. Caleidoscopio), tramite

git difftool -t

Mi piace anche che l'impostazione predefinita sia diffsolo la normale riga di comando, quindi l'impostazione della GIT_EXTERNAL_DIFFvariabile non è un'opzione.

Puoi usare diffun'app arbitraria come una tantum con questo comando:

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

Passa semplicemente i 2 file al comando specificato, quindi probabilmente non hai nemmeno bisogno di un wrapper.

Basandosi sulla risposta di VonC per gestire la rimozione e l'aggiunta di file, utilizzare i seguenti comandi e script:

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

Ciò equivale a metterlo nel tuo globale .gitconfig:

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

Quindi inserisci quanto segue in winmerge.shcui deve trovarsi sul tuo percorso:

#!/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

Soluzione per Windows / msys git

Dopo aver letto le risposte, ho scoperto un modo più semplice che prevede la modifica di un solo file.

1. Crea un file batch per invocare il tuo programma diff, con gli argomenti 2 e 5. Questo file deve trovarsi da qualche parte nel tuo percorso. (Se non sai dove si trova, inseriscilo in c: \ windows). Chiamalo, ad esempio, "gitdiff.bat". Il mio è:

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

2. Impostare la variabile di ambiente in modo che punti al file batch. Ad esempio: GIT_EXTERNAL_DIFF=gitdiff.bat. O tramite PowerShell digitando git config --global diff.external gitdiff.bat.

   È importante non utilizzare le virgolette o specificare le informazioni sul percorso, altrimenti non funzionerà. Ecco perché gitdiff.bat deve essere sul tuo cammino.

Ora quando digiti "git diff", invocherà il tuo visualizzatore di diff esterno.

Se lo stai facendo tramite Cygwin, potrebbe essere necessario utilizzare 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`

Dopo aver esaminato altri strumenti diff esterni, ho scoperto che la diffvista in IntelliJ IDEA (e Android Studio) è la migliore per me.

Passaggio 1: configurare IntelliJ IDEA per l'esecuzione dalla riga di comando

Se si desidera utilizzare IntelliJ IDEA come strumento diff, è necessario prima configurare IntelliJ IDEA per l'esecuzione dalla riga di comando seguendo le istruzioni qui :

Su macOS o UNIX:

1. Assicurarsi che IntelliJ IDEA sia in esecuzione.
2. Nel menu principale, selezionare Tools | Create Command-line Launcher. Viene visualizzata la finestra di dialogo Crea script di avvio, con il percorso e il nome suggeriti dello script di avvio. Puoi accettare le impostazioni predefinite o specificare il tuo percorso. Notalo, perché ne avrai bisogno in seguito. Al di fuori di IntelliJ IDEA, aggiungi il percorso e il nome dello script di avvio al percorso.

Su Windows:

1. Specificare la posizione dell'eseguibile IDEA IntelliJ nella variabile di ambiente di sistema Path. In questo caso, sarà possibile richiamare l'eseguibile IntelliJ IDEA e altri comandi IntelliJ IDEA da qualsiasi directory.

Passaggio 2: configurare git per utilizzare IntelliJ IDEA come difftool

Seguendo le istruzioni su questo post del blog :

bash

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

Pesce

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

Ora aggiungi quanto segue alla tua configurazione di 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")

Puoi provarlo con git difftoologit difftool HEAD~1

questo funziona per me su Windows 7. Non c'è bisogno di script sh intermedi

contenuto di .gitconfig:

    [diff]
      tool = kdiff3

    [difftool]
       prompt = false

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

Un breve riassunto delle grandi risposte sopra:

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

Quindi utilizzalo digitando (facoltativamente specificando anche il nome del file):

git difftool

introduzione

Per riferimento, vorrei includere la mia variazione nella risposta di VonC. Tieni presente che sto usando la versione MSys di Git (1.6.0.2 in questo momento) con PATH modificato e sto eseguendo Git stesso da Powershell (o cmd.exe), non dalla shell Bash.

Ho introdotto un nuovo comando, gitdiff. L'esecuzione di questo comando reindirizza temporaneamente git diffall'utilizzo di un programma diff visivo di tua scelta (al contrario della soluzione VonC che lo fa in modo permanente). Questo mi permette di avere sia la funzionalità diff Git predefinita ( git diff) che la funzionalità diff diff ( gitdiff). Entrambi i comandi accettano gli stessi parametri, quindi ad esempio per modificare visivamente le modifiche in un determinato file è possibile digitare

gitdiff path/file.txt

Impostare

Si noti che $GitInstallviene utilizzato come segnaposto per la directory in cui è installato Git.

1. Crea un nuovo file, $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. Crea un nuovo file $GitInstall\bin\git-diff-visual.cmd(sostituendo il [visual_diff_exe]segnaposto con il percorso completo del programma diff di tua scelta)

   @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. Ora hai finito. L'esecuzione gitdiffall'interno di un repository Git dovrebbe ora invocare il tuo programma diff visivo per ogni file che è stato modificato.

Ecco un file batch che funziona per Windows: presuppone che DiffMerge sia installato nella posizione predefinita, gestisce x64, gestisce la sostituzione della barra rovesciata secondo necessità e ha la possibilità di installarsi. Dovrebbe essere facile sostituire DiffMerge con il tuo programma diff preferito.

Installare:

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 sei su un Mac e hai XCode, allora hai FileMerge installato. Il comando del terminale è aperto, quindi puoi semplicemente farlogit difftool -t opendiff

Installa fusione

 # apt-get install meld

Quindi scegli quello come difftool

 $ git config --global diff.tool meld

Se vuoi eseguirlo sul tipo di console:

 $ git difftool

Se si desidera utilizzare il tipo di modalità grafica:

 $ git mergetool

E l'output sarebbe:

 '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):

Quindi premi Invio per usare la combinazione (impostazione predefinita), questo aprirà la modalità grafica, salverà la magia e premi quello che risolverà l'unione. È tutto

Per una versione Linux di come configurare uno strumento diff su versioni git precedenti alla 1.6.3 (1.6.3 aggiunto difftool a git) questo è un ottimo tutorial conciso,

in breve:

Passaggio 1: aggiungi questo al tuo .gitconfig

[diff]
  external = git_diff_wrapper
[pager]
  diff =

Step 2: crea un file chiamato git_diff_wrapper, mettilo da qualche parte nel tuo $ PATH

#!/bin/sh

vimdiff "$2" "$5"

Su Mac OS X,

git difftool -t diffuse 

fa il lavoro per me nella cartella git. Per l'installazione diffusa, si può usare la porta -

sudo port install diffuse

puoi usare git difftool.

ad esempio se hai una combinazione , puoi modificare i rami mastere devel:

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

Quanto segue può essere ricavato dalle altre risposte qui, ma per me è difficile (troppe informazioni), quindi ecco la risposta "digita semplicemente" per tkdiff:

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

Puoi sostituire il nome eseguibile del tuo strumento diffing preferito con tkdiff. Finché (ad es. Tkdiff), (o il tuo strumento di diff preferito) è nel tuo PERCORSO, verrà lanciato.

Ho provato le cose fantasiose qui (con tkdiff) e niente ha funzionato per me. Quindi ho scritto la seguente sceneggiatura, tkgitdiff. Fa quello che mi serve per farlo.

$ 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

Uso kompare su Ubuntu:

sudo apt-get install kompare

Per confrontare due rami:

git difftool -t kompare <my_branch> master

Sto usando questo bit ~/.gitconfigda molto tempo:

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

Con git-meld:

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

Ma ora mi sono stancato di usare sempre la combinazione in ambiente grafico, e non è banale invocare il diff normale con questa configurazione, quindi sono passato a questo:

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

Con questa configurazione, cose come questa funzionano:

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

E riesco ancora a mantenere il buon vecchio git diff.

Se ti capita di avere già uno strumento diff associato ai tipi di file (diciamo, perché hai installato TortoiseSVN che viene fornito con un visualizzatore diff) potresti semplicemente reindirizzare l' git diffoutput normale in un file "temp", quindi aprire quel file direttamente senza bisogno di sapere qualcosa sullo spettatore:

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

Impostarlo come alias globale funziona ancora meglio: git what

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

Se non sei uno per la riga di comando, se installi tortoise git puoi fare clic destro su un file per ottenere un sottomenu tortoisegit con l'opzione "Diff later".

Quando lo selezioni sul primo file, puoi fare clic con il pulsante destro del mouse sul secondo file, andare al sottomenu tortoisegit e selezionare "Diff with == yourfilehere ==" Questo darà la gui tortoisegitmerge per il risultato.

Puoi provare xd http://github.com/jiqingtang/xd , che è il wrapper GUI per GIT / SVN diff. NON è uno strumento diff stesso. Corri xdquando vuoi correre git diffosvn diff e ti mostrerà un elenco di file, una finestra di anteprima e puoi avviare qualsiasi strumento diff che ti piace, tra cui tkdiff, xxdiff, gvimdiff, emacs (ediff), xemacs (ediff), meld, diffuse, kompare e kdiff3. Puoi anche eseguire qualsiasi strumento personalizzato.

Sfortunatamente lo strumento non supporta Windows.

Divulgazione : sono l'autore di questo strumento.