Comment différencier et fusionner deux répertoires?

Je sais que le mode diff de Vim ( vimdiff) nous permet de comparer le contenu de deux fichiers (ou plus).

Mais il est possible de comparer le contenu de plusieurs fichiers sur plusieurs répertoires afin de fusionner deux répertoires de manière récursive (comme DiffMerge et des outils similaires)?

Il existe un plugin DirDiff.vim ( GitHub ) pour diff et fusionner deux répertoires de manière récursive.

Il effectue un diff récursif sur deux répertoires et génère une "fenêtre" de diff. En fonction de cette fenêtre, vous pouvez effectuer différentes opérations de diff, telles que l’ouverture de deux fichiers en mode Diff de Vim, la copie récursive du fichier ou du répertoire dans l’autre, ou la suppression de l’arborescence du répertoire source.

Usage:

:DirDiff <dir1> <dir2>

Pour plus d'informations / aide: :help dirdiff

Voir la capture d'écran:

Voir également:

• (vidéo) DirDiff.vim, diff et fusion de deux répertoires de manière récursive par Yu-Jie Lin sur YouTube

• Comparer et fusionner des répertoires de manière récursive? chez dedm blog

  

J'utilise un script d'emballage pythonpour fusionner des fichiers (voir ci-dessous). Ceci est une version simplifiée de ce que j'utilise pour fusionner mes ~/.vimrépertoires et autres.

Cela devrait fonctionner en Python 2 et 3; mais probablement pas dans les très anciennes versions de Python livrées avec CentOS et d'autres distributions.

Sachez que certaines vérifications (comme celle concernant les fichiers binaires, ou si les fichiers sont identiques) ne sont pas très rapides (le fichier entier est lu); vous pouvez les enlever si vous voulez.

Il ne mentionne pas non plus si a est uniquement présent dans l'un des répertoires ...

#!/usr/bin/env python
from __future__ import print_function
import hashlib, os, subprocess, sys

if len(sys.argv) < 3:
    print('Usage: {} dir1 dir2'.format(sys.argv[0]))
    sys.exit(1)

dir1 = os.path.realpath(sys.argv[1])
dir2 = os.path.realpath(sys.argv[2])

for root, dirs, files in os.walk(dir1):
    for f in files:
        f1 = '{}/{}'.format(root, f)
        f2 = f1.replace(dir1, dir2, 1)

        # Don't diff files over 1MiB
        if os.stat(f1).st_size > 1048576 or os.stat(f2).st_size > 1048576: continue

        # Check if files are the same; in which case a diff is useless
        h1 = hashlib.sha256(open(f1, 'rb').read()).hexdigest()
        h2 = hashlib.sha256(open(f2, 'rb').read()).hexdigest()
        if h1 == h2: continue

        # Don't diff binary files
        if open(f1, 'rb').read().find(b'\000') >= 0: continue

        subprocess.call(['vimdiff', f1, f2])

Je voulais la même chose depuis un moment. La meilleure solution que j'ai trouvée consistait à utiliser vdwrap , qui fonctionne à merveille. Tout ce qu'il fait est wrap git difftool --dir-diffpour vimdiff. Il ne nécessite aucun plugin vim.

Tout ce que vous avez à faire, c'est git difftoold'utiliser vdwrap:

git config --global difftool.vdwrap.cmd '/full/path/vdwrap $LOCAL $REMOTE'
git config --global diff.tool vdwrap

La prochaine fois que vous utiliserez git difftool, il ouvrira Vim avec des onglets Vim distincts pour chaque paire de fichiers.

Une mise en garde est que c'est un script Zsh. Cela devrait être assez simple de le convertir en script bash, mais je ne l'ai pas essayé.

Si vous voulez simplement utiliser vimdiff sans rien installer de plus, la commande suivante ouvrira successivement tous les fichiers, ce qui vous permettra de voir les modifications avec vimdiff:

    for files in $(diff -rq dir1 dir2|grep 'differ$'|sed "s/^Files //g;s/ differ$//g;s/ and /:/g"); do 
        vimdiff ${files%:*} ${files#*:}; 
    done

Il existe une solution légère pour cela:

1. Configurez le plugin vimdiffext .
2. Faire diff dir1 dir2 | vim -R -à la coquille.

Il ajoutera des replis et une comparaison côte à côte pour les fichiers modifiés.