embark-target-finder for current buffer/file?

[karthink]

How can I write an embark-target-this-file and embark-target-this-buffer that act on the current file/buffer? I have a bunch of functions like load-this-file, byte-compile-this-file, sudo-this-file and built-in ones like diff-buffer-with-file that I would like to call using embark directly. Right now I do dired-jump, then call embark on the current file.

These target finders should, of course, have a lower priority than embark-target-active-region, embark-target-file-at-point etc, so they're only activated if all the other target finders fail.

[oantolin]

If I understand correctly what you want to do you may not even need to define load-this-file, and just use the regular load-file instead. Something like this?

(defun embark-target-this-buffer ()
  (cons 'this-buffer (buffer-name)))

(add-to-list 'embark-target-finders #'embark-target-this-buffer 'append)

(embark-define-keymap this-buffer-map
  "Commands to act on current file or buffer."
  ("l" load-file)
  ("b" byte-compile-file)
  ("d" diff-buffer-with-file))

(add-to-list 'embark-keymap-alist '(this-buffer . this-buffer-map))

Does that work as you'd like?

[oantolin]

I should have said before answering: great idea! I think I want this in my config too!

[minad]

What about adding a target finder to Embark by default which returns (major-mode . buffer-name)? It allows you to copy the major mode via a general action 😎 or is there some value in not having an Embark context everywhere?

[hmelman]

I don't understand the value of this compared to just binding these commands to a key. Particularly load-file and byte-compile-file are only useful in emacs-lisp buffers, why not bind them via the emacs-lisp-mode-hook to something like C-c l and C-c b? Since a "this buffer" target would be lower priority, I think I would be annoyed when I wanted to use it but point was on a region or symbol (which it should be most of the time).

I totally understand the value of having these bound on the embark-file-map as they already are, though perhaps it would be cleaner if there was an elisp-file target and an embark-elisp-flle-map whose parent is embark-file-map.

FWIW, I have the following bound to C-c L in emacs-lisp bufers and use it all the time:

(defun hrm-load-current-lisp-file ()
  "Load the byte compiled form of the file if it's there or the .el file."
  (interactive)
  (and (buffer-modified-p)
       (y-or-n-p (format "Save file %s? " (buffer-file-name)))
       (save-buffer))
  (let ((possible-elc-file (concat buffer-file-name "c")))
    (if (and (file-exists-p possible-elc-file)
	     (file-readable-p possible-elc-file))
	(load possible-elc-file)
      (load buffer-file-name))))

[minad]

@hmelman having such buffer local bindings would let embark act like a context dependent leader key. Of course you could just bind everything under a prefix in the mode map. So I am also not really convinced that this is needed. The context of a buffer or mode somehow feels to big for embark.

[hmelman]

IMHO given the shadowing problem, embark feels like the wrong solution for this.

[oantolin]

@hmelman

I don't understand the value of this compared to just binding these commands to a key.

It's a little silly: it just saves you from choosing the file: M-x load-file prompts you for a file, M-n will pick the current file from the future history, and then you press RET to confirm. This saves the M-n and RET steps. It is only a minor inconvenience having to do those steps, but Emacs is the one piece of software where you almost never have to put up with minor inconveniences.

But of course I was talking about using load-file as an action verus using the same load-file as a command. However, @karthink already wrote a load-this-file command that does not prompt for a file an just operates on the current one. Binding that command to a prefix key is probably as good as using this target finder.

@minad

The context of a buffer or mode somehow feels to big for embark.

Yes, I can understand that feeling. It's fiddly, you have to make sure you're not on a smaller target.

[karthink]

If I understand correctly what you want to do you may not even need to define load-this-file, and just use the regular load-file instead. Something like this?
...
Does that work as you'd like?

This is perfect, thank you. I still need to figure out how to pack all the file-based and buffer-based commands I use into a single keymap without key collisions, or write different triggers and figure out the context to activate them separately, but I'll think about that for a bit.

As @minad points out, this is functionality that usually lives under a leader key, but that would require writing a bunch of functions that act on the current file (like load-this-file, email-attach-this-file etc), and I don't need that with embark. Even if I decide to use a leader key (or the shadowing annoys me), I can just do something like

(defun embark-act-on-buffer-file (&optional arg)
  (interactive "P")
  (let ((embark-target-finders (list embark-target-this-buffer)))
    (embark-act arg)))

and bind that to a leader instead.

Alternatively I can use a major-mode specific hydra for buffer/file actions, but I don't have any of that set up (and I'm not sure how to), and Embark is 90% of the way there already.

[oantolin]

I'll close this to indicate nothing in the Embark code base needs to change, but of course the discussion can continue.

[karthink]

In case someone wants to use embark as a leader key, here's the full recipe:

(defun embark-target-this-buffer-file ()
  (cons 'this-buffer-file (or (buffer-file-name) (buffer-name))))

(add-to-list 'embark-target-finders #'embark-target-this-buffer-file 'append)

(add-to-list 'embark-keymap-alist '(this-buffer-file . this-buffer-file-map))

(embark-define-keymap this-buffer-file-map
      "Commands to act on current file or buffer."
      ("l" load-file)
      ("b" byte-compile-file)
      ("S" sudo-find-file)
      ("U" 0x0-upload)
      ("r" rename-file-and-buffer)
      ("d" diff-buffer-with-file)
      ("=" ediff-buffers)
      ("C-=" ediff-files)
      ("!" shell-command)
      ("&" async-shell-command)
      ("x" consult-file-externally)
      ("C-a" mml-attach-file)
      ("c" copy-file)
      ("k" kill-buffer)
      ("z" bury-buffer)
      ("|" embark-shell-command-on-buffer)
      ("g" revert-buffer))

The advantange over just defining a prefix-command in Emacs is as follows:

1. Due to the fact that Embark injects the target into the input prompt of these interactive functions, I didn't have to write any wrappers to make them act on the current buffer/file (except for mml-attach-file which is broken here for now).
2. I don't need to find and memorize a new keybinding. It just overloads Embark.
3. It's the same key mappings as embark-buffer-map and embark-file-map. Again, more consistent behavior.

The disadvantages are

1. This functionality can be shadowed by other target-finders. There is an alternative (see below), but I haven't actually had this happen yet in a week of usage.
2. This mixes file and buffer actions in a single keymap, and causes trouble when the file name differs from the buffer name.

One modification you might consider is to let-bind embark-target-finders so that the above keymap is consistently activated, even if some other Embark target would have precedence (like the region or a symbol). Then this acts like a true leader key, not a fallback behavior of Embark, although you need a new dedicated keybinding.

(defun embark-act-on-buffer-file (&optional arg)
  (interactive "P")
  (let ((embark-target-finders '(embark-target-this-buffer-file)))
    (embark-act arg)))

(global-set-key (kbd "C-c o") 'embark-act-on-buffer-file)

[oantolin]

Now that we have @minad's fabulous multiple target support, this target finders triggers anywhere within a buffer, but with lowest priority. If you feel you need to cycle too much to reach it, then probably you should change the expression and defun target finders in your personal configuration.

[karthink]

A timely comment! I was just trying to figure out how to tweak embark's new behavior so I could get to this-buffer-file-map quickly.

[minad]

A cheap addition would be a prefix argument to embark-cycle.

EDIT: And also to embark-act/dwim. In the minibuffer the argument already has a fixed meaning, but at point one could use it for cycling. C-- C-. would then act on the last target and M-- M-. would dwim the last target, given my favorite C/M-. Embark keybindings.