Using Djblue's portal for tap in Babashka

Tue, 18 Jul 2023 21:40:23 +0100

It’s often the case one has to deal with a repl-crashing amount of data via Babashka. In clojure I reach for hashp but this time I thought I’d try out Chris Badahdah’s Portal which describes itself as the following: “A clojure tool to navigate through your data”. Amazingly, you can even try it out online!

Here’s how to set it up:

In bb.edn:

{
...
:deps {djblue/portal {:mvn/version "0.42.1"}}
...
}

Then in the REPL:

(do
  (.addShutdownHook (Runtime/getRuntime)
                    (Thread. (fn [] (p/close))))
  (def portal (p/open {:app true}))
  (add-tap #'p/submit))

If you have Chrom(ium?) installed, you should get a new window and from this point, tap> will send data there ready to be explored.

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))

Naming a timer in Babashka

Fri, 06 Jan 2023 17:04:04 +0000

(defmacro named-time
  "Evaluates expr and prints the `nme` and the time it took. Returns the value of
  expr."
  [nme# expr]
  `(let [start# (. System (nanoTime))
         ret# ~expr]
     (prn (str "Elapsed time (" ~nme# ") "
               (/ (double (- (. System (nanoTime)) start#)) 1000000.0)
               " msecs"))
     ret#))

Like the time function that Babashka/Clojure has in core, but accepts a name so that it’s easier to identify stuff in a busy console:

(named-time :plus (+ 1 1)) => 2, prints "Elapsed time (:plus) 0.022612 msecs"

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.

condev - like cond but different

Mon, 26 Jul 2021 16:12:21 +0100

Hopefully the docstring explains this well enough:

(defmacro condev
  "Takes clauses in the same style as `cond` but, if the left side is
  truthy, will execute the right side of the expressions as a function
  which gets the result of evaluation of the left side."
  [& clauses]
  (assert (even? (count clauses)))
  (let [pstep (fn [[test step]] `(when-let [r# ~test] (~step r#)))]
    `(list ~@(map pstep (partition 2 clauses)))))

Usage:

(condev
 (+ 1 4) #(prn (+ 100 %))
 nil     #(prn "won't happen")
 (+ 1 1) #(prn (+ 200 %))

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))