[Bug/Support]: optionally bury *elpaca-log* buffers when no errors are found

[m-vitale]

Confirmation

• I have checked the documentation (README, Wiki, docstrings, etc)
• I am checking these without reading them.
• I have searched previous issues to see if my question is a duplicate.

Elpaca Version

0.11

Operating System

Linux

Description

Is it possible to bury the elpaca-log buffer and shrink the echo area back to normal when there're no installation errors?

I have a ugly solution attached to two hooks (to cover both startup and installations from the elpaca manager) that looks at the 4 numbers in the buffer header to decide (and this after waiting for an arbitrary 0.1 seconds as the hooks are invoked too early). I'd prefer a non ugly solution builtin in Elpaca, but haven't been able to find it.

[progfolio]

Please see this wiki entry and let me know if that helps:

https://github.com/progfolio/elpaca/wiki/Logging

[m-vitale]

Apologies for not having seen that part of the wiki.
I tried briefly and I'm not sure where this-command and last-command come from. In my case are both nil. I don't understand the intention either, as the commands listed in the variable definition seems to have nothing to do with the normal work of elpaca and rather be things one would do while developing elpaca.
Removing that (or ...) makes something happen, but I'm left with a window with 'elpaca-log', in Fundamental mode but with the header where elpaca shows progress and the buffer content removed. This might be because all buffers are special buffers and maybe quit-window doesn't find anything suitable.
As a reference, my ugly code using bury-buffer works in the the same situation of buffers and leaves me with scratch displayed. You can see my code here, but sit down first, it is ugly:

(defun neo/elpaca-header-numbers (&optional buffer)
  (when-let ((buf (or buffer (get-buffer "*elpaca-log*"))))
    (with-current-buffer buf
      (let ((s (format-mode-line header-line-format))) 
        (when (stringp s)
          (when (string-match "\\([0-9]+\\) +\\([0-9]+\\) +\\([0-9]+\\) +\\([0-9]+\\)" s)
            (mapcar #'string-to-number
                    (list (match-string 1 s) (match-string 2 s)
                          (match-string 3 s) (match-string 4 s)))))))))

(defun neo/elpaca-header-clean-p (&optional buffer)
  (when-let ((nums (neo/elpaca-header-numbers buffer)))
    (let ((finished (nth 0 nums))
          (blocked  (nth 1 nums))
          (failed   (nth 2 nums))
          (other    (nth 3 nums)))
      (and (numberp finished) 
           (= blocked 0)
           (= failed 0)
           (= other 0)))))

(defun neo/bury-elpaca-log ()
  (let ((b (get-buffer "*elpaca-log*")))
  (when (and b (buffer-live-p b))
    (dolist (w (get-buffer-window-list b nil t))
      (when (window-live-p w)
        (when (window-dedicated-p w) (set-window-dedicated-p w nil))
        (set-window-buffer w (other-buffer b t))))
    (bury-buffer b))))

(defun neo/elpaca-maybe-bury-log (&optional buffer)
  (let ((buf (or buffer (get-buffer "*elpaca-log*"))))
    (when (and buf (buffer-live-p buf) (neo/elpaca-header-clean-p buf))
      (neo/bury-elpaca-log)
      (message ""))))

;; TODO not robust, but I haven't found a better way. Without delay
;; the buffer might simply not be there by the time we're called.
(defun neo/elpaca--bury-log-deferred (&optional delay)
  "Run `neo/elpaca-maybe-bury-log' after DELAY seconds (default 0.1).
Also force a header/mode-line update in the log buffer before testing."
  (let ((delay (or delay 1)))
    (run-at-time delay nil
                 (lambda ()
                   (when-let ((b (get-buffer "*elpaca-log*")))
                     ;; ensure header-line is evaluated/rendered
                     (with-current-buffer b
                       (force-mode-line-update t))
                     (neo/elpaca-maybe-bury-log b))))))

(add-hook 'elpaca-after-init-hook #'neo/elpaca--bury-log-deferred)
(add-hook 'elpaca-post-queue-hook #'neo/elpaca--bury-log-deferred)

I particularly dislike the delay, a few days back .1 was ok. Today it wasn't.

[kaspar4]

I see, this-command and last-command are set by Emacs itself, never met them before. In my case they are nil because the elpaca-log buffer I want to bury is the one that pops up during startup when I haven't touched the keyboard yet.

[m-vitale]

Some more experimenting, as I thought the code in the wiki might have needed a delay in order to work "reliably".
With this minimal init.el (only change to your hook is ignoring this-command and last-command:

(defvar elpaca-installer-version 0.11)
(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
(defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
(defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
(defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                              :ref nil :depth 1 :inherit ignore
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca--activate-package)))
(let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
       (build (expand-file-name "elpaca/" elpaca-builds-directory))
       (order (cdr elpaca-order))
       (default-directory repo))
  (add-to-list 'load-path (if (file-exists-p build) build repo))
  (unless (file-exists-p repo)
    (make-directory repo t)
    (when (<= emacs-major-version 28) (require 'subr-x))
    (condition-case-unless-debug err
        (if-let* ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                  ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
                                                  ,@(when-let* ((depth (plist-get order :depth)))
                                                      (list (format "--depth=%d" depth) "--no-single-branch"))
                                                  ,(plist-get order :repo) ,repo))))
                  ((zerop (call-process "git" nil buffer t "checkout"
                                        (or (plist-get order :ref) "--"))))
                  (emacs (concat invocation-directory invocation-name))
                  ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                        "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                  ((require 'elpaca))
                  ((elpaca-generate-autoloads "elpaca" repo)))
            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
          (error "%s" (with-current-buffer buffer (buffer-string))))
      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
  (unless (require 'elpaca-autoloads nil t)
    (require 'elpaca)
    (elpaca-generate-autoloads "elpaca" repo)
    (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
(add-hook 'after-init-hook #'elpaca-process-queues)
(elpaca `(,@elpaca-order))

(defun +elpaca-hide-successful-log ()
    "Hide Elpaca log buffer if queues processed successfully."
    (message "this: %S last: %S" this-command last-command)
    (if-let ((incomplete (cl-find 'incomplete elpaca--queues :key #'elpaca-q<-status))
             ((elpaca-q<-elpacas incomplete)))
        nil
      (when-let ((log (bound-and-true-p elpaca-log-buffer))
                 (window (get-buffer-window log t)) ;; log buffer visible
                 ((or t (member last-command +elpaca-hide-log-commands)
                      (member this-command +elpaca-hide-log-commands))))
        (with-selected-window window (quit-window 'kill window)))))



;(add-hook 'elpaca-post-queue-hook #'+elpaca-hide-successful-log)

(defun neo/elpaca--bury-log-deferred (&optional delay)
  (let ((delay (or delay 1)))
    (run-at-time delay nil #'+elpaca-hide-successful-log)))
(add-hook 'elpaca-post-queue-hook #'neo/elpaca--bury-log-deferred)

(elpaca
 elpaca-use-package
 ;; Enable :elpaca use-package keyword.
 (elpaca-use-package-mode)
 ;; Assume :elpaca t unless otherwise specified.
 (setq elpaca-use-package-by-default t))

(elpaca-wait)

Here's what I see (in all cases I removed the eln and elpaca caches before running):

• with your hook end code but no (elpaca ...) and (elpaca-wait): things seems to work (I relaunched Emacs a number of times in different configurations. I think I've seen a failure (e.g. *elpaca-log* still visualized but empty), but I'm not sure. Let's say that if it fails with this configuration it is extremely rare.
• with your hook and the (elpaca ...) loading and (elpaca-wait): always failure (or at least so often that I gave up trying).
• with your code, but my hook that defers calling +elpaca-hide-successfull-log by one second: always success

This with Emacs 30.1. Let me know if you can reproduce.