emenel/doomemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove doom--cycle-real-buffers; refactor kill-this-buffer advice

Browse source 
cycle-real-buffers was a tidbit of complexity that was never necessary
in the first place. This functionality was already available in the form
of the frame buffer-predicate parameter, which controls where functions
like next-buffer and other-buffer can land you.

The only thing I have to do myself, is check for the condition where
there are no more real buffers left to switch to, and in that case send
you to the fallback-buffer.
This commit is contained in:
Henrik Lissner 2018-02-02 04:23:54 -05:00
parent ec7f20589a
commit d1953e00c4
No known key found for this signature in database
GPG key ID: 5F6C0EA160557395
3 changed files with 10 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

26
core/autoload/buffers.el
View file

@ -150,32 +150,6 @@ If DERIVED-P, test with `derived-mode-p', otherwise use `eq'."
when (string-match-p pattern (buffer-name buf))
collect buf))
(defun doom--cycle-real-buffers (n)
"Switch to the next buffer N times (previous, if N < 0), skipping over unreal
buffers. If there's nothing left, switch to `doom-fallback-buffer'. See
`doom-real-buffer-p' for what 'real' means."
(if (null n)
(switch-to-buffer (doom-fallback-buffer) nil t)
(let ((buffers (delq (current-buffer) (doom-real-buffer-list))))
(cond ((or (not buffers)
(zerop (% n (1+ (length buffers)))))
(switch-to-buffer (doom-fallback-buffer) nil t))
((= (length buffers) 1)
(switch-to-buffer (car buffers) nil t))
(t
;; Why this instead of switching straight to the Nth buffer in
;; BUFFERS? Because `switch-to-next-buffer' and
;; `switch-to-prev-buffer' properly update buffer list order.
(cl-loop with move-func =
(if (> n 0) #'switch-to-next-buffer #'switch-to-prev-buffer)
for i to 20
while (not (memq (current-buffer) buffers))
do
(dotimes (_i (abs n))
(funcall move-func)))))))
(force-mode-line-update)
(current-buffer))
;;;###autoload
(defun doom-set-buffer-real (buffer flag)
"Forcibly mark BUFFER as FLAG (non-nil = real)."

16
core/core-ui.el
View file

@ -540,16 +540,20 @@ instead)."
(not (eq (current-buffer) (doom-fallback-buffer))))
(defun doom*switch-to-fallback-buffer-maybe (orig-fn)
"Advice for `kill-this-buffer'. If there are no real buffers left, switch to
`doom-fallback-buffer'."
"Advice for `kill-this-buffer'. If in a dedicated window, delete it. If there
are no real buffers left, switch to `doom-fallback-buffer'. Otherwise, delegate
to original `kill-this-buffer'."
(let ((buf (current-buffer)))
(cond ((window-dedicated-p)
(delete-window))
((doom-real-buffer-p buf)
(previous-buffer)
(doom--cycle-real-buffers
(if (delq buf (doom-real-buffer-list)) -1))
(kill-buffer buf))
(or (kill-buffer buf)
(previous-buffer))
;; if there are no (real) buffers left to switch to, land on the
;; fallback buffer.
(unless (cl-set-difference (doom-real-buffer-list)
(doom-visible-buffers))
(switch-to-buffer (doom-fallback-buffer))))
(t
(funcall orig-fn)))))

21
core/test/autoload-buffers.el
View file

@ -109,27 +109,6 @@
(should (buffer-live-p fallback))
(should (equal (buffer-name fallback) doom-fallback-buffer-name))))
;; `doom--cycle-real-buffers'
(def-test! kill-buffer-then-show-real-buffer
(with-temp-buffers!! (a b c d)
(let-advice!! ((kill-this-buffer :around doom*switch-to-fallback-buffer-maybe))
(dolist (buf (list a b d))
(with-current-buffer buf
(setq-local buffer-file-name "x")))
(should (cl-every #'buffer-live-p (buffer-list)))
(switch-to-buffer a)
(should (eq (current-buffer) a))
(should (eq (selected-window) (get-buffer-window a)))
(kill-this-buffer)
(should-not (eq (current-buffer) a))
(should-not (buffer-live-p a))
;; eventually end up in the fallback buffer
(let ((fallback (doom-fallback-buffer)))
(while (not (eq (current-buffer) fallback))
(should (doom-real-buffer-p))
(kill-this-buffer))
(should (eq (current-buffer) fallback))))))
;; `doom-kill-buffer-and-windows'
(def-test! kill-buffer-and-windows
(with-temp-buffers!! (a b)