¿Cómo diferenciar y fusionar dos directorios?

Sé que el modo diff de Vim ( vimdiff) nos permite comparar el contenido de dos (o más) archivos.

Pero, ¿es posible comparar el contenido de múltiples archivos entre directorios para fusionar dos directorios de forma recursiva (como DiffMerge y herramientas similares)?

Existe el complemento DirDiff.vim ( GitHub ) para diferenciar y fusionar dos directorios de forma recursiva.

Realiza un diff recursivo en dos directorios y genera una "ventana" de diff. En función de esa ventana, puede realizar varias operaciones diff, como abrir dos archivos en el modo diff de Vim, copiar el archivo o directorio de forma recursiva a la otra o eliminar el árbol de directorios del directorio fuente.

Uso:

:DirDiff <dir1> <dir2>

Para más información / ayuda: :help dirdiff

Ver la captura de pantalla:

Ver también:

• (video) DirDiff.vim, diferencie y combine dos directorios recursivamente por Yu-Jie Lin en YouTube

• ¿Comparar y fusionar directorios de forma recursiva? en el blog dedm

  

Utilizo un script de contenedor pythonpara fusionar archivos (ver más abajo). Esta es una versión simplificada de lo que uso para fusionar mis ~/.vimdirectorios y demás.

Debería funcionar en Python 2 y 3; pero probablemente no en versiones muy antiguas de Python como se incluyen con CentOS y algunas otras distribuciones.

Tenga en cuenta que algunas comprobaciones (como la de los archivos binarios, o si los archivos son iguales) no son muy rápidas (lee todo el archivo); puedes eliminarlos si quieres.

Tampoco informa si a solo está presente en uno de los directorios ...

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

He querido lo mismo por un tiempo. La mejor solución que encontré fue usar vdwrap , que funciona increíblemente bien. Todo lo que hace es envoltura git difftool --dir-diffpara vimdiff. No requiere ningún complemento vim.

Todo lo que necesita hacer es decirle git difftoolque use vdwrap:

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

La próxima vez que use git difftool, abrirá Vim con pestañas de Vim separadas para cada par de archivos.

Una advertencia es que es un script Zsh. Debería ser bastante simple convertirlo a un script bash, pero no lo he probado.

Si solo desea usar vimdiff sin instalar nada adicional, el siguiente comando abrirá todos los archivos diferentes en sucesión, lo que le permitirá ver los cambios con 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

Hay una solución ligera para eso:

1. Configure el complemento vimdiffext .
2. Hacer diff dir1 dir2 | vim -R -en la cáscara.

Agregará pliegues y una comparación lado a lado para los archivos modificados.