Rename scratch buffer and ask confirmation to kill non-file buffers created by user

Question

I tend to use often non-file buffers kinda like post-it-notes and it is way too easy to kill them inadvertently, as there is no confirmation to kill. Even if you enforce the habit of writing only in file buffers (subject to confirmation), you might still inadvertently write in a non-file buffer.

Therefore, I created a kill-hook to ask kill confirmation, but only for buffers that I created (setting global buffer-offer-save would make Emacs unusable). To identify user buffers, I exploit the fact that the name of buffers created automatically starts with a star.

Now, given its prominence, I would like to use the *scratch* buffer as a note taking buffer too. In this case, to fit the Emacs naming convention, I need to rename it scratch (or anyway something without the star).

I see two possibilities:

1. I prevent its creation: in the kill hook I check if I am going to kill the last buffer and create my scratch, to prevent the creation of Emacs' *scratch*.

2. I look for a create create-scratch-buffer hook and rename the scratch here.

As for point 1, (length (list-buffers)) includes also so called non-interesting (hidden) buffers and I would happily avoid to parse names with regexp on every hook call (to detect interesting buffers).

As for point 2, how can I detect the scratch buffer creation? Perhaps with a mode hook, e.g. something like:

(add-hook 'after-change-major-mode-hook 'rename-scratch)

My actual kill hook follows.

(add-to-list 'kill-buffer-query-functions   'ask-before-killing-user-buffer)
(defun ask-before-killing-user-buffer ()
  "If the current buffer is a user buffer, ask for saving before killing.
Here a user buffer is one not: associated to a file, belonging to a process or auto-created by Emacs. 
The latter are considered such when starting with the usual `*'.
The proposed filename will not be accepted if any buffer is already visiting the file"
  (interactive)
  (let* (save-name visited-by exit-while-p
           (ask "Save file as: ")
           (buffer (current-buffer))    
           (buffer-name (buffer-name))
           (user-buff-p (if (or (string-match  "^ \\|\\*" buffer-name)
                    (get-buffer-process buffer)
                    (buffer-file-name)) nil t)))

    ;; Ask to save modified buffer
    (if (and user-buff-p (buffer-modified-p))
    (if (y-or-n-p (format "`%s' was modified; save it? " buffer-name))
        (progn
          ;; accept only non visited file names
          (setq default-directory DEFAULT-SAVE-DIR)
          (while (not exit-while-p)
        (setq save-name (file-truename (read-file-name ask nil nil nil buffer-name)))
        (setq visited-by (find-buffer-visiting save-name))
        (if visited-by
            (setq ask (format "`%s' is being visited by buffer `%s'.\nPlease choose another name: "
                      save-name (buffer-name visited-by)))                 
          (setq exit-while-p t)))
          (write-file save-name t))))

    t))

UPDATE

Try to answer to your comments, clarifiying what I am willing to achieve.

I have a shortcut creating buffers named scratch1, scratch2, etc to readily copy snippets from web pages or from ebooks, to type a nearby task, the draft of an email, etc. Normally these are ephemeral buffers never translating into files, they live until the text snippets are copied in actual documents (but occasionally the buffer is edited and saved). Important original material gets immediately the status of file-buffer (with the related backup facilities); it is anyway unpleasant to accidentally kill my scratches, despite I can recover them going on the source web page, ebook etc. Just like it is not crucial to lose your remember-the-milk notes, but ...

Currently using a mode hook seems to me a solution without to much overhead:

(defun rename-scratch-buffer ()
  (if (and (get-buffer "*scratch*") (not (get-buffer "scratch")))      
      (with-current-buffer "*scratch*"  (rename-buffer "scratch"))))
(add-hook 'after-change-major-mode-hook 'rename-scratch-buffer)

Answer 1

I guess much of this is a matter of taste and usage patterns. I tend to use something inbetween your solution and @Drew's usage (according to the comments).

Here is the gist of it:

• I want "throwaway" buffers to be quickly available, without having to think ahead of time where to save them;
• I want them to be file buffers in order for Emacs to warn me if I accidentally kill them;
• I don't want to accidentally save them due to my C-xC-s OCD.

And here is the way I implement it:

• M-xfind-scratch-bufferRET visits a new scratch buffer, associated to a file in /tmp/scratch-buffer/ and named scratch<N> (or you can provide an explicit name using the universal prefix argument)

• the newly created buffer is put in scratch-mode, which remaps C-xC-s to C-xC-w, meaning that if you accidentally want to save the file, you will be prompted for a location.

And the code:

(defvar scratch-mode-directory "/tmp/scratch-buffer/"
  "Prefix path for scratch buffers")

(defvar scratch-mode--index 0
  "Index of the newest anonymous scratch buffer.")

(defun scratch-mode-write-file ()
  "Run whatever is bound to \"C-x C-w\".
This should be something like `write-file'."
  (interactive)
  (call-interactively (key-binding (kbd "C-x C-w"))))

(define-minor-mode scratch-mode
  "Minor mode for temporary buffers"
  :global nil
  :init-value nil
  :lighter " scratch"
  :keymap (let ((map (make-sparse-keymap)))
            (define-key map (kbd "C-x C-s") #'scratch-mode-write-file)
            map))

(defun scratch-mode--enable-maybe ()
  (when (string= scratch-mode-directory
                 (file-name-directory
                  (or (buffer-file-name) "")))
    (scratch-mode 1)))

(add-hook 'after-change-major-mode-hook #'scratch-mode--enable-maybe)

(defun find-scratch-buffer (&optional name)
  "Visit a scratch buffer.
When NAME is not provided, it defaults to \"scratch<N>\".  The
newly created buffer inherits the current value of
`default-directory', and is put in `scratch-mode'."
  (interactive `(,(if current-prefix-arg
                      (read-from-minibuffer "Scratch name: ")
                    nil)))
  (unless (file-exists-p scratch-mode-directory)
    (make-directory scratch-mode-directory t))
  (let ((dd default-directory))
    (find-file (format "%s%s"
                       scratch-mode-directory
                       (or name
                           (format "scratch<%d>" (incf scratch-mode--index)))))
    (setq default-directory dd)))

Answer 2

I made it slightly different (but the previous answers helped me a lot, thanks guys), to avoid string matching.

I modified the "new-empty-buffer" function suggested by Xah Lee from ErgoEmacs, making it set a local-variable 'custom-scratch-buffer when the buffer is created.

Therefore, we know when the buffer is a scratch buffer created by this function and we can add a query to the kill-buffer-query-functions list identifying this kind of buffer.

Here goes the code:

(defun custom-scratch-buffer-create ()
  "Open a new empty buffer.
URL `http://ergoemacs.org/emacs/emacs_new_empty_buffer.html'
Version 2016-08-11"
  (interactive)
  (let ((-buf (generate-new-buffer "untitled")))
    (switch-to-buffer -buf)
    (funcall initial-major-mode)
    (setq buffer-offer-save t)
    (set (make-local-variable 'custom-scratch-buffer) t))) ;; I added this line

(defun custom-scratch-buffer-kill-query-function ()
  (if (and (not buffer-file-name)           ;; buffer is not visiting a file
           (buffer-modified-p)              ;; buffer has been modified
           (boundp 'custom-scratch-buffer))
      (if 'custom-scratch-buffer            ;; buffer is a custom scratch created buffer
          (yes-or-no-p "Scratch buffer modified. Kill it anyway? "))
    t))

;; run query before killing if buffer is custom-scratch-buffer
(add-to-list 'kill-buffer-query-functions 'custom-scratch-buffer-kill-query-function)

Now you can bind the function custom-scratch-buffer-create to a key or use it with M-x.

Answer 3

After some testing, I saw the solution, based on the hook after-change-major-mode-hook, proposed in the question, works most of the time to modify the scratch buffer name. Anyway, when killing scratch (with the modified name) and when it is the only Emacs buffer, *scratch* might be recreated without triggering (the change-mode hook and therefore) the name modification.

To avoid this, it is sufficient not to allow to kill scratch when it is the last buffer. Therefore we need to add a proper hook to kill-buffer-query-functions which returns nil in this instance (nil causes Emacs not execute the kill).

(add-to-list 'kill-buffer-query-functions 'check-scratch)
(defun check-scratch ()
  (let ((bufs (remq nil
            (mapcar
             #'(lambda (x) (string-match "^[^ ]" x)) 
             (mapcar 'buffer-name (buffer-list))))))
    (if (and (not (buffer-modified-p))
         (string= (buffer-name) "scratch") 
         (eq (length bufs) 1))
    nil t)))