Comparando diretórios no Emacs

Estou experimentando ediff-directories, mas não tenho certeza se estou usando corretamente.

Li na documentação que, depois de fornecer dois diretórios ediff-directories, se eu pressionar o ==Emacs, os comparará recursivamente.

No entanto, se eu pressionar ==, só recebo pastas com =sinais (o que significa que as duas pastas têm conteúdo idêntico) no nível em que executo o comando. Se eu quiser ver quais pastas têm =sinais em níveis mais profundos na hierarquia de pastas, preciso executar novamente o ==comando em cada nível.

Como posso dizer ao emacs para ir recursivamente até as folhas, para que eu possa ver todas as diferenças no directory difference buffer(acessível através do comando do teclado D)?

Se alguém souber de um tutorial sobre como usar ediff-directories(além da documentação oficial ), eu ficaria muito interessado.

Além disso, se eu quiser sair de um grupo de sessões (comparação de pastas em um nível), mas tiver sessões abertas para níveis mais profundos, se eu pressionar q(sair deste grupo de sessões), o Emacs se queixa da mensagem:

Este grupo de sessões tem sessões ativas --- não pode sair

Como posso sair dos grupos de sessões sem sair das sub-sessões uma a uma?

Eu usei M-x dired-compare-directories, mas também há o EdiffTrees , que pode atendê-lo melhor na situação que você descreve.

Eu também precisava desse recurso e criei o seguinte. A função ediff-directories-recursivefunciona como, ediff-directoriesmas se repete em subdiretórios.

A mágica por trás disso está substituindo temporariamente o built-in directory-filespor um self-made directory-files-recursiveantes de ligar ediff-directories.

(eval
 (let ((directory-files-original (symbol-function 'directory-files)))
   `(defun directory-files-recursive (directory &optional full match nosort)
      "Like `directory-files' but recurses into subdirectories. Does not follow symbolic links."
      (let* ((prefix (or (and full "") directory))
         dirs
         files)
    (mapc (lambda (p)
        (let ((fullname (if full p (concat prefix "/" p))))
          (when (and (file-directory-p fullname)
                 (null (or (string-match "\\(^\\|/\\).$" p)
                       (string-match "\\(^\\|/\\)..$" p)
                       (file-symlink-p fullname))))
            (setq dirs (cons p dirs)))))
          (funcall ,directory-files-original directory full nil nosort))
    (setq dirs (nreverse dirs))
    (mapc (lambda (p)
        (when (null (file-directory-p (if full p (concat prefix "/" p))))
          (setq files (cons p files))))
          (funcall ,directory-files-original directory full match nosort))
    (setq files (nreverse files))
    (mapc (lambda (d)
        (setq files
              (append files
                  (if full
                  (apply 'directory-files-recursive (list d full match nosort))
                (mapcar (lambda (n)
                      (concat d "/" n))
                    (apply 'directory-files-recursive (list (concat prefix "/" d) full match nosort)))))))
          dirs)
    files))))

(eval
 `(defun ediff-directories-recursive (dir1 dir2 regexp)
    "Like `ediff-directories' but recurses into sub-directories. Does not follow symbolic links."
    ,(interactive-form (symbol-function 'ediff-directories))
    (let ((directory-files-original (symbol-function 'directory-files)))
      (unwind-protect
      (progn
        (fset 'directory-files (symbol-function 'directory-files-recursive))
        (ediff-directories dir1 dir2 regexp)
        (fset 'directory-files directory-files-original))))))

Existe um ztreepacote disponível no Melpa que suporta comparação recursiva da árvore de diretórios: M-x ztree-diffusando os diffutilitários GNU para comparar os arquivos correspondentes.

Se você usar use-packageentão para instalar e configurar o ztreepacote, adicione ao seu .emacs:

;; ** recursive directory tree comparison: M-x ztree-diff
(use-package ztree
  :ensure t) ; needs GNU diff utility