GNU ELPA - embark

This package provides a sort of right-click contextual menu for Emacs, accessed through the embark-act command (which you should bind to a convenient key), offering you relevant actions to use on a target determined by the context:

• In the minibuffer, the target is the current top completion candidate.
• In the *Completions* buffer the target is the completion at point.
• In a regular buffer, the target is the region if active, or else the file, symbol, URL, s-expression or defun at point.

Multiple targets can be present at the same location and you can cycle between them by repeating the embark-act key binding. The type of actions offered depend on the type of the target. Here is a sample of a few of the actions offered in the default configuration:

• For files you get offered actions like deleting, copying, renaming, visiting in another window, running a shell command on the file, etc.
• For buffers the actions include switching to or killing the buffer.
• For package names the actions include installing, removing or visiting the homepage.
• For Emacs Lisp symbols the actions include finding the definition, looking up documentation, evaluating (which for a variable immediately shows the value, but for a function lets you pass it some arguments first). There are some actions specific to variables, such as setting the value directly or though the customize system, and some actions specific to commands, such as binding it to a key.

By default when you use embark-act if you don't immediately select an action, after a short delay Embark will pop up a buffer showing a list of actions and their corresponding key bindings. If you are using embark-act outside the minibuffer, Embark will also highlight the current target. These behaviors are configurable via the variable embark-indicators. Instead of selecting an action via its key binding, you can select it by name with completion by typing C-h after embark-act.

Everything is easily configurable: determining the current target, classifying it, and deciding which actions are offered for each type in the classification. The above introduction just mentions part of the default configuration.

Configuring which actions are offered for a type is particularly easy and requires no programming: the variable embark-keymap-alist associates target types with variables containing keymaps, and those keymaps containing bindings for the actions. (To examine the available categories and their associated keymaps, you can use C-h v embark-keymap-alist or customize that variable.) For example, in the default configuration the type file is associated with the symbol embark-file-map. That symbol names a keymap with single-letter key bindings for common Emacs file commands, for instance c is bound to copy-file. This means that if you are in the minibuffer after running a command that prompts for a file, such as find-file or rename-file, you can copy a file by running embark-act and then pressing c.

These action keymaps are very convenient but not strictly necessary when using embark-act: you can use any command that reads from the minibuffer as an action and the target of the action will be inserted at the first minibuffer prompt. After running embark-act all of your key bindings and even execute-extended-command can be used to run a command. For example, if you want to replace all occurrences of the symbol at point, just use M-% as the action, there is no need to bind query-replace in one of Embark's keymaps. Also, those action keymaps are normal Emacs keymaps and you should feel free to bind in them whatever commands you find useful as actions and want to be available through convenient bindings.

The actions in embark-general-map are available no matter what type of completion you are in the middle of. By default this includes bindings to save the current candidate in the kill ring and to insert the current candidate in the previously selected buffer (the buffer that was current when you executed a command that opened up the minibuffer).

Emacs's minibuffer completion system includes metadata indicating the category of what is being completed. For example, find-file's metadata indicates a category of file and switch-to-buffer's metadata indicates a category of buffer. Embark has the related notion of the type of a target for actions, and by default when category metadata is present it is taken to be the type of minibuffer completion candidates when used as targets. Emacs commands often do not set useful category metadata so the Marginalia package, which supplies this missing metadata, is highly recommended for use with Embark.

Embark's default configuration has actions for the following target types: files, buffers, symbols, packages, URLs, bookmarks, and as a somewhat special case, actions for when the region is active. You can read about the default actions and their key bindings on the GitHub project wiki.

Embark has a notion of default action for a target:

• If the target is a minibuffer completion candidate, then the default action is whatever command opened the minibuffer in the first place. For example if you run kill-buffer, then the default action will be to kill buffers.
• If the target comes from a regular buffer (i.e., not a minibuffer), then the default action is whatever is bound to RET in the keymap of actions for that type of target. For example, in Embark's default configuration for a URL found at point the default action is browse-url, because RET is bound to browse-url in the embark-url-map keymap.

To run the default action you can press RET after running embark-act. Note that if there are several different targets at a given location, each has its own default action, so first cycle to the target you want and then press RET to run the corresponding default action.

There is also the embark-dwim which runs the default action for the first target found. It's pretty handy in non-minibuffer buffers: with Embark's default configuration it will

Besides acting individually on targets, Embark lets you work collectively on a set of target candidates. For example, while you are in the minibuffer the candidates are simply the possible completions of your input. Embark provides two main commands to work on candidate sets:

• The embark-collect-snapshot command produces a buffer listing all the current candidates, for you to peruse and run actions on at your leisure. The candidates can be viewed in a grid or as a list showing additional annotations.

• The embark-export command tries to open a buffer in an appropriate major mode for the set of candidates. If the candidates are files export produces a Dired buffer; if they are buffers, you get an Ibuffer buffer; and if they are packages you get a buffer in package menu mode.

  If you use the grepping commands from the Consult package, consult-grep, consult-git-grep or consult-ripgrep, then you'll probably want to install and load the embark-consult package, which adds support for exporting a list of grep results to an honest grep-mode buffer, on which you can even use wgrep if you wish.

When in doubt choosing among these a good rule of thumb is to always prefer embark-export since when an exporter to a special major mode is available for a given type of target, it will be more featureful than an Embark collect buffer, and if no such exporter is configured the embark-export command falls back to the generic embark-collect-snapshot.

These commands are always available as "actions" (although they do not act on just the current target but on all candidates) for embark-act and are bound to S, E, respectively, in embark-general-map. This means that you do not have to bind your own key bindings for these (although you can, of course!), just a key binding for embark-act.

There is also the embark-collect-live variant of embark-collect-snapshot which produces "live" Embark Collect buffers, meaning they auto-update as the set of candidates changes. Most users of visual completion UIs such as Vertico, Icomplete, Selectrum or Ivy will probably either not want to use this, to avoid seeing double (the list of candidates is displayed both by Embark and by the completion UI), or to configure their completion UI to hide while using embark-collect-live. See the Embark wiki for sample configuration for Selectrum.

Embark also has the embark-become command which is useful for when you run a command, start typing at the minibuffer and realize you meant a different command. The most common case for me is that I run switch-to-buffer, start typing a buffer name and realize I haven't opened the file I had in mind yet! I'll use this situation as a running example to illustrate embark-become. When this happens I can, of course, press C-g and then run find-file and open the file, but this requires retyping the portion of the file name you already typed. This process can be streamlined with embark-become: while still in the switch-to-buffer you can run embark-become and effectively make the switch-to-buffer command become find-file for this run.

You can bind embark-become to a key in minibuffer-local-map, but it is also available as an action under the letter B (uppercase), so you don't need a binding if you already have one for embark-act. So, assuming I have embark-act bound to, say, C-., once I realize I haven't open the file I can type C-. B C-x C-f to have switch-to-buffer become find-file without losing what I have already typed in the minibuffer.

But for even more convenience, embark-become offers shorter key bindings for commands you are likely to want the current command to become. When you use embark-become it looks for the current command in all keymaps named in the list embark-become-keymaps and then activates all keymaps that contain it. For example, the default value of embark-become-keymaps contains a keymap embark-become-file+buffer-map with bindings for several commands related to files and buffers, in particular, it binds switch-to-buffer to b and find-file to f. So when I accidentally try to switch to a buffer for a file I haven't opened yet, embark-become finds that the command I ran, switch-to-buffer, is in the keymap embark-become-file+buffer-map, so it activates that keymap (and any others that also contain a binding for switch-to-buffer). The end result is that I can type C-. B f to switch to find-file.

By default, if you run embark-act and do not immediately select an action, after a short delay Embark will pop up a buffer called *Embark Actions* containing a list of available actions with their key bindings. You can scroll that buffer with the mouse of with the usual commands scroll-other-window and scroll-other-window-down (bound by default to C-M-v and C-M-S-v).

That functionality is provided by the embark-mixed-indicator, but Embark has other indicators that can provide information about the target and its type, what other targets you can cycle to, and which actions have key bindings in the action map for the current type of target. Any number of indicators can be active at once and the user option embark-indicators should be set to a list of the desired indicators.

Embark comes with the following indicators:

• embark-minimal-indicator: shows a messages in the echo area or minibuffer prompt showing the current target and the types of all targets starting with the current one; this one is on by default.
• embark-highlight-indicator: highlights the target at point; also on by default.
• embark-verbose-indicator: displays a table of actions and their key bindings in a buffer; this is not on by default, in favor of the mixed indicator described next.
• embark-mixed-indicator: starts out by behaving as the minimal indicator but after a short delay acts as the verbose indicator; this is on by default.
• embark-isearch-highlight-indicator: this only does something when the current target is the symbol at point, in which case it lazily highlights all occurrences of that symbol in the current buffer, like isearch; also on by default.

Users of the popular which-key package may prefer to use the embark-which-key-indicator from the Embark wiki. Just copy its definition from the wiki into your configuration and customize the embark-indicators user option to exclude the mixed and verbose indicators and to include embark-which-key-indicator.

As an alternative to reading the list of actions in the verbose or mixed indicators (see the previous section for a description of these), you can use embark-keymap-help after running embark-act which is bound to C-h in all of Embark's action keymaps. That command will prompt you for the name of an action with completion (but feel free to enter a command that is not among the offered candidates!), and will also remind you of the key bindings. You can press @ at the prompt and then one of the key bindings to enter the name of the corresponding action.

You may think that with the *Embark Actions* buffer popping up to remind you of the key bindings you'd never want to use completion to select an action by name, but personally I find that typing a small portion of the action name to narrow down the list of candidates feels significantly faster than visually scanning the entire list of actions.

If you find you prefer entering actions that way, you can configure embark to always prompt you for actions by setting the variable embark-prompter to embark-completing-read-prompter.

By default, if you call embark-act from the minibuffer it quits the minibuffer after performing the action. You can change this by setting the user option embark-quit-after-action to nil. That variable controls whether or not embark-act quits the minibuffer when you call it without a prefix argument, and you can select the opposite behavior to what the variable says by calling embark-act with C-u. Note that both the variable embark-quit-after-action and C-u have no effect when you call embark-act outside the minibuffer.

Having embark-act not quit the minibuffer can be useful to turn commands into little "thing managers". For example, you can use find-file as a little file manager or describe-package as a little package manager: you can run those commands, perform a series of actions, and then quit the command.

If you find yourself using the quitting and non-quitting variants of embark-act about equally often, you may prefer to have separate commands for them instead of a single command that you call with C-u half the time. You could, for example, keep the default exiting behavior of embark-act and define a non-quitting version as follows:

(defun embark-act-noquit ()
  "Run action but don't quit the minibuffer afterwards."
  (interactive)
  (let ((embark-quit-after-action nil))
    (embark-act)))

By default, for most commands embark inserts the target of the action into the next minibuffer prompt and "presses RET" for you, accepting the target as is.

For some commands this might be undesirable, either for safety (because a command is "hard to undo", like delete-file or kill-buffer), or because further input is required next to the target (like when using shell-command: the target is the file and you still need to enter a shell command to run on it, at the same prompt). You can add such commands to the embark-allow-edit-actions variable (which by default already contains the examples mentioned, and a few others as well).

You can customize what happens after the target is inserted at the minibuffer prompt of an action. There are embark-setup-action-hooks, that are run by default after injecting the target into the minibuffer. The hook can be specified for specific action commands by associating the command to the desired hook. By default the hooks with the key t are executed.

For example, consider using shell-command as an action during file completion. It would be useful to insert a space before the target file name and to leave the point at the beginning, so you can immediately type the shell command. That's why in embark's default configuration there is an entry in embark-setup-action-hooks associating shell-command to embark--shell-prep, a simple helper command that quotes all the spaces in the file name, inserts an extra space at the beginning of the line and leaves point to the left of it.

All internal keymaps are defined with a helper macro embark-define-keymap that you can use to define your own keymaps, whether they are for new categories in embark-keymap-alist or for any other purpose! For example a simple version of the file action keymap could be defined as follows:

(embark-define-keymap embark-file-map
  "Example keymap with a few file actions"
  ("d" delete-file)
  ("r" rename-file)
  ("c" copy-file))

Remember also that these action keymaps are perfectly normal Emacs keymaps, and do not need to be created with this helper macro. You can use the built-in define-key, or your favorite external package such as bind-key or general.el to manage them.

It is easy to configure Embark to provide actions for new types of targets, either in the minibuffer or outside it. I present below two very detailed examples of how to do this. At several points I'll explain more than one way to proceed, typically with the easiest option first. I include the alternative options since there will be similar situations where the easiest option is not available.

Alternatively, Embark does support one other type of action: a non-interactive function of a single argument. The target is passed as argument to the function. For example:

(defun example-action-function (target)
  (message "The target was `%s'." target))

(define-key embark-symbol-map "X4" #'example-action-function)

Note that normally binding non-interactive functions in a keymap is useless, since when attempting to run them using the key binding you get an error message similar to "Wrong type argument: commandp, example-action-function". In general it is more flexible to write any new Embark actions as commands, that is, as interactive functions, because that way you can also run them directly, without Embark. But there are a couple of reasons to use non-interactive functions as actions:

1. You may already have the function lying around, and it is convenient to simply reuse it.
2. For command actions the targets can only be simple string, with no text properties. For certain advanced uses you may want the action to receive a string with some text properties, or even a non-string target.