Lorsque je tape git diff, je veux afficher la sortie avec mon outil de diff visuel de choix (SourceGear "diffmerge" sur Windows). Comment configurer git pour ce faire?

Depuis Git1.6.3, vous pouvez utiliser le script git difftool : voir ma réponse ci-dessous .

Peut-être que cet article vous aidera. Voici les meilleures parties:

Il existe deux façons différentes de spécifier un outil de diff externe.

La première est la méthode que vous avez utilisée, en définissant la variable GIT_EXTERNAL_DIFF. Cependant, la variable est censée pointer vers le chemin complet de l'exécutable. De plus, l'exécutable spécifié par GIT_EXTERNAL_DIFF sera appelé avec un ensemble fixe de 7 arguments:

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

Comme la plupart des outils diff nécessiteront un ordre différent (et seulement certains) des arguments, vous devrez probablement spécifier un script wrapper à la place, qui à son tour appelle le véritable outil diff.

La deuxième méthode, que je préfère, consiste à configurer l'outil de diff externe via "git config" . Voici ce que j'ai fait:

1) Créez un script wrapper "git-diff-wrapper.sh" qui contient quelque chose comme

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

Comme vous pouvez le voir, seuls les deuxième ("ancien fichier") et cinquième ("nouveau fichier") arguments seront transmis à l'outil diff.

2) Type

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

à l'invite de commande, en remplaçant par le chemin d'accès à "git-diff-wrapper.sh", donc votre ~ / .gitconfig contient

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

Veillez à utiliser la syntaxe correcte pour spécifier les chemins d'accès au script wrapper et à l'outil diff, c'est-à-dire utiliser des barres obliques inversées au lieu de barres obliques inverses. Dans mon cas, j'ai

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

dans .gitconfig et

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

dans le script wrapper. Attention au "chat" qui traîne!

(Je suppose que le ' | cat' n'est nécessaire que pour certains programmes qui peuvent ne pas retourner un état de retour correct ou cohérent. Vous voudrez peut-être essayer sans le chat de fin si votre outil diff a un état de retour explicite)

( Diomidis Spinellis ajoute dans les commentaires :

La catcommande est requise, car diff(1), par défaut, se termine avec un code d'erreur si les fichiers diffèrent.
Git s'attend à ce que le programme diff externe ne se termine avec un code d'erreur qu'en cas d'erreur réelle, par exemple s'il manque de mémoire.
En canalisant la sortie de gitvers catle code d'erreur non nul est masqué.
Plus efficacement, le programme pourrait simplement s'exécuter exitavec un argument de 0.)

C'est (l'article cité ci-dessus) est la théorie de l'outil externe défini via le fichier de configuration (et non via la variable d'environnement).
En pratique (toujours pour la définition du fichier de configuration de l'outil externe), vous pouvez vous référer à:

• Comment configurer DiffMerge avec msysgit / gitk? qui illustre les paramètres concrets de DiffMerge et WinMerge pour MsysGit et gitk
• Comment puis-je configurer un éditeur pour travailler avec Git sous Windows? pour la définition de Notepad ++ en tant qu'éditeur externe.

Pour terminer ma précédente réponse de configuration "diff.external" ci-dessus:

Comme mentionné par Jakub , Git1.6.3 a introduit git difftool , initialement proposé en septembre 2008:

USAGE = '[--tool=tool] [--commit=ref] [--start=ref --end=ref] [--no-prompt] [file to merge]'
(Voir --extcmddans la dernière partie de cette réponse)

$LOCALcontient le contenu du fichier de la révision de début et $REMOTEcontient le contenu du fichier dans la révision de fin.
$BASEcontient le contenu du fichier dans le wor

Il est fondamentalement git-mergetoolmodifié pour fonctionner sur l'index / worktree git.

Le cas d'utilisation habituelle pour ce script est quand vous avez soit mis en scène ou des changements Unstaged et que vous aimeriez voir les changements dans un visualisateur de différences côte à côte (par exemple xxdiff, tkdiff, etc.).

git difftool [<filename>*]

Un autre cas d'utilisation est lorsque vous souhaitez voir les mêmes informations mais comparez les validations arbitraires (c'est la partie où l'analyse de revarg pourrait être meilleure)

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

Le dernier cas d'utilisation est lorsque vous souhaitez comparer votre arbre de travail actuel à autre chose que HEAD (par exemple une balise)

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

Remarque: depuis Git 2.5, git config diff.tool winmergec'est suffisant!
Voir " git mergetool winmerge "

Et depuis Git 1.7.11 , vous avez la possibilité --dir-diff, afin de générer des outils de diff externes qui peuvent comparer deux hiérarchies de répertoires à la fois après avoir rempli deux répertoires temporaires, au lieu d'exécuter une instance de l'outil externe une fois par paire de fichiers.

Avant Git 2.5:

Cas pratique pour configurer difftoolavec votre outil de diff personnalisé:

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

Avec winmerge.sh stocké dans une partie répertoire de votre PATH:

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

Si vous avez un autre outil (kdiff3, P4Diff, ...), créez un autre script shell et la difftool.myDiffTool.cmddirective de configuration appropriée .
Ensuite, vous pouvez facilement changer d'outils avec la diff.toolconfiguration.

Vous avez également cette entrée de blog de Dave pour ajouter d'autres détails.
(Ou cette question pour les winmergeuoptions)

L'intérêt de ce paramètre est le winmerge.shscript : vous pouvez le personnaliser pour prendre en compte des cas particuliers.

Voir par exemple la réponse de David Marble ci-dessous pour un exemple qui traite de:

• nouveaux fichiers dans l'origine ou la destination
• fichiers supprimés dans l'origine ou la destination

Comme Kem Mason le mentionne dans sa réponse , vous pouvez également éviter tout wrapper en utilisant l' --extcmdoption :

--extcmd=<command>

Spécifiez une commande personnalisée pour afficher les différences. git-difftoolignore les valeurs par défaut configurées et s'exécute $command $LOCAL $REMOTElorsque cette option est spécifiée.

Par exemple, voici comment gitkexécuter / utiliser n'importe quel diffoutil .

Dans l'esprit de répondre à des questions quelque peu différentes de celles posées. Essayez cette solution:

$ meld my_project_using_git

Meld comprend git et permet de naviguer autour des récents changements.

Avec le nouveau git difftool , c'est aussi simple que d'ajouter ceci à votre fichier .gitconfig :

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

Éventuellement, ajoutez également:

[difftool]
    prompt = false

Consultez également diffall , un script simple que j'ai écrit pour étendre le comportement de diff par défaut ennuyeux (IMO) de l'ouverture de chacun en série.

Global .gitconfig sur Windows est dans %USERPROFILE%\.gitconfig

Depuis la version 1.6.3 de git, il existe " git difftool " que vous pouvez configurer pour utiliser votre outil de comparaison graphique préféré. Les formats prêts à l'emploi actuellement pris en charge sont kdiff3, kompare, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, diffuse et opendiff ; si l'outil que vous souhaitez utiliser ne figure pas dans cette liste, vous pouvez toujours utiliser l' difftool.<tool>.cmdoption de configuration ' '.

"git difftool" accepte les mêmes options que "git difft".

J'ai un ajout à cela. J'aime utiliser régulièrement une application diff qui n'est pas prise en charge comme l'un des outils par défaut (par exemple kaléidoscope), via

git difftool -t

J'aime aussi que la valeur par défaut diffsoit juste la ligne de commande normale, donc définir la GIT_EXTERNAL_DIFFvariable n'est pas une option.

Vous pouvez utiliser une diffapplication arbitraire comme une seule fois avec cette commande:

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

Il passe simplement les 2 fichiers à la commande que vous spécifiez, vous n'avez donc probablement pas besoin d'un wrapper non plus.

En s'appuyant sur la réponse de VonC pour gérer les suppressions et ajouts de fichiers, utilisez les commandes et scripts suivants:

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

Ce qui revient à mettre cela dans votre global .gitconfig:

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

Ensuite, mettez ce qui suit winmerge.shsur votre chemin:

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

Solution pour Windows / msys git

Après avoir lu les réponses, j'ai découvert un moyen plus simple qui consiste à modifier un seul fichier.

1. Créez un fichier batch pour appeler votre programme diff, avec les arguments 2 et 5. Ce fichier doit se trouver quelque part sur votre chemin. (Si vous ne savez pas où c'est, mettez-le dans c: \ windows). Appelez-le, par exemple, "gitdiff.bat". Le mien est:

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

2. Définissez la variable d'environnement pour pointer vers votre fichier de commandes. Par exemple: GIT_EXTERNAL_DIFF=gitdiff.bat. Ou via PowerShell en tapant git config --global diff.external gitdiff.bat.

   Il est important de ne pas utiliser de guillemets ou de spécifier des informations de chemin, sinon cela ne fonctionnera pas. C'est pourquoi gitdiff.bat doit être sur votre chemin.

Maintenant, lorsque vous tapez "git diff", il invoquera votre visualiseur de diff externe.

Si vous faites cela via cygwin, vous devrez peut-être utiliser 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`

Après avoir regardé quelques autres outils de diff externes, j'ai trouvé que la diffvue dans IntelliJ IDEA (et Android Studio) était la meilleure pour moi.

Étape 1 - Configurer IntelliJ IDEA pour qu'il soit exécuté à partir de la ligne de commande

Si vous souhaitez utiliser IntelliJ IDEA comme outil de comparaison, vous devez d'abord configurer IntelliJ IDEA pour qu'il soit exécuté à partir de la ligne de commande en suivant les instructions ici :

Sous macOS ou UNIX:

1. Assurez-vous que IntelliJ IDEA est en cours d'exécution.
2. Dans le menu principal, choisissez Tools | Create Command-line Launcher. La boîte de dialogue Créer un script de lancement s'ouvre, avec le chemin et le nom suggérés du script de lancement. Vous pouvez accepter la valeur par défaut ou spécifier votre propre chemin. Prenez-en note, car vous en aurez besoin plus tard. En dehors d'IntelliJ IDEA, ajoutez le chemin et le nom du script de lancement à votre chemin.

Sous Windows:

1. Spécifiez l'emplacement de l'exécutable IntelliJ IDEA dans la variable d'environnement système Path. Dans ce cas, vous pourrez invoquer l'exécutable IntelliJ IDEA et d'autres commandes IntelliJ IDEA à partir de n'importe quel répertoire.

Étape 2 - Configurer git pour utiliser IntelliJ IDEA en tant que difftool

En suivant les instructions de ce billet de blog :

Frapper

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

Poisson

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

Ajoutez maintenant ce qui suit à votre configuration 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")

Vous pouvez l'essayer avec git difftoolougit difftool HEAD~1

cela fonctionne pour moi sur Windows 7. Pas besoin de scripts sh intermédiaires

contenu de .gitconfig:

    [diff]
      tool = kdiff3

    [difftool]
       prompt = false

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

Un bref résumé des bonnes réponses ci-dessus:

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

Ensuite, utilisez-le en tapant (en spécifiant éventuellement le nom du fichier également):

git difftool

introduction

Pour référence, j'aimerais inclure ma variation sur la réponse de VonC. Gardez à l'esprit que j'utilise la version MSys de Git (1.6.0.2 en ce moment) avec PATH modifié et que j'exécute Git lui-même à partir de Powershell (ou cmd.exe), pas du shell Bash.

J'introduit une nouvelle commande, gitdiff. L'exécution de cette commande redirige temporairement git diffpour utiliser un programme de diff visuel de votre choix (par opposition à la solution de VonC qui le fait en permanence). Cela me permet d'avoir à la fois la fonctionnalité de différence Git par défaut ( git diff) ainsi que la fonctionnalité de différence visuelle ( gitdiff). Les deux commandes prennent les mêmes paramètres, par exemple pour différencier visuellement les changements dans un fichier particulier, vous pouvez taper

gitdiff path/file.txt

Installer

Notez qu'il $GitInstallest utilisé comme espace réservé pour le répertoire dans lequel Git est installé.

1. Créez un nouveau fichier, $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. Créez un nouveau fichier $GitInstall\bin\git-diff-visual.cmd(en remplaçant l' [visual_diff_exe]espace réservé par le chemin d'accès complet au programme diff de votre choix)

   @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. Vous avez maintenant terminé. L'exécution à gitdiffpartir d'un référentiel Git devrait maintenant appeler votre programme de diff visuel pour chaque fichier qui a été modifié.

Voici un fichier de commandes qui fonctionne pour Windows - suppose que DiffMerge est installé à l'emplacement par défaut, gère x64, gère le remplacement de la barre oblique inverse si nécessaire et a la capacité de s'installer lui-même. Il devrait être facile de remplacer DiffMerge par votre programme de diff préféré.

À installer:

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

Si vous êtes sur un Mac et que vous avez XCode, FileMerge est installé. La commande de terminal est ouverte, vous pouvez donc simplement fairegit difftool -t opendiff

Installer la fusion

 # apt-get install meld

Ensuite, choisissez comme difftool

 $ git config --global diff.tool meld

Si vous voulez l'exécuter sur le type de console:

 $ git difftool

Si vous souhaitez utiliser le type de mode graphique:

 $ git mergetool

Et la sortie serait:

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

Il suffit donc d'appuyer sur Entrée pour utiliser la fusion (par défaut), cela ouvrirait le mode graphique, ferait la sauvegarde magique et appuyez sur celui qui résout la fusion. C'est tout

Pour une version Linux de la façon de configurer un outil de diff sur les versions git avant 1.6.3 (1.6.3 ajouté difftool à git) c'est un grand tutoriel concis,

en bref:

Étape 1: ajoutez ceci à votre .gitconfig

[diff]
  external = git_diff_wrapper
[pager]
  diff =

Étape 2: créez un fichier nommé git_diff_wrapper, placez-le quelque part dans votre $ PATH

#!/bin/sh

vimdiff "$2" "$5"

Sous Mac OS X,

git difftool -t diffuse 

fait le travail pour moi dans le dossier git. Pour installer diffuse, on peut utiliser le port -

sudo port install diffuse

vous pouvez utiliser git difftool.

par exemple si vous avez fusionné , vous pouvez éditer les branches masteret develen:

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

Ce qui suit peut être glané des autres réponses ici, mais pour moi c'est difficile, (trop d'informations), alors voici la réponse `` il suffit de taper '' pour tkdiff:

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

Vous pouvez remplacer tkdiff par le nom exécutable de votre outil de différenciation préféré. Tant que (par exemple tkdiff), (ou votre outil de différenciation préféré) est dans votre PATH, il sera lancé.

J'ai essayé les trucs chics ici (avec tkdiff) et rien n'a fonctionné pour moi. J'ai donc écrit le script suivant, tkgitdiff. Il fait ce dont j'ai besoin.

$ 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

J'utilise kompare sur ubuntu:

sudo apt-get install kompare

Pour comparer deux branches:

git difftool -t kompare <my_branch> master

J'utilise ce bit ~/.gitconfigdepuis longtemps:

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

Avec git-meld:

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

Mais maintenant, je suis fatigué de toujours utiliser meld dans un environnement graphique, et ce n'est pas trivial d'invoquer le diff normal avec cette configuration, alors je suis passé à ceci:

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

Avec cette configuration, des choses comme cela fonctionnent:

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

Et je garde encore le bon vieux git diff.

S'il vous arrive d'avoir déjà un outil de diff associé aux types de fichiers (par exemple, parce que vous avez installé TortoiseSVN qui est livré avec un visualiseur de diff), vous pouvez simplement diriger la git diffsortie régulière vers un fichier "temp", puis simplement ouvrir ce fichier directement sans avoir besoin de savoir quoi que ce soit sur le spectateur:

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

Le définir comme un alias global fonctionne encore mieux: git what

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

Si vous ne faites pas partie de la ligne de commande, si vous installez tortoise git, vous pouvez cliquer avec le bouton droit sur un fichier pour obtenir un sous-menu tortoisegit avec l'option "Diff later".

Lorsque vous sélectionnez ceci dans le premier fichier, vous pouvez ensuite cliquer avec le bouton droit sur le second fichier, aller dans le sous-menu tortoisegit et sélectionner "Diff with == yourfilehere ==" Cela donnera le gui tortoisegitmerge pour le résultat.

Vous voudrez peut-être essayer xd http://github.com/jiqingtang/xd , qui est le wrapper GUI pour diff GIT / SVN. Ce n'est PAS un outil de diff lui-même. Vous exécutez xdquand vous voulez exécuter git diffou svn diffet il vous montrera une liste de fichiers, une fenêtre d'aperçu et vous pouvez lancer n'importe quel outil de différenciation que vous aimez, y compris tkdiff, xxdiff, gvimdiff, emacs (ediff), xemacs (ediff), meld, diffuse, kompare et kdiff3. Vous pouvez également exécuter n'importe quel outil personnalisé.

Malheureusement, l'outil ne prend pas en charge Windows.

Divulgation : je suis l'auteur de cet outil.