Hydra for evil-mc

Tue, 16 May 2023 14:42:08 +0100

At least in Doom Emacs the default keybindings for evil-mc are really cumbersome, here’s a Hydra that makes things much easier:

(defhydra my-mc-hydra (:color pink
                       :hint nil
                       :pre (evil-mc-pause-cursors))
  "
^Match^            ^Line-wise^           ^Manual^
^^^^^^----------------------------------------------------
_Z_: match all     _J_: make & go down   _z_: toggle here
_m_: make & next   _K_: make & go up     _r_: remove last
_M_: make & prev   ^ ^                   _R_: remove all
_n_: skip & next   ^ ^                   _p_: pause/resume
_N_: skip & prev

Current pattern: %`evil-mc-pattern

"
  ("Z" #'evil-mc-make-all-cursors)
  ("m" #'evil-mc-make-and-goto-next-match)
  ("M" #'evil-mc-make-and-goto-prev-match)
  ("n" #'evil-mc-skip-and-goto-next-match)
  ("N" #'evil-mc-skip-and-goto-prev-match)
  ("J" #'evil-mc-make-cursor-move-next-line)
  ("K" #'evil-mc-make-cursor-move-prev-line)
  ("z" #'+multiple-cursors/evil-mc-toggle-cursor-here)
  ("r" #'+multiple-cursors/evil-mc-undo-cursor)
  ("R" #'evil-mc-undo-all-cursors)
  ("p" #'+multiple-cursors/evil-mc-toggle-cursors)
  ("q" #'evil-mc-resume-cursors "quit" :color blue)
  ("<escape>" #'evil-mc-resume-cursors "quit" :color blue))

Here’s how I map it in Doom:

(map!
 (:when (featurep! :editor multiple-cursors)
  :prefix "g"
  :nv "z" #'my-mc-hydra/body))

Keeping backups of every edited file

Mon, 31 Jan 2022 15:28:13 +0000

I recently ran rm -rf * in my home directory, which apart from being very foolish, reminded me that I have backups of basically every file I’ve edited:

(setq backup-directory-alist `(("." . "~/.backups"))
      backup-by-copying t
      delete-old-versions t
      kept-new-versions 6
      kept-old-versions 2
      version-control t)

Most of those are self-explanatory, but the long-and-short of it is that I end up with this sort of thing in ~/.backups (for example):

-rw-r--r-- 1 phil phil      593 Nov  7  2020 '!home!phil!.xinitrc.~1~'
-rw-r--r-- 1 phil phil      593 Nov  8  2020 '!home!phil!.xinitrc.~2~'
-rw-r--r-- 1 phil phil      593 Nov  8  2020 '!home!phil!.xinitrc.~3~'
-rw-r--r-- 1 phil phil      593 Nov  8  2020 '!home!phil!.xinitrc.~4~'
-rw-r--r-- 1 phil phil      603 Nov  8  2020 '!home!phil!.xinitrc.~5~'
-rw-r--r-- 1 phil phil      603 Jan  7  2021 '!home!phil!.xinitrc.~6~'
-rw-r--r-- 1 phil phil      785 Oct  6 11:03 '!home!phil!.xinitrc.~7~'

The backups rotate and actually don’t take up much space at all. Just 20Mb for a few years in my case.

Delta for Git and Magit

Thu, 09 Sep 2021 14:58:52 +0100

I was just introduced to a tool called Delta which is a pager you can use with Git to give you Github-esque diffs.

Tiny bit of elisp to configure:

(use-package magit-delta
  :ensure t
  :hook (magit-mode . magit-delta-mode))

Delta itself is incredibly configurable and from the command line has some nice features such as side-by-side diffs.

Save all mu4e attachments

Mon, 30 Aug 2021 20:14:34 +0100

To save all attachments from an mu4e email to a particular directory, you can use this handy snippet for older versions of the client. For more modern mu4e versions, use the elisp by @sj30.

Export an environment variable to Emacs

Mon, 26 Jul 2021 16:04:50 +0100

Handy function to export environment variables to Emacs from the command line:

function export-emacs {
    if [ "$(emacsclient -e t)" != 't' ]; then
        return 1
    fi

    for name in "${@}"; do
        value=$(eval echo \"\${${name}//\\\"/\\\\042}\")
        emacsclient -e "(setenv \"${name}\" \"${value}\")" >/dev/null
    done
}

Use it like this:

export BLAH="Some value"
export-emacs BLAH

And in emacs:

(getenv "BLAH") ; => "Some value"

update: A very kind soul updated the function to handle quoting properly. Thanks, @pcrama!

Using yadm via magit

Sun, 25 Jul 2021 18:22:13 +0100

Yadm’s an amazing dotfile manager that’s basically a thin wrapper around git and a bare repo. With it being a bare repo, you’ll not be able to manage it directly with Magit so here’s a really smart tip I found that will let you access it via Tramp:

(use-package tramp
  :config
  (add-to-list 'tramp-methods
               '("yadm"
                 (tramp-login-program "yadm")
                 (tramp-login-args (("enter")))
                 (tramp-login-env (("SHELL") ("/bin/sh")))
                 (tramp-remote-shell "/bin/sh")
                 (tramp-remote-shell-args ("-c")))))

(defun yadm ()
  (interactive)
  (magit-status "/yadm::"))

Load a random emacs theme on startup

Sun, 11 Jul 2021 21:16:34 +0100

To load a random emacs theme on startup (I restart daily) you can use the following snippet. Just add your theme as a new function to funs. If you don’t restart often, you could add a timer to change themes while you’re going.

My current favourite themes included.

(use-package doom-themes
  :ensure t
  :init (setq doom-themes-enable-bold t
              doom-themes-enable-italic t)
  :config
  ;; list of themes (just called as functions) which also contain
  ;; theme specific config
  (let* ((funs '((lambda () (load-theme 'doom-outrun-electric))
                 (lambda () (load-theme 'doom-palenight))
                 (lambda ()
                   (load-theme 'doom-challenger-deep t)
                   (set-face-attribute 'markdown-code-face nil
                                       :background "#32333d")
                   (set-face-attribute 'font-lock-comment-face nil
                                       :foreground "#999"))
                 (lambda ()
                   (load-theme 'doom-dracula t)
                   (set-face-attribute 'ivy-minibuffer-match-face-1 nil
                                       :foreground "pink"))))
         (rand (random (length funs))))
    (funcall (nth rand funs)))

  ;; any global theme config goes here
  (set-face-attribute 'show-paren-match nil :foreground "#111" :background "orange")
  (doom-themes-org-config))

Start evil substitution on selection

Sun, 11 Jul 2021 11:23:27 +0100

Here’s a little evil operator that will fill in the first part of an evil/ex substitution with the region / visual / object. This allows you to replace objects quickly without having to type out the ex command in full.

If I’ve missed something like this that’s built-in, let me know.

(evil-define-operator start-ex-sub-on-region (beg end)
  (let ((region (buffer-substring beg end)))
    (evil-ex (concat "%s/" (replace-regexp-in-string "\/" "\\\\/"
                                                     (regexp-quote region))
                     "/"))))

I bind this globally to ",s" with:

(evil-global-set-key 'normal (kbd ",s") 'start-ex-sub-on-region)

Search specific extensions with counsel-projectile-rg

Fri, 25 Jun 2021 22:31:02 +0100

If you’re in a monorepo searching through stuff can be a bit chaotic. Here’s a way of narrowing down to specific file extensions with counsel-projectile-rg:

(defun search-specific-glob ()
    (interactive)
    (let ((glob (ivy-completing-read "Glob?: " '("*.cljs"
                                                 "*.clj"
                                                 "*.md"
                                                 "*.styl"
                                                 "*.css"))))
      (counsel-projectile-rg (concat "--glob " glob))))

First it’ll list the extensions with Ivy, then lets you input a search term as normal.

Using the CIDER debugger in Evil

Sun, 06 Jun 2021 17:00:40 +0100

When using evil and CIDER together, you might find that rebinding the keys required to control the debugger is a pain. Luckily, you don’t actually have to, you can just enter insert mode instead:

(defun my-cider-debug-toggle-insert-state ()
  (if cider--debug-mode    ;; Checks if you're entering the debugger
      (evil-insert-state)  ;; If so, turn on evil-insert-state
    (evil-normal-state)))  ;; Otherwise, turn on normal-state

(add-hook 'cider--debug-mode-hook 'my-cider-debug-toggle-insert-state)

Borrowed from here.

Widescreen emacs and vertical splits

Sun, 06 Jun 2021 13:14:51 +0100

On a widescreen monitor, especially the really wide ones, it’s nice to have only vertical splits. This snippet will give bias to vertical splits:

(defun my-split-window-sensibly (&optional window)
  "replacement `split-window-sensibly' function which prefers
vertical splits"
  (interactive)
  (let ((window (or window (selected-window))))
    (or (and (window-splittable-p window t)
             (with-selected-window window
               (split-window-right)))
        (and (window-splittable-p window)
             (with-selected-window window
               (split-window-below))))))

(setq split-window-preferred-function #'my-split-window-sensibly)

Having Smartparens commands work with Evil-mc

Sat, 05 Jun 2021 00:38:51 +0100

As described here, when using evil-mc, it’s very frustrating when a Smartparens command works on only the first of the multiple cursors. Here’s how to fix that:

(dolist (cmd '(sp-up-sexp
               sp-copy-sexp
               sp-down-sexp
               sp-join-sexp
               sp-kill-sexp
               sp-next-sexp
               sp-split-sexp
               sp-wrap-curly
               sp-wrap-round
               sp-raise-sexp
               sp-clone-sexp
               sp-wrap-square
               sp-splice-sexp
               sp-end-of-sexp
               sp-forward-sexp
               sp-backward-sexp
               sp-convolute-sexp
               sp-transpose-sexp
               sp-kill-whole-line
               sp-beginning-of-sexp
               sp-forward-barf-sexp
               sp-forward-slurp-sexp
               sp-backward-barf-sexp
               sp-backward-slurp-sexp
               sp-splice-sexp-killing-forward
               sp-splice-sexp-killing-backward))
    (add-to-list
     'evil-mc-custom-known-commands
     `(,cmd (:default . evil-mc-execute-call))))