Prevent dired-find-alternate-file from killing emacsclient

Question

When visiting a folder with emacsclient, for example through emacsclient ., using dired, opening a folder using a will cause emacsclient to terminate. I believe this is because a, bound to dired-find-alternate-file will close the buffer emacsclient is in some way bound to causing it to terminate. I observe the same behavior when using dired-single.el.

Is there any way to prevent this from happening? Given my above assumptions about how why this happens: to make dired reuse the same buffer rather than destroy it?

Answer 1

You could remap dired-find-alternate-file to a custom command which firstly checks to see whether server-buffer-clients is non-nil in that dired buffer. If it's nil then just go ahead and call dired-find-alternate-file; if it's set, then work around the issue...

Some possible workarounds are:

1. Call dired-find-file instead of dired-find-alternate-file. Maybe bury-buffer for the original buffer, too.

2. Set the buffer-local server-buffer-clients to nil. This will prevent server-kill-buffer from killing every client for which this was the sole remaining buffer of interest. It means there will be a stale entry in the buffers list for the client process -- but server-buffer-done already copes with dead buffers, so it's basically fine.

   Or similar: remove the buffer-local kill-buffer-hook entry server-kill-buffer in that buffer.

   Either way, when the dired buffer is killed, the client stays alive.

   That sounds good, but probably isn't actually sufficient. In the case you're interested in -- the one where that client in reality has no live buffers of interest after that dired buffer has been killed -- then that client is going to be killed the next time that any client-buffer (for any client) is killed -- so you might still lose the client without meaning to.

3. That all being the case, I think instead of using (2), your custom command would be better to call server-visit-files for the file you're asking dired to open, in order that the new buffer can be registered for the client (in practice you probably need to do this for every client which was interested in the original buffer). Then you're effectively shifting the client's interest from buffer to buffer, but it's not subject to sudden death on account of some other client.

Answer 2

This is an old question, but as this annoyance is not going away, I thought people might appreciate a code solution. My approach is to write alternatives to find-alternate-file and dired-find-alternate-file.

(defun my-find-alternate-file (newfile)
  "switch to new file, then kill old buffer"
  (remove-hook 'kill-buffer-hook 'server-kill-buffer t)
  (let ((my-old-buffer (current-buffer)))
    (find-file newfile)
    (kill-buffer my-old-buffer)))

(defun my-dired-find-alternate-file ()
  "open a new file from dired, then kill the old dired buffer"
  (interactive)
  (my-find-alternate-file (dired-get-file-for-visit)))

Uses @phils second approach and seems to be working for me.

=== edit ===

By the way, as of 28 you are supposed to be able to set dired-kill-when-opening-new-dired-buffer to get this same effect, but it only seems to works intermittently--most of the time you end up with an ever-expanding list of dired buffers.