Prompt de buffer de interrupção com opção para diferenciar as alterações

O save-some-bufferscomando solicita salvar ou ignorar cada arquivo modificado e também fornece uma opção para diferenciar o arquivo modificado no arquivo que está visitando.

Eu gostaria do mesmo comportamento de kill-bufferou kill-this-buffer. Se o buffer for modificado, já existe um prompt de sim / não, mas eu também gostaria da opção de ver as diferenças.

Existe uma maneira interna de fazer isso ou um ponto de extensão apropriado? Ou devo apenas ligar meu próprio comando kill-buffer?

A grande questão é se você deseja esse comportamento por kill-buffersi só, o que significa não apenas quando você o chama de maneira interativa, mas para todo uso no código Lisp existente, ou se você deseja apenas para uso interativo.

Eu vou assumir o último. Nesse caso, deixe em kill-bufferpaz, defina seu próprio comando que faça o que você deseja e remapeie as chaves que normalmente estão vinculadas kill-bufferao seu comando:

(global-set-key [remap kill-buffer] 'my-kill-buffer)

Para seu my-kill-buffercomando, basta verificar desde o início se o buffer foi modificado e, em caso afirmativo, inicie ediff-o.

Para verificar se foi modificado, use buffer-modified-p.

Para ediffvocê, você provavelmente desejaria pegar o arquivo (ou seja, o buffer como salvo) e diferenciá-lo do atual buffer modificado. Você pode precisar mexer um pouco para fazer isso - não conheço um ediffcomando existente que faça isso.

Mas talvez tudo o que você realmente precise seja algo parecido highlight-changes-mode. Veja o manual do Emacs, nó Highlight Interactively. Em outras palavras, talvez tudo o que você precise é invocar highlight-changes-modese o buffer foi modificado.

Com base nas outras respostas e comentários, aqui está um comando kill personalizado que fornece a opção de diferenciar um buffer modificado com o arquivo que ele está visitando. Eu mapeei isso para, C-x C-kmas também poderia remapear kill-buffercomo sugerido na resposta de @ Drew.

(defun my/kill-this-buffer ()
  (interactive)
  (catch 'quit
    (save-window-excursion
      (let (done)
        (when (and buffer-file-name (buffer-modified-p))
          (while (not done)
            (let ((response (read-char-choice
                             (format "Save file %s? (y, n, d, q) " (buffer-file-name))
                             '(?y ?n ?d ?q))))
              (setq done (cond
                          ((eq response ?q) (throw 'quit nil))
                          ((eq response ?y) (save-buffer) t)
                          ((eq response ?n) (set-buffer-modified-p nil) t)
                          ((eq response ?d) (diff-buffer-with-file) nil))))))
        (kill-buffer (current-buffer))))))

Usando a mesma implementação básica, você também pode aconselhar kill-buffer. Com essa abordagem, você tem a opção de ver diferenças em qualquer lugar que kill-bufferseja chamado - por exemplo, ao eliminar buffers marcados do Ibuffer.

(defun my/kill-buffer (orig-func &optional buffer-or-name)
  (catch 'quit
    (save-window-excursion
      (with-current-buffer buffer-or-name
        (let (done (buf (current-buffer)))
          (when (and buffer-file-name (buffer-modified-p))
            (while (not done)
              (let ((response (read-char-choice
                               (format "Save file %s? (y, n, d, q) " (buffer-file-name buf))
                               '(?y ?n ?d ?q))))
                (setq done (cond
                            ((eq response ?q) (throw 'quit nil))
                            ((eq response ?y) (save-buffer) t)
                            ((eq response ?n) (set-buffer-modified-p nil) t)
                            ((eq response ?d) (diff-buffer-with-file) nil))))))
          (apply orig-func (list (current-buffer))))))))

(advice-add 'kill-buffer :around #'my/kill-buffer)