Disable consult buffer preview for remote buffers

[mgraham]

I have been trying to disable consult buffer preview for remote buffers, but I am unable to get the solution in #224 and the wiki to work.

I'm tracing through the code in the solution and it looks to me that it sets filter to a lambda that returns either cand (the candidate) or nil (which it does when the candidate is a remote file):

(defun consult-buffer-state-no-tramp ()
  "Buffer state function that doesn't preview Tramp buffers."
  (let ((orig-state (consult--buffer-state))
        (filter (lambda (action cand)
                  (if (and cand
                           (or (eq action 'return)
                               (let ((buffer (get-buffer cand)))
                                 (and buffer
                                      (not (file-remote-p (buffer-local-value 'default-directory buffer)))))))
                      cand
                    nil))))
    (lambda (action cand)
      (funcall orig-state action (funcall filter action cand)))))

(setq consult--source-buffer
      (plist-put consult--source-buffer :state #'consult-buffer-state-no-tramp))

But even when I change the filter lambda so that it always returns nil, consult-buffer still gives me previews:

(defun consult-buffer-state-no-tramp ()
  "Buffer state function that doesn't preview any buffers."
  (let ((orig-state (consult--buffer-state))
        (filter (lambda (action cand)
                  (if (and cand
                           (or (eq action 'return)
                               (let ((buffer (get-buffer cand)))
                                 (and buffer
                                      (not (file-remote-p (buffer-local-value 'default-directory buffer)))))))
                      nil  ;; always return nil - for remote and local buffers
                    nil))))
    (lambda (action cand)
      (funcall orig-state action (funcall filter action cand)))))

(setq consult--source-buffer
      (plist-put consult--source-buffer :state #'consult-buffer-state-no-trampl))

I would expect that the above would disable previews for all buffers, but it doesn't.

Simplifying it further, the following code also fails to disable previews:

(defun consult-buffer-state-never-preview ()
  "Buffer state function that doesn't preview any buffers."
  (let ((orig-state (consult--buffer-state)))
    (lambda (action cand)
      (funcall orig-state action nil))))

(setq consult--source-buffer
      (plist-put consult--source-buffer :state #'consult-buffer-state-never-preview))

I don't know enough about the consult internals to know why these don't work. I went looking for the definition of consult--buffer-state but it's docs say that it is defined as a closure, not a defun, and I'm afraid I'm at the limit of my elisp skills!

[mgraham]

If I understand the docs for consult--with-preview correctly (and I'm not sure that I do), I think the idea is that if I wanted to use the state function to disable previews entirely, I would want this filter lambda to return nil when action is 'preview, and return cand when action is anything else. Essentially, we're intercepting the state function and calling (consult--buffer-state 'preview nil)?

I think that is what I am doing below:

(defun consult-buffer-state-disable-previews ()
  "Buffer state function that doesn't preview Tramp buffers."
  (lambda (action cand)
    (let ((orig-state (consult--buffer-state))
          (filter (lambda (action cand)
                    (if (eq action 'preview) nil
                      cand))))
      (lambda (action cand)
        (funcall (orig-state) action (funcall filter action cand))))))

(setq consult--source-buffer
      (plist-put consult--source-buffer :state #'consult-buffer-state-disable-previews))

However, when I run consult-buffer and cycle through the candidates, I do still see previews.

Note that at this point, this is nothing to do with remote buffers. I am just trying to see if I understand how I'm supposed to write the state function.

Have I got the right idea? That calling consult--buffer-state with a cand of nil when action is 'preview will disable previews? Or am I misunderstanding things?

[minad]

@mgraham Disabling buffer preview for certain buffers has been requested often. Would you like to prepare a patch which adds a variable consult-preview-excluded-buffers, similar to the already existing consult-preview-excluded-files? In the long term, this may be better than continuing with the potentially brittle wiki code.

[mgraham]

@minad - Sure - I can take a stab at that! I will have to spend some time grokking the consult internals first.

It looks like consult-preview-excluded-files is a regexp. I'm guessing consult-preview-excluded-buffers should probably be able to match on buffer name, major-mode, minor-mode and possibly other buffer attributes. Maybe it should be a lambda?

[minad]

There exists the new function buffer-match-p which we could use. We could use it for consult-preview-excluded-buffers and also replace consult-buffer-filter with it for consistency:

(buffer-match-p buf `(or ,@consult-buffer-filter))

My only gripe with this buffer-match-p function is that it is not particularly efficient. So we should maybe implement our own filter, which creates an efficient predicate function and a regexp.

(setq consult-buffer-filter
  '("regexp"      ;; stringp: regexp matchig buffer name
    (var list...) ;; consp: (member (buffer-local-value var) list), e.g., var=major-mode
    predicate))   ;; functionp: predicate function

[minad]

@mgraham I looked again a little more deeply into the existing Consult code, and I think a larger refactoring/consolidation concerning buffer filtering is needed. I will work on this when I find some time. Just letting you know, such that you don't have to spent time on creating a PR.

The rough plan:

1. consult--buffer-query will be deprecated in favor of a new function consult--buffer-list.
2. A new function consult--buffer-predicate will take a flexible filter expression (similar to buffer-match-p) as argument but compiles it to an efficient predicate function.
3. consult--buffer-list will take such a filter expression (or a predicate function) as argument, compiles it and returns the filtered list.

Then we can use consult--buffer-predicate to handle the new consult-preview-excluded-buffers and use consult--buffer-list instead of consult--buffer-query.

[mgraham]

Sounds good. Let me know if I can help

[minad]

For now I went with a simple solution and added consult-preview-excluded-buffers based on buffer-match-p. See e1621f4.

[TristanCacqueray]

Hello @minad , could you please explain how to use consult-preview-excluded-buffers to exclude remote files? Using (setq consult-preview-excluded-buffers 'file-remote-p) fails with Error in post-command-hook (consult--preview-post-command-hook): (wrong-type-argument stringp #<buffer *shell*>). Do we need to setup a custom predicate to get the buffer's file before using file-remote-p ?

[minad]

@TristanCacqueray Check out the documentation of buffer-match-p. I think you need a custom predicate, yes.

[TristanCacqueray]

Alright, the following predicate seems to work, though the debug statement shows a weird file-name for closed remote buffers (from recentf), it looks like they point at the currently opened buffer, but it seems like file-remote-p works as expected. Could this be added to the Wiki?

(defun buffer-remote-p (buf)                                                                                                                                                                                                                                                                                      
  "Return t when BUF is remote."                                                                                                                                                                                                                                                                                
  ;; (message "HERE [%s - %s]" buf (buffer-file-name buf))                                                                                                                                                                                                                                                         
  (if-let ((fp (buffer-file-name buf)))                                                                                                                                                                                                                                                                         
      (file-remote-p fp)                                                                                                                                                                                                                                                                                        
    nil))

(setq consult-preview-excluded-buffers 'buffer-remote-p)

Thanks!