Prefix keys

• Remove C-z
  

  Unbind C-z before anything else, so that I can use it as a prefix key.

  (global-unset-key (kbd "C-z"))
  

• Alias <menu> to C-x
  

  Make the menu key do the same as C-x.

  (bind-key "<menu>" ctl-x-map)
  

Reloading config file

(bind-key "C-z C-r" 'config-load)

Org Mode

(use-package org
  :defer t
  :custom
  (org-src-window-setup 'current-window)
  (org-src-tab-acts-natively t)
  (org-adapt-indentation nil)
  (org-hide-emphasis-markers t)
  (org-file-apps
   '((auto-mode . emacs)
     ("\\.x?html?\\'" . (lambda (file &optional ignore)
                          (eww-open-file file)))))
  :delight
  (org-src-mode " #+src")
  :config
  ;; Quite ugly: (setf (last ...)) doesn't exist, and can't use
  ;; assoc/alist-get because the package name is the cadr
  (setf (nth (1- (length org-latex-default-packages-alist))
             org-latex-default-packages-alist)
        '("hidelinks" "hyperref" nil)
        (car org-latex-default-packages-alist)
        '("utf8x" "inputenc" "pdflatex"))
  (defun org-insert-emacs-help (&optional prompt)
    "Insert a help link to a symbol.
  If the symbol at point is bound, it is replaced by the link.
  Otherwise, or with prefix arg, PROMPT from all bound symbols in
  `obarray'."
    (interactive "*P")
    (when (eq (get-text-property (point) 'face)
              'org-link)
      (user-error "Text at point is already a link--don't want to mangle the buffer"))
    (cl-labels ((predicate (sym)
                           (and (or (boundp sym)
                                    (fboundp sym))
                                (not (keywordp sym))))
                (prompt ()
                        (completing-read
                         "Help link: "
                         obarray
                         #'predicate
                         t)))
      (let ((symbol
             (or (when prompt
                   (prompt))
                 (let ((symbol (symbol-at-point))
                       (bounds (bounds-of-thing-at-point 'symbol)))
                   (when (and symbol
                              (predicate symbol))
                     (delete-region (car bounds) (cdr bounds))
                     symbol))
                 (prompt))))
        (insert (format "[[help:%s][%s]]" symbol symbol)))))
  :bind
  ("C-c M-." . org-time-stamp)
  (:map org-mode-map
        ("C-c C-v h" . org-hide-block-all)
        ("M-h" . mark-paragraph)
        ("C-M-h" . org-mark-element)
        ("C-c h" . org-insert-emacs-help)))

• Insert help link
  

  A function to insert an org-mode help link. This uses the symbol at point if it's a defined variable or function. Otherwise, it prompts from all bound or fbound symbols.

  (defun org-insert-emacs-help (&optional prompt)
    "Insert a help link to a symbol.
  If the symbol at point is bound, it is replaced by the link.
  Otherwise, or with prefix arg, PROMPT from all bound symbols in
  `obarray'."
    (interactive "*P")
    (when (eq (get-text-property (point) 'face)
              'org-link)
      (user-error "Text at point is already a link--don't want to mangle the buffer"))
    (cl-labels ((predicate (sym)
                           (and (or (boundp sym)
                                    (fboundp sym))
                                (not (keywordp sym))))
                (prompt ()
                        (completing-read
                         "Help link: "
                         obarray
                         #'predicate
                         t)))
      (let ((symbol
             (or (when prompt
                   (prompt))
                 (let ((symbol (symbol-at-point))
                       (bounds (bounds-of-thing-at-point 'symbol)))
                   (when (and symbol
                              (predicate symbol))
                     (delete-region (car bounds) (cdr bounds))
                     symbol))
                 (prompt))))
        (insert (format "[[help:%s][%s]]" symbol symbol)))))
  

• Org Indent
  

  I used to use org-indent-mode a while back, but ditched it for reasons I can't remember. I set the indentation level to 1 character instead of its default value of 2. This helps to keep the text within a manageable width and is probably the reason I disabled it.

  I find org-mode looks a bit cleaner and more "open" with this mode enabled. Without it, the window can get cluttered pretty easily.

  (use-package org-indent
    :defer
    :delight
    :config
    (setq org-indent-indentation-per-level 1))
  

• Org capture
  

  Take notes in org-mode with specific templates and write them to a file. Similar to remember.

  (use-package org-capture
    :custom
    (org-default-notes-file "~/org/notes.org")
    (org-capture-templates
     '(("t" "Todo")
       ("tt" "Misc." entry
        (file+headline "todo.org" "Miscellaneous")
        "* TODO %?\n\n%a\n")
       ("tu" "University" entry
        (file+headline "todo.org" "University")
        "* TODO %?\n\n%a\n")
       ("n" "Notes" entry
        (file+headline "notes.org" "Notes")
        "* %?\nEntered on %u\n\n%i\n\n%a\n")
       ("m" "Music" entry
        (file+headline "notes.org" "Music")
        "* %?\nEntered on %u\n\n%i\n")
       ("e" "Elisp" entry
        (file+headline "notes.org" "Emacs Lisp")
        "* %^{Title}\n\n#+begin_src emacs-lisp\n %i\n#+end_src\n")
       ("d" "Diary" entry
        (file "diary.org")
        "* %?\nEntered on %u\n\n")
       ("h" "Haiku" entry
        (file "haiku.org")
        "* %U\n%?\n")))
    (org-capture-bookmark nil)
    :bind
    ("C-x M-r" . org-capture))
  

• Org babel
  

  Work with code blocks. The libraries all provide support for a language so that you can run their source blocks with C-c C-c.

  • LilyPond
    

    Execute LilyPond source blocks. For notes about exporting to pdf, see this org file. Only load it when lilypond is installed.

    (use-package ob-lilypond
      :when (executable-find "lilypond")
      :defer t
      :config
      (defun ob-lilypond-pdf-or-png (backend &rest _args)
        "Replace the lilypond source blocks' :file argument.
      This will turn them all into .png files if BACKEND is html, and
      .pdf files in BACKEND is latex."
        (when (member backend '(latex html))
          (let ((case-fold-search t))
            (save-excursion
              (goto-char (point-min))
              (while (re-search-forward
                      "^\\(#\\+begin_src lilypond .*:file \\)\\(.*\\)\\.[a-z]+"
                      nil :noerror)
                (replace-match (pcase backend
                                 ('latex "\\1\\2.pdf")
                                 ('html "\\1\\2.png")))))
            (save-buffer))))
    
      (advice-add 'org-export-to-file :before #'ob-lilypond-pdf-or-png)
      :commands org-babel-execute:lilypond)
    

    • Replace :file argument in lilypond source blocks
      

      This little bit of hackery to adjust the :file argument for lilypond source blocks.

      • pdf works great with latex export, but doesn't work with html.
      • png works great with html export, but looks fuzzy with latex.

      This advice checks the backend of the export to determine which to use.

      (defun ob-lilypond-pdf-or-png (backend &rest _args)
        "Replace the lilypond source blocks' :file argument.
      This will turn them all into .png files if BACKEND is html, and
      .pdf files in BACKEND is latex."
        (when (member backend '(latex html))
          (let ((case-fold-search t))
            (save-excursion
              (goto-char (point-min))
              (while (re-search-forward
                      "^\\(#\\+begin_src lilypond .*:file \\)\\(.*\\)\\.[a-z]+"
                      nil :noerror)
                (replace-match (pcase backend
                                 ('latex "\\1\\2.pdf")
                                 ('html "\\1\\2.png")))))
            (save-buffer))))
      
      (advice-add 'org-export-to-file :before #'ob-lilypond-pdf-or-png)
      

  • C
    

    Execute C source blocks. TCC is a really fast compiler, so use it instead of gcc if it's installed.

    (use-package ob-C
      :defer t
      :commands org-babel-execute:C
      :custom
      (org-babel-C-compiler
       (or (executable-find "tcc")
           "gcc")))
    

  • Scheme
    

    Execute scheme source blocks. This uses Geiser which is kind of awkward and slow, but evaluating scheme is useful.

    (use-package ob-scheme
      :defer t
      :commands org-babel-execute:scheme)
    

  • Common Lisp
    

    Execute Common Lisp source blocks. This depends on Slime, which doesn't start automatically (see the variable slime-auto-start).

    (use-package ob-lisp
      :defer t
      :commands org-babel-execute:lisp)
    

  • Shell
    

    Execute shell source blocks. Autoload sh, shell, and bash functions.

    (use-package ob-shell
      :defer t
      :commands
      org-babel-execute:sh
      org-babel-execute:shell
      org-babel-execute:bash)
    

• Org links
  

  The library org-mode uses to create and store links. I bind C-x M-l to generate a link from the current position.

  (use-package ol
    :config
    (defun ol-help--export (link description format)
      (let* ((desc (or description link))
             (sym (intern link))
             (type (if (fboundp sym)
                       "Fun"
                     "Var")))
        (when (eq format 'html)
          (format "<a target=\"_blank\" href=\"https://doc.endlessparentheses.com/%s/%s.html\">%s</a>"
                  type link desc))))
  
    (org-link-set-parameters "help" :export #'ol-help--export)
    :bind
    ("C-x M-l" . org-store-link))
  

  • Export help links in html
    

    I often use org's help links (e.g. org-mode) but by default these are useless in an html export. Thankfully, there's a neat site that contains docstrings for all the built-in definitions. Here, I:

    1. define a function that formats an href to the symbol's respective page, and
    2. let org know that I want to use that function whenever a help link is exported

    (defun ol-help--export (link description format)
      (let* ((desc (or description link))
             (sym (intern link))
             (type (if (fboundp sym)
                       "Fun"
                     "Var")))
        (when (eq format 'html)
          (format "<a target=\"_blank\" href=\"https://doc.endlessparentheses.com/%s/%s.html\">%s</a>"
                  type link desc))))
    
    (org-link-set-parameters "help" :export #'ol-help--export)
    

• Org agenda
  

  Use all files in org-directory to get my agenda. And don't disrupt my window configuration.

  (use-package org-agenda
    :defer t
    :custom
    (org-agenda-files '("~/org" "~/org/uni"))
    (org-agenda-window-setup 'current-window)
    :bind
    ("C-z C-a" . org-agenda))
  

• Org publish
  

  I use org-publish for my websites. This block has a lot going on:

  1. I set some default options for publishing projects.
  2. I use a custom function to generate postamble.
  3. Include my three sites in org-publish-project-alist.

  (use-package ox-publish
    :defer t
    :config
    (use-package ox-jamzattack
      :demand
      :straight
      (ox-jamzattack :type git
                     :repo "git@jamzattack.xyz:ox-jamzattack.git"))
    (defun my-org-html-postamble-format (&rest args)
      "Generate an html postamble using ARGS.
    This generates a paragraph for each item in ARGS.  For format
    strings, see the docstring of `org-html-postamble-format'."
      (unless args
        (setq args '("Author: %a <%e>")))
      (list (list "en"
                  (mapconcat (lambda (str)
                               (format (cond
                                        ((string-match-p "%d" str)
                                         "<p class=\"date\">%s</p>")
                                        ((string-match-p "%A" str)
                                         "<p class=\"author\">%s</p>")
                                        (t
                                         "<p>%s</p>"))
                                       str))
                             args
                             "\n"))))
    (defvar my-org-publish-default-options
      '(
        :auto-sitemap t
        :publishing-function org-html-publish-to-html
        :html-metadata-timestamp-format "%Y-%m-%d"
        :with-toc nil
        :with-email t
        :with-drawers nil
        :section-numbers nil
        :with-todo-keywords nil
        )
      "Default options for `org-publish-project-alist'.
  This variable must be spliced into `org-publish-project-alist'
  when set, i.e.
      (setq org-publish-project-alist
              `((\"project\"
                 ,@my-org-publish-default-options)))")
    (setq
     org-html-postamble t ; needed to use custom format
     org-export-headline-levels 6
     org-html-postamble-format
     (my-org-html-postamble-format
      "Author: %A")
     org-publish-timestamp-directory "~/.cache/org/timestamps/"
     org-html-head "<link rel=\"stylesheet\" type=\"text/css\" href=\"/style.css\"/>"
     org-publish-project-alist
     `(("blog"
        ,@my-org-publish-default-options
        :base-directory "~/org/jamzattack.xyz/blog"
        :with-toc t
        :publishing-directory "~/org/jamzattack.xyz/out/blog"
        :html-postamble-format ,(my-org-html-postamble-format
                                 "Author: %A"
                                 "Date: %d (modified %M)"
                                 "Top: <a href=\"/index.html\">The Yeet Log</a>")
        :sitemap-filename "index.org"
        :sitemap-title "The Yeet Log"
        :sitemap-format-entry
        (lambda (entry style project)
          (cond ((not (directory-name-p entry))
                 (format "%s [[file:%s][%s]]"
                         (format-time-string
                          "%Y-%m-%d"
                          (org-publish-find-date entry project))
                         entry
                         (org-publish-find-title entry project)))
                ((eq style 'tree)
                 ;; Return only last subdir.
                 (file-name-nondirectory (directory-file-name entry)))
                (t entry)))
        :sitemap-sort-files anti-chronologically)
       ("gopher"
        :base-directory "~/org/jamzattack.xyz/blog"
        :with-toc t
        :with-email t
        :section-numbers nil
        :publishing-function org-ascii-publish-to-ascii
        :publishing-directory "~/org/jamzattack.xyz/out/gopher")
       ("music"
        ,@my-org-publish-default-options
        :base-directory "~/org/jamzattack.xyz/music"
        :recursive t
        :html-postamble-format ,(my-org-html-postamble-format
                                 "Author: %A"
                                 "Top: <a href=\"/sitemap.html\">All projects</a>")
        :publishing-directory "~/org/jamzattack.xyz/out/music"
        :sitemap-title "My Music Projects")
       ("html"
        ,@my-org-publish-default-options
        :base-directory "~/org/jamzattack.xyz/html"
        :publishing-directory "~/org/jamzattack.xyz/out/html"))))
  

  • Generate postamble
    

    A little function to generate postamble.

    (defun my-org-html-postamble-format (&rest args)
      "Generate an html postamble using ARGS.
    This generates a paragraph for each item in ARGS.  For format
    strings, see the docstring of `org-html-postamble-format'."
      (unless args
        (setq args '("Author: %a <%e>")))
      (list (list "en"
                  (mapconcat (lambda (str)
                               (format (cond
                                        ((string-match-p "%d" str)
                                         "<p class=\"date\">%s</p>")
                                        ((string-match-p "%A" str)
                                         "<p class=\"author\">%s</p>")
                                        (t
                                         "<p>%s</p>"))
                                       str))
                             args
                             "\n"))))
    

  • Default export options
    

    A list of default export options.

    :auto-sitemap t
    :publishing-function org-html-publish-to-html
    :html-metadata-timestamp-format "%Y-%m-%d"
    :with-toc nil
    :with-email t
    :with-drawers nil
    :section-numbers nil
    :with-todo-keywords nil
    

Cc-mode

(use-package cc-mode
  :defer t
  :custom
  (c-default-style '((java-mode . "java")
                     (awk-mode . "awk")
                     (other . "bsd"))))

Emacs Lisp mode

(use-package elisp-mode
  :custom
  (initial-major-mode 'emacs-lisp-mode)
  :delight
  (emacs-lisp-mode ("el" (lexical-binding "/l" "/d")) :major)
  (inferior-emacs-lisp-mode "EL>" :major)
  :bind
  ("<C-M-backspace>" . backward-kill-sexp))

• Find-func
  

  A package that defines a few functions for editing Elisp source code. It provides the function find-function-setup-keys which binds some keys in ctl-x-map, but I prefer to have them under C-h.

  (use-package find-func
    :defer t
    :bind
    (:map help-map
          ("C-l" . find-library)
          ("C-f" . find-function)
          ("C-v" . find-variable)
          ("C-k" . find-function-on-key)))
  

Typesetting

• Nroff-mode
  

  Set a compile-command hook for nroff files. I usually use the ms macros when writing something, but I usually just use org-mode anyway.

  (use-package nroff-mode
    :defer t
    :config
    (defun nroff-mode-compile ()
      "Set the compile command for nroff files.
    It will choose the macro set based on the file extension."
      (let* ((in (buffer-file-name))
             (out (concat (file-name-sans-extension in)
                          ".pdf")))
        (setq-local
         compile-command
         (format "groff -%s -Tpdf '%s' > '%s'"
                 (file-name-extension in) in out))))
    :hook (nroff-mode . nroff-mode-compile))
  

  • Compile Command
    

    (defun nroff-mode-compile ()
      "Set the compile command for nroff files.
    It will choose the macro set based on the file extension."
      (let* ((in (buffer-file-name))
             (out (concat (file-name-sans-extension in)
                          ".pdf")))
        (setq-local
         compile-command
         (format "groff -%s -Tpdf '%s' > '%s'"
                 (file-name-extension in) in out))))
    

• LaTeX
  

  Set a compile-command hook for latex files. I prefer to write in org-mode, but compiling latex on its own is sometimes useful.

  (use-package tex-mode
    :defer t
    :config
    (defun latex-compile-command ()
      "Set the compile command for latex files."
      (setq-local compile-command
                  (format "pdflatex %s" buffer-file-name)))
    :hook (latex-mode . latex-compile-command))
  

  • Compile Command
    

    (defun latex-compile-command ()
      "Set the compile command for latex files."
      (setq-local compile-command
                  (format "pdflatex %s" buffer-file-name)))
    

Compile

(use-package compile
  :bind
  ("C-z C-m" . compile)
  ("<f9>" . recompile)
  :delight
  (compilation-shell-minor-mode " ¢")   ; "C" for compile...
  :hook
  (eshell-mode . compilation-shell-minor-mode)
  (shell-mode . compilation-shell-minor-mode))

Hi-lock

(use-package hi-lock
  :delight
  :bind
  ("C-c ." . highlight-symbol-at-point)
  ("C-x w i" . hi-lock-find-patterns)
  ("C-x w l" . highlight-lines-matching-regexp)
  ("C-x w p" . highlight-phrase)
  ("C-x w h" . highlight-regexp)
  ("C-x w ." . highlight-symbol-at-point)
  ("C-x w r" . unhighlight-regexp)
  ("C-x w b" . hi-lock-write-interactive-patterns))

Parens

(use-package paren
  :config
  (show-paren-mode t))

Auto fill

(use-package simple
  :delight
  (auto-fill-function " ^M"))

Isearch

(use-package isearch
  :delight " ^S")

Eldoc

(use-package eldoc
  :delight
  :defer t
  :custom
  (eldoc-idle-delay 0.1)
  :config
  (eldoc-add-command
   ;; Moving
   'paredit-backward
   'paredit-forward
   'paredit-forward-down
   'paredit-backward-up
   'paredit-backward-down
   'paredit-forward-up
   ;; Editing
   'paredit-raise-sexp
   'paredit-splice-sexp-killing-backward
   'paredit-convolute-sexp
   'paredit-close-round
   'paredit-close-round-and-newline
   'paredit-forward-delete
   'paredit-backward-delete))

EWW

(use-package eww
  :defer t
  :custom
  (eww-bookmarks-directory
   (expand-file-name "eww" user-emacs-directory))
  (eww-browse-url-new-window-is-tab nil)
  :init
  (with-eval-after-load 'browse-url
    (setq browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function 'browse-url-externally-please))
  (defun browse-url-externally-please (url &optional ignored)
    "Open URL using either vimb or surf if they are found,
  otherwise use xdg-open."
    (interactive (browse-url-interactive-arg "URL: "))
    (call-process (or (executable-find "vimb")
                      (executable-find "surf")
                      (executable-find "xdg-open"))
                  nil 0 nil url))
  :config
  (defun eww-edit-current-url (&optional arg)
    "Edit the current URL.
  With prefix ARG, open in a new buffer."
    (interactive "p")
    (let ((url
           (read-string (if (= arg 1)
                            "URL: "
                          "URL (new buffer): ")
                        (eww-current-url))))
      (eww url arg)))
  (defun eww-set-width (width)
    "Set the html rendering width to WIDTH.
  If prefix arg is a number, use it.  Otherwise, read number from
  the minibuffer."
    (interactive (list
                  (if (numberp current-prefix-arg)
                      current-prefix-arg
                    (read-number "Set width: "
                                 (- (window-width) 5)))))
    (setq-local shr-width width)
    (eww-reload t))
  (defun eww-follow-link-with-browse-url (&optional external mouse-event)
    "Browse the URL under point.
  If EXTERNAL is single prefix, browse the URL using
  `browse-url-secondary-browser-function'."
    (interactive (list current-prefix-arg last-nonmenu-event))
    (mouse-set-point mouse-event)
    (let ((url (get-text-property (point) 'shr-url)))
      (cond
       ((not url)
        (message "No link under point"))
       ((and (consp external) (<= (car external) 4))
        (funcall browse-url-secondary-browser-function url)
        (shr--blink-link))
       ;; This is a #target url in the same page as the current one.
       ((and (url-target (url-generic-parse-url url))
             (eww-same-page-p url (plist-get eww-data :url)))
        (let ((dom (plist-get eww-data :dom)))
          (eww-save-history)
          (plist-put eww-data :url url)
          (eww-display-html 'utf-8 url dom nil (current-buffer))))
       (t
        (let ((browse-url-browser-function #'eww-browse-url))
          (browse-url url external))))))

  (advice-add 'eww-follow-link :override #'eww-follow-link-with-browse-url)
  :bind
  ("C-z g" . eww)
  (:map eww-mode-map
        ("M-n" . forward-paragraph)
        ("M-p" . backward-paragraph)
        ("e" . eww-edit-current-url)
        ("V" . variable-pitch-mode)
        ("C-x f" . eww-set-width)
        ;; plumb
        ("f" . plumb-stream)
        ("D" . plumb-download-video)
        ("A" . plumb-audio)
        ;; transmission
        ("m" . transmission-add-url-at-point)
        ;; helm-eww
        ("B" . helm-eww-bookmarks)
        ("H" . helm-eww-history)
        ("s" . helm-eww-buffers)))

• External browser
  

  (defun browse-url-externally-please (url &optional ignored)
    "Open URL using either vimb or surf if they are found,
  otherwise use xdg-open."
    (interactive (browse-url-interactive-arg "URL: "))
    (call-process (or (executable-find "vimb")
                      (executable-find "surf")
                      (executable-find "xdg-open"))
                  nil 0 nil url))
  

• Edit current URL
  

  Useful command to edit the current URL. With prefix arg, open the edited URL in a new buffer. Bound to e in eww-mode.

  (defun eww-edit-current-url (&optional arg)
    "Edit the current URL.
  With prefix ARG, open in a new buffer."
    (interactive "p")
    (let ((url
           (read-string (if (= arg 1)
                            "URL: "
                          "URL (new buffer): ")
                        (eww-current-url))))
      (eww url arg)))
  

• Set eww width
  

  This command sets shr-width to a value read from the minibuffer. Very useful in eww, and a fitting replacement for set-fill-column.

  (defun eww-set-width (width)
    "Set the html rendering width to WIDTH.
  If prefix arg is a number, use it.  Otherwise, read number from
  the minibuffer."
    (interactive (list
                  (if (numberp current-prefix-arg)
                      current-prefix-arg
                    (read-number "Set width: "
                                 (- (window-width) 5)))))
    (setq-local shr-width width)
    (eww-reload t))
  

• Follow links using browse-url
  

  The key RET in eww is bound to eww-follow-link, which bypasses browse-url-handlers meaning you can't open non-http links (except for the one exception, mailto). Here I override this function to use browse-url, and ensure that eww is used where possible. In effect, this means I can open gopher links from eww in elpher.

  (defun eww-follow-link-with-browse-url (&optional external mouse-event)
    "Browse the URL under point.
  If EXTERNAL is single prefix, browse the URL using
  `browse-url-secondary-browser-function'."
    (interactive (list current-prefix-arg last-nonmenu-event))
    (mouse-set-point mouse-event)
    (let ((url (get-text-property (point) 'shr-url)))
      (cond
       ((not url)
        (message "No link under point"))
       ((and (consp external) (<= (car external) 4))
        (funcall browse-url-secondary-browser-function url)
        (shr--blink-link))
       ;; This is a #target url in the same page as the current one.
       ((and (url-target (url-generic-parse-url url))
             (eww-same-page-p url (plist-get eww-data :url)))
        (let ((dom (plist-get eww-data :dom)))
          (eww-save-history)
          (plist-put eww-data :url url)
          (eww-display-html 'utf-8 url dom nil (current-buffer))))
       (t
        (let ((browse-url-browser-function #'eww-browse-url))
          (browse-url url external))))))
  
  (advice-add 'eww-follow-link :override #'eww-follow-link-with-browse-url)
  

SHR

(use-package shr
  :defer t
  :custom
  (shr-width 80)
  :config
  (defun un-duckduckgo-url (args)
    "Cleanse a url from duckduckgo's janky redirect.
  This takes the same args as `shr-urlify', passed as a list."
    (let ((start (nth 0 args))
          (url (nth 1 args))
          (title (nth 2 args)))
      (list start
            (let ((unhexed (url-unhex-string url))
                  (regexp "\\`.*[&\\?]uddg=\\(.*\\)&rut=[a-z0-9]\\{64\\}"))
              (if (string-match regexp unhexed)
                  (match-string 1 unhexed)
                url))
            title)))

  (advice-add 'shr-urlify :filter-args #'un-duckduckgo-url)
  :bind
  (:map shr-map
        ("f" . plumb-stream)
        ("A" . plumb-audio)
        ("D" . plumb-download-video)))

• Remove duckduckgo tracking from url
  

  Duckduckgo does a very sinful thing – instead of linking to https://url.com, it links to:

  https://duckduckgo.com/l/?kh=-1&uddg=https%3A%2F%2Furl.com
  
  

  Here, I define a function that removes all this junk, and use advice to filter the arguments given to shr-urlify. Because this is relatively low-level, all occurences of duckduckgo's redirects that are parsed with shr are replaced with the clean version.

  (defun un-duckduckgo-url (args)
    "Cleanse a url from duckduckgo's janky redirect.
  This takes the same args as `shr-urlify', passed as a list."
    (let ((start (nth 0 args))
          (url (nth 1 args))
          (title (nth 2 args)))
      (list start
            (let ((unhexed (url-unhex-string url))
                  (regexp "\\`.*[&\\?]uddg=\\(.*\\)&rut=[a-z0-9]\\{64\\}"))
              (if (string-match regexp unhexed)
                  (match-string 1 unhexed)
                url))
            title)))
  
  (advice-add 'shr-urlify :filter-args #'un-duckduckgo-url)
  

ERC

(use-package erc
  :defer t
  :custom
  (erc-server "jamzattack.xyz")
  (erc-nick "jamzattack")
  (erc-hide-list '("JOIN" "PART" "QUIT"))
  :config
  (defun znc-detach-channel ()
    "Hook that handles ZNC-specific channel killing behavior"
    (when (erc-server-process-alive)
      (when-let ((tgt (erc-default-target)))
        (erc-server-send (format "DETACH %s" tgt)
                         nil tgt))))

  (advice-add 'erc-kill-channel :override #'znc-detach-channel)
  (defun erc-narrow-to-znc-playback (&optional force)
    "Narrow the buffer beginning at the latest buffer playback.
  If the buffer is already narrowed beyond that point, don't change
  anything.  With prefix arg FORCE, extend the buffer to the
  playback even if it is already narrowed."
    (interactive "P")
    (save-excursion
      (when force
        (widen))
      (narrow-to-region
       (goto-char (point-max))
       (or (re-search-backward
            (rx bol "<***> Buffer Playback..." eol)
            nil :noerror)
           (point-min)))))

  (define-key erc-mode-map (kbd "C-c b") #'erc-narrow-to-znc-playback)
  (add-to-list 'erc-modules 'notifications)
  (erc-update-modules)
  (erc-track-mode))

• Detach instead of parting when buffer is killed
  

  I've just started using ZNC, an IRC bouncer. ERC, however tries to part from a channel when its buffer is killed. Instead, I want to detach so that I can reattach later. Here, I override erc-kill-channel, resulting in the wanted behaviour.

  (defun znc-detach-channel ()
    "Hook that handles ZNC-specific channel killing behavior"
    (when (erc-server-process-alive)
      (when-let ((tgt (erc-default-target)))
        (erc-server-send (format "DETACH %s" tgt)
                         nil tgt))))
  
  (advice-add 'erc-kill-channel :override #'znc-detach-channel)
  

• Narrow to ZNC playback
  

  When reattaching to a channel via ZNC, it plays back some number of recent messages and sends them upon connection. This function narrows to the most recent playback, unless the buffer is already narrowed further.

  I would have liked to use a hook to do this automatically, but due to the asynchronous mechanics of the system I'm gonna have to make do with a keybind.

  (defun erc-narrow-to-znc-playback (&optional force)
    "Narrow the buffer beginning at the latest buffer playback.
  If the buffer is already narrowed beyond that point, don't change
  anything.  With prefix arg FORCE, extend the buffer to the
  playback even if it is already narrowed."
    (interactive "P")
    (save-excursion
      (when force
        (widen))
      (narrow-to-region
       (goto-char (point-max))
       (or (re-search-backward
            (rx bol "<***> Buffer Playback..." eol)
            nil :noerror)
           (point-min)))))
  
  (define-key erc-mode-map (kbd "C-c b") #'erc-narrow-to-znc-playback)
  

• ERC notifications
  

  erc-notify enables notifications for erc conversations. I only enable it if the executable "dunst" is found, because it will crash Emacs unless a notification daemon is active.

  (use-package erc-notify
    :after erc
    :config
    (when (executable-find "dunst")
      (erc-notify-enable)))
  

Info

(use-package info
  :bind
  (:map Info-mode-map
        ("M-p" . backward-paragraph)
        ("M-n" . forward-paragraph)))

Ibuffer

(use-package ibuffer
  :bind
  ("C-x C-b" . ibuffer)
  :init
  (defun ibuffer-helm-major-mode-predicate (buffer)
    "Returns t if BUF is a helm buffer."
    (equal 'helm-major-mode (buffer-local-value 'major-mode buffer)))
  :config
  (add-to-list 'ibuffer-maybe-show-predicates
               #'ibuffer-helm-major-mode-predicate))

Dired

(use-package dired
  :defer t
  :config
  (setq dired-listing-switches "-lahv --group-directories-first")
  :init
  (setq delete-by-moving-to-trash t))

• Dired-x
  

  I load dired-x after dired, to enable some useful commands such as dired-mark-extension and dired-mark-sexp.

  I bind C-x C-d to dired-jump, instead of the useless list-directory.

  (use-package dired-x
    :after dired
    :demand t
    :bind
    ("C-x C-d" . dired-jump))
  

Diffing

• Ediff
  

  By default, Ediff tries to open its own frame. This doesn't work well with EXWM, so I disable that feature.

  (use-package ediff
    :defer t
    :custom
    (ediff-window-setup-function
     #'ediff-setup-windows-plain))
  

• Smerge
  

  Easily merge git conflicts. The prefix is C-c ^ which works fine, but I also bind C-c n and C-c p to go to the next/previous hunk.

  (use-package smerge-mode
    :bind
    (:map smerge-mode-map
          ("C-c n" . smerge-next)
          ("C-c p" . smerge-prev)))
  

Proced

(use-package proced
  :defer t
  :config
  (add-to-list 'display-buffer-alist
               '("\\`\\*Proced\\*\\'" display-buffer-same-window)))

Shell

(use-package shell
  :defer t
  :config
  (add-to-list 'display-buffer-alist
               '("\\`\\*shell\\*\\'" display-buffer-same-window)))

Eshell

(use-package eshell
  :custom
  (eshell-history-size 10000)
  (eshell-banner-message "")
  :init

  :bind
  (:map eshell-mode-map
        ("C-c r" . eshell/r))
  :config
  (require 'esh-mode)
  (defun eshell/e (&rest args)
    "Edit a file from eshell."
    (mapcar 'find-file args))
  (defun eshell/r (&optional name &rest _ignored)
    "Rename the current buffer.
  This will be (in order):
  - [eshell] the first argument
  - [interactive] numeric prefix arg
  - [interactive] read from minibuffer with non-numeric prefix arg
  - the current process
  - the TRAMP user@host
  - the current working directory

  If a buffer of the chosen name already exists, rename it
  uniquely."
    (interactive (list (let ((arg current-prefix-arg))
                         (cond
                          ((numberp arg)
                           arg)
                          (arg
                           (read-string "New name: "))))))
    (setq name
          (if (numberp name)
              ;; If NAME is a number (either from eshell or via prefix
              ;; arg), format it like eshell does.
              (format "<%d>" name)
            ;; Otherwise, add an extra space before.
            (format " %s"
                    (or
                     name
                     (let ((proc (eshell-interactive-process)))
                       (when proc
                         (process-name proc)))
                     (let ((dir (eshell/pwd)))
                       (if (string-match-p tramp-file-name-regexp dir)
                           (replace-regexp-in-string
                            ".*:\\(.*\\):.*" "\\1" dir)
                         (replace-regexp-in-string
                          abbreviated-home-dir "~/" dir)))))))
    (let ((buffer
           (concat eshell-buffer-name name)))
      (rename-buffer buffer (get-buffer buffer))))
  (defun eshell/ssh (&rest args)
    "Use tramp to move into an ssh directory.
  Usage: ssh [USER@]HOST [PATH]"
    (let ((host (car args))
          (path (or (cadr args) "")))
      (eshell/cd (format "/ssh:%s:%s" host path))))
  (defun eshell/img (&rest files)
    "Insert FILES into the buffer as images.
  If a file does not match `image-file-name-regexp', nothing
  happens."
    (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
      (when (string-match-p (image-file-name-regexp) file)
        (goto-char (1- (point)))
        (insert "\n")
        (insert-image (create-image file nil nil
                                    :max-height (* 2 (/ (window-pixel-height) 3))
                                    :max-width (* 2 (/ (window-pixel-width) 3))))))
    (goto-char (point-max))
    nil)

  (defun eshell/shr (&rest files)
    "Insert FILES into the buffer as rendered HTML."
    (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
      (when (string-match-p "\\.html\\'" file)
        (goto-char (1- (point)))
        (shr-insert-document
         (with-temp-buffer
           (insert-file-contents file)
           (libxml-parse-html-region (point-min) (point-max))))))
    (goto-char (point-max))
    nil)

  (defun eshell/fontify (&rest files)
    "Insert FILES into the buffer.
  Like `eshell/cat', but fontifies the text as it would be if it
  were visited normally."
    (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
      (goto-char (1- (point)))
      (insert "\n")
      (insert
       (with-temp-buffer
         (insert-file-contents file)
         (setq buffer-file-name file)
         (normal-mode)
         (font-lock-ensure)
         (delete-region (1- (point-max)) (point-max))
         (set-buffer-modified-p nil)
         (buffer-string)))
      (goto-char (point-max)))
    nil)

  (defun eshell/c (&rest files)
    "My overpowered version of `eshell/cat'.
  This command show FILES as:
  - images (`eshell/img')
  - directories (`eshell/ls')
  - rendered html (`eshell/shr')
  - fontified source code (`eshell/fontify')"
    (dolist (file (mapcar (lambda (file)
                            (let ((expanded (expand-file-name file)))
                              (when (file-exists-p file)
                                expanded)))
                          (flatten-tree files)))
      (cond ((string-match-p (image-file-name-regexp) file)
             (eshell/img file))
            ((file-directory-p file)
             (eshell/ls "-lah" file))
            ((string-match-p "\\.html\\'" file)
             (eshell/shr file))
            (t
             (eshell/fontify file)))))
  (defun eshell/h (symbol-name &rest _ignored)
    "Show help for SYMBOL-NAME.
  If `helpful-symbol' is available, use it.  Otherwise, fall back
  to `describe-symbol'."
    (let ((function (if (fboundp 'helpful-symbol)
                        #'helpful-symbol
                      #'describe-symbol)))
      (funcall function (intern symbol-name))))
  (defun eshell/su (&rest args)
    (let ((user (or (car args) "root")))
      (eshell/cd
       (if (string-prefix-p "/ssh:" default-directory)
           (format (replace-regexp-in-string
                    "/ssh:\\(.*@\\)?:?+\\(.*\\):.*" ;regex
                    "/ssh:\\1\\2|sudo:%s@\\2:"    ;replacement
                    default-directory)            ;string
                   user)
         (format "/sudo:%s@localhost:" user)))))
  (defun eshell/comint (&rest args)
    "Start a comint session running ARGS"
    (let ((string (eshell-flatten-and-stringify args))
          (program (executable-find (car args)))
          (program-args (eshell-flatten-and-stringify (cdr args))))
      (switch-to-buffer
       (make-comint string
                    (or program
                        (user-error "Executable %s not found" (car args)))
                    nil
                    program-args)))))

• Eshell functions
  
  • Edit a file
    

    Instead of opening a file with emacsclient, just edit it directly.

    (defun eshell/e (&rest args)
      "Edit a file from eshell."
      (mapcar 'find-file args))
    

  • Comint
    

    A wrapper to start a comint process from eshell.

    Used like so:

    comint ed ~/.bashrc
    

    (defun eshell/comint (&rest args)
      "Start a comint session running ARGS"
      (let ((string (eshell-flatten-and-stringify args))
            (program (executable-find (car args)))
            (program-args (eshell-flatten-and-stringify (cdr args))))
        (switch-to-buffer
         (make-comint string
                      (or program
                          (user-error "Executable %s not found" (car args)))
                      nil
                      program-args))))
    

  • ssh via tramp
    

    A simple ssh wrapper that uses tramp. ssh user@host will always be run as the current user via local ssh.

    (defun eshell/ssh (&rest args)
      "Use tramp to move into an ssh directory.
    Usage: ssh [USER@]HOST [PATH]"
      (let ((host (car args))
            (path (or (cadr args) "")))
        (eshell/cd (format "/ssh:%s:%s" host path))))
    

  • su via tramp
    

    A simple sudo wrapper that uses tramp. Works from remote hosts as well.

    (defun eshell/su (&rest args)
      (let ((user (or (car args) "root")))
        (eshell/cd
         (if (string-prefix-p "/ssh:" default-directory)
             (format (replace-regexp-in-string
                      "/ssh:\\(.*@\\)?:?+\\(.*\\):.*" ;regex
                      "/ssh:\\1\\2|sudo:%s@\\2:"      ;replacement
                      default-directory)              ;string
                     user)
           (format "/sudo:%s@localhost:" user)))))
    

  • Describe symbol
    

    A wee eshell interface to helpful-symbol. Falls back to describe-symbol if the above isn't available somehow.

    (defun eshell/h (symbol-name &rest _ignored)
      "Show help for SYMBOL-NAME.
    If `helpful-symbol' is available, use it.  Otherwise, fall back
    to `describe-symbol'."
      (let ((function (if (fboundp 'helpful-symbol)
                          #'helpful-symbol
                        #'describe-symbol)))
        (funcall function (intern symbol-name))))
    

  • Rename eshell buffer
    

    Rename the current eshell. Bound to C-c r, but can also be used from eshell with or without an argument.

    r "my buffer's new name"
    

    With an argument, the buffer will be renamed that argument. This is achieved interactively with a prefix argument.

    Otherwise, it will be named according to:

    • The current process
    • TRAMP user@host
    • The current working directory

    (defun eshell/r (&optional name &rest _ignored)
      "Rename the current buffer.
    This will be (in order):
    - [eshell] the first argument
    - [interactive] numeric prefix arg
    - [interactive] read from minibuffer with non-numeric prefix arg
    - the current process
    - the TRAMP user@host
    - the current working directory
    
    If a buffer of the chosen name already exists, rename it
    uniquely."
      (interactive (list (let ((arg current-prefix-arg))
                           (cond
                            ((numberp arg)
                             arg)
                            (arg
                             (read-string "New name: "))))))
      (setq name
            (if (numberp name)
                ;; If NAME is a number (either from eshell or via prefix
                ;; arg), format it like eshell does.
                (format "<%d>" name)
              ;; Otherwise, add an extra space before.
              (format " %s"
                      (or
                       name
                       (let ((proc (eshell-interactive-process)))
                         (when proc
                           (process-name proc)))
                       (let ((dir (eshell/pwd)))
                         (if (string-match-p tramp-file-name-regexp dir)
                             (replace-regexp-in-string
                              ".*:\\(.*\\):.*" "\\1" dir)
                           (replace-regexp-in-string
                            abbreviated-home-dir "~/" dir)))))))
      (let ((buffer
             (concat eshell-buffer-name name)))
        (rename-buffer buffer (get-buffer buffer))))
    

  • eshell/c
    

    eshell/c is a super beefy function that supersedes eshell/cat. It uses the GUI to its advantage to show:

    • images
    • directories
    • rendered html
    • fontified source code

    (defun eshell/img (&rest files)
      "Insert FILES into the buffer as images.
    If a file does not match `image-file-name-regexp', nothing
    happens."
      (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
        (when (string-match-p (image-file-name-regexp) file)
          (goto-char (1- (point)))
          (insert "\n")
          (insert-image (create-image file nil nil
                                      :max-height (* 2 (/ (window-pixel-height) 3))
                                      :max-width (* 2 (/ (window-pixel-width) 3))))))
      (goto-char (point-max))
      nil)
    
    (defun eshell/shr (&rest files)
      "Insert FILES into the buffer as rendered HTML."
      (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
        (when (string-match-p "\\.html\\'" file)
          (goto-char (1- (point)))
          (shr-insert-document
           (with-temp-buffer
             (insert-file-contents file)
             (libxml-parse-html-region (point-min) (point-max))))))
      (goto-char (point-max))
      nil)
    
    (defun eshell/fontify (&rest files)
      "Insert FILES into the buffer.
    Like `eshell/cat', but fontifies the text as it would be if it
    were visited normally."
      (dolist (file (mapcar #'expand-file-name (flatten-tree files)))
        (goto-char (1- (point)))
        (insert "\n")
        (insert
         (with-temp-buffer
           (insert-file-contents file)
           (setq buffer-file-name file)
           (normal-mode)
           (font-lock-ensure)
           (delete-region (1- (point-max)) (point-max))
           (set-buffer-modified-p nil)
           (buffer-string)))
        (goto-char (point-max)))
      nil)
    
    (defun eshell/c (&rest files)
      "My overpowered version of `eshell/cat'.
    This command show FILES as:
    - images (`eshell/img')
    - directories (`eshell/ls')
    - rendered html (`eshell/shr')
    - fontified source code (`eshell/fontify')"
      (dolist (file (mapcar (lambda (file)
                              (let ((expanded (expand-file-name file)))
                                (when (file-exists-p file)
                                  expanded)))
                            (flatten-tree files)))
        (cond ((string-match-p (image-file-name-regexp) file)
               (eshell/img file))
              ((file-directory-p file)
               (eshell/ls "-lah" file))
              ((string-match-p "\\.html\\'" file)
               (eshell/shr file))
              (t
               (eshell/fontify file)))))
    

IELM

(use-package ielm
  :defer t
  :config
  (define-key ielm-map (kbd "C-c C-z") #'quit-window))

Recentf

(use-package recentf
  :config (recentf-load-list))

Desktop

(use-package desktop
  :custom
  (desktop-restore-frames nil)
  (history-delete-duplicates t)
  (desktop-save-mode t)
  :config
  (add-to-list 'desktop-globals-to-save 'helm-ff-history)
  (add-to-list 'desktop-globals-to-save 'extended-command-history))

Save Place

(use-package saveplace
  :config
  (save-place-mode t))

Winner-mode

(use-package winner
  :config
  (winner-mode))

Extraneous bars

• Scroll bar
  

  Disable the scroll bar using customize, but set the width in case I decide to turn it on.

  (use-package scroll-bar
    :custom
    (scroll-bar-mode nil)
    (scroll-bar-width 6 t))
  

• Menu bar
  

  Disable the menu bar.

  (use-package menu-bar
    :config
    (menu-bar-mode -1))
  

• Tool bar
  

  Disable the tool bar.

  (use-package tool-bar
    :config
    (tool-bar-mode -1))
  

Mode-line

• Time
  

  Display the current time in the mode-line, and make it use 24-hour time. I adjust the time format for the world-clock so it displays the offset from UTC/GMT, and change the list of timezones.

  (use-package time
    :custom
    (display-time-24hr-format t)
    (world-clock-time-format "%A\t%d %B %R %Z\t(%z)")
    (world-clock-list
     '(("America/Los_Angeles" "Western US")
       ("America/Chicago" "Central US")
       ("America/New_York" "Eastern US")
       ("Europe/London" "UK")
       ("Europe/Paris" "Central Europe")
       ("Asia/Calcutta" "India")
       ("Asia/Chongqing" "China")
       ("Asia/Seoul" "Korea/Japan")
       ("Australia/Canberra" "Canberra")
       ("Pacific/Auckland" "New Zealand")))
    :config
    (display-time-mode t))
  

• Battery
  

  Show battery information with C-z b. Configuration for showing battery status in the mode-line is in a separate heading.

  (use-package battery
    :config
    (setq battery-mode-line-format " [%b%p%%]")
  
    (defun set-display-battery-mode-accordingly ()
      "Enable `display-battery-mode' if battery is being used.
    If connected to power, or no battery is detected, disable it."
      (if (and battery-status-function
               (or (rassoc "discharging" (funcall battery-status-function))
                   (rassoc "Discharging" (funcall battery-status-function))))
          (display-battery-mode t)
        (display-battery-mode 0)))
  
    (advice-add 'battery :after #'set-display-battery-mode-accordingly)
    :bind
    ("C-z b" . battery)
    ("<XF86Battery>" . battery))
  

  • Battery info in mode-line
    

    Every time battery is called (with C-z b), check if display-battery-mode should be turned on or off.

    I also adjust battery-mode-line-format to add an extra space between the battery and time. By default, these push up against each other which I do not like.

    (setq battery-mode-line-format " [%b%p%%]")
    
    (defun set-display-battery-mode-accordingly ()
      "Enable `display-battery-mode' if battery is being used.
    If connected to power, or no battery is detected, disable it."
      (if (and battery-status-function
               (or (rassoc "discharging" (funcall battery-status-function))
                   (rassoc "Discharging" (funcall battery-status-function))))
          (display-battery-mode t)
        (display-battery-mode 0)))
    
    (advice-add 'battery :after #'set-display-battery-mode-accordingly)
    

• Show the column
  

  Show the current column in the mode-line. This is provided by the simple package.

  (use-package simple
    :config
    (column-number-mode t))
  

Indicate empty lines

(defun indicate-empty-lines-mode (&optional arg)
  "Indicate empty lines in the fringe.
This is not actually a minor mode, just a wrapper function to set
the variable `indicate-empty-lines'.

If called interactively, enable indicaty-empty-lines-mode if ARG
is positive, and disable it if ARG is zero or negative.  If
called from Lisp, also enable the mode if ARG is omitted or nil,
and toggle it if ARG is toggle; disable the mode otherwise."
  (interactive (list (or current-prefix-arg 'toggle)))
  (setq indicate-empty-lines
        (cond ((eq arg 'toggle)
               (not indicate-empty-lines))
              ((numberp arg)
               (< 1 arg))
              (t t))))

(add-hook 'text-mode-hook #'indicate-empty-lines-mode)
(add-hook 'prog-mode-hook #'indicate-empty-lines-mode)

Keybindings

• Line wrapping
  

  Simple keybinding to wrap/unwrap lines. This feature is also provided by simple.

  (use-package simple
    :bind
    ("C-c t" . toggle-truncate-lines))
  

• Line numbers
  

  Display line numbers. I prefer to just use the mode-line because it doesn't slow down Emacs as much.

  (use-package display-line-numbers
    :bind
    ("C-c l" . display-line-numbers-mode))
  

• Cycle spacing
  

  By default, M-SPC is bound to the less powerful just-one-space. I rebind that key to cycle-spacing, which does the same thing but on successive invocations switches between one space and no spaces. Thus, M-SPC M-SPC acts like M-\ (delete-horizontal-space)

  (use-package simple
    :bind
    ("M-SPC" . cycle-spacing))
  

Minibuffer

(use-package mb-depth
  :config
  (setq enable-recursive-minibuffers t)
  (minibuffer-depth-indicate-mode))

Window

(use-package window
  :no-require
  :demand
  :bind
  ("C-z C-z" . bury-buffer)
  ("s-z" . bury-buffer)
  ("C-x _" . shrink-window)
  ("<s-backspace>" . quit-window)
  ("s-s" . next-buffer)
  ("s-d" . previous-buffer)
  :config
  (defun skip-boring-buffer-please (_window buffer _bury-or-kill)
    "Return non-nil if BUFFER is boring.
A buffer is \"boring\" if one of the following is true:
- it is in `helm-major-mode', `helpful-mode', or `help-mode'
- it is empty
- it is _not_ in `exwm-mode'"
    (or (member (buffer-local-value 'major-mode buffer)
                '(helm-major-mode
                  helpful-mode
                  help-mode))
        (unless
            (equal (buffer-local-value 'major-mode buffer)
                   'exwm-mode)
          (with-current-buffer buffer
            (= (point-min) (point-max))))))
  (setq switch-to-prev-buffer-skip
        #'skip-boring-buffer-please))

Windmove

(use-package windmove
  :defer t
  :bind
  ("s-c" . windmove-up)
  ("s-h" . windmove-left)
  ("s-t" . windmove-down)
  ("s-n" . windmove-right)
  ("s-C" . windmove-swap-states-up)
  ("s-H" . windmove-swap-states-left)
  ("s-T" . windmove-swap-states-down)
  ("s-N" . windmove-swap-states-right))

Tab-bar

(use-package tab-bar
  :defer t
  :custom
  (tab-bar-show nil)
  (tab-bar-close-button-show nil)
  (tab-bar-new-button-show nil)
  (tab-bar-tab-hints t)
  :bind
  ("s-g" . tab-previous)
  ("s-r" . tab-next)
  ("s-w" . tab-bar-switch-to-tab)
  :config
  (dolist (k (number-sequence 0 9))
    (bind-key (kbd (format "s-%s" k)) 'tab-bar-select-tab))
  (defadvice tab-bar-select-tab
      (after show-tab-name activate)
    "Show the tab name and index+1 in the echo area."
    (message "Switched to tab: %s (%s)"
             (propertize
              (cdr (assoc 'name (tab-bar--tab)))
              'face 'error)
             (1+ (tab-bar--current-tab-index)))))

Swap yes/no prompt with y/n

(defalias 'yes-or-no-p 'y-or-n-p)
(bind-key "RET" 'y-or-n-p-insert-y y-or-n-p-map)

Enable all the features

(use-package novice
  :custom
  (disabled-command-function nil))

Disable audible and visual bell

(use-package custom
  :custom
  (ring-bell-function 'ignore))

Hippie expand

(use-package hippie-exp
  :defer t
  :bind
  ("M-/" . hippie-expand))

Paragraphs

(use-package emacs
  :bind
  ("M-n" . forward-paragraph)
  ("M-p" . backward-paragraph))

Project

(use-package project
  :defer t
  :config
  (add-to-list 'display-buffer-alist
               '("-eshell\\*\\'" display-buffer-same-window)))

Gnus

(use-package gnus
  :init
  (setq mail-user-agent 'gnus-user-agent)
  :config
  (setq gnus-select-method
        '(nntp "news.gwene.org"))
  (setq gnus-secondary-select-methods
        '((nnimap "gmail"
                  (nnimap-address "imap.gmail.com"))
          (nnimap "university"
                  (nnimap-address "outlook.office365.com"))
          (nnimap "mail.jamzattack.xyz")
          (nntp "news.eternal-september.org"
                (nntp-authinfo-file "~/.authinfo.gpg"))))
  (defun gnus-group-set-up-imenu-please ()
    (setq imenu-generic-expression
          '(("Topic" "\\[ \\(.*?\\) -- [0-9]+ \\]" 1)
            ("Unread" "[1-9]+.*: \\(.*\\)" 1))))
  (add-hook 'gnus-group-mode-hook 'gnus-group-set-up-imenu-please)
  (with-eval-after-load 'gnus-win
    (setq gnus-use-full-window nil))
  :bind
  ("C-z C-n" . gnus-unplugged)
  ("C-z n" . gnus-plugged))

• Gnus-sum
  

  Nicer summary & thread formatting. Credit to Protesilaos Stavrou

  (use-package gnus-sum
    :defer t
    :custom
    (gnus-summary-line-format "%U%R%z %-16,16&user-date;  %4L:%-30,30f  %B%s\n")
    (gnus-summary-mode-line-format "%p")
    (gnus-sum-thread-tree-false-root "─┬> ")
    (gnus-sum-thread-tree-indent " ")
    (gnus-sum-thread-tree-leaf-with-other "├─> ")
    (gnus-sum-thread-tree-root "")
    (gnus-sum-thread-tree-single-leaf "└─> ")
    (gnus-sum-thread-tree-vertical "│")
    (gnus-ignored-from-addresses
     (mapcar #'regexp-quote
             '("jdb@jamzattack.xyz"
               "beardsleejamie@gmail.com"
               "beardsjami@myvuw.ac.nz"))))
  

• Gnus-msg
  

  Gnus' library for sending messages. gnus-posting-styles allows you to adjust headers, signatures, etc. based on how you got to the composition buffer. All messages composed from my university mailbox will be sent from my university address. Very nice!

  Posting Styles in the gnus manual

  (use-package gnus-msg
    :defer t
    :custom
    (gnus-posting-styles
     `(("nnimap\\+university:.*"
        (From ,(format "%s <%s@%s>" user-full-name "beardsjami" "myvuw.ac.nz"))
        (signature "Jamie Beardslee (300484191)"))
       ("nnimap\\+gmail:.*"
        (From ,(format "%s <%s@%s>" user-full-name "beardsleejamie" "gmail.com")))
       ("nnimap\\+mail\\.jamzattack\\.xyz:.*"
        (From ,(format "%s <%s@%s>" user-full-name "jdb" "jamzattack.xyz"))))))
  

• Gnus-art
  

  Article stuff. Gnus tries to use the smiley library to convert emoticons into images – I turned it off because it looks terrible.

  I also want some buttons to show signature status and alternative MIME types, which is achieved with gnus-buttonized-mime-types.

  (use-package gnus-art
    :defer t
    :custom
    (gnus-treat-display-smileys nil)
    (gnus-buttonized-mime-types
     '("multipart/signed" "multipart/alternative")))
  

• Gnus-topic
  

  Gnus can sort your groups by topic, which I enable in gnus-group-mode-hook.

  It shows titles for empty topics by default, which I find to get in the way. I set the variable gnus-topic-display-empty-topics to disable this. Default behaviour can be restored with T H.

  (use-package gnus-topic
    :defer t
    :custom
    (gnus-topic-display-empty-topics nil)
    :hook
    (gnus-group-mode . gnus-topic-mode))
  

• Gnus-start
  

  Just getting rid of a couple of extra files in $HOME.

  • Gnus by default creates ~/.newsrc in a format compatible with other newsreaders, but I don't use any so it's just an extra line in my ls.
  • Move the dribble (i.e. auto-save) files to ~/.cache.

  (use-package gnus-start
    :defer t
    :custom
    (gnus-save-newsrc-file nil)
    (gnus-dribble-directory "~/.cache/"))
  

Sendmail

(use-package sendmail
  :defer t
  :config
  (setq send-mail-function 'sendmail-send-it
        sendmail-program (or (executable-find "msmtp")
                             sendmail-program)
        mail-envelope-from 'header))

Message

(use-package message
  :config
  (defun fill-message-please (&optional unfill)
    "Fill the whole message.
  With prefix arg UNFILL, unfill the message (i.e. paragraphs will
  all be on one line)"
    (interactive "P")
    (let ((fill-column (if unfill
                           (point-max)
                         fill-column)))
      (message-fill-yanked-message)))
  (defun my-gnus-add-gcc-header ()
    "If message is from anybody@jamzattack.xyz, archive it via IMAP.
  This will also archive it in the default nnfolder+archive group."
    (interactive)
    (let ((new-gcc
           (format-time-string
            "nnfolder+archive:sent.%Y-%m,nnimap+mail.jamzattack.xyz:Sent")))
      (save-excursion
        (goto-char (point-min))
        (ignore-errors
          (when (re-search-forward "^From: \\(.*\\)jamzattack.xyz>?")
            (message-replace-header "Gcc" new-gcc))))))
  :hook
  (message-send . my-gnus-add-gcc-header)
  :bind
  (:map message-mode-map
        ("C-c C-q" . fill-message-please)
        ("C-c $" . ispell-message)))

• Archive mail from jamzattack.xyz
  

  I can't figure out how to make my postfix server copy messages to "Sent", so I do it with gnus.

  (defun my-gnus-add-gcc-header ()
    "If message is from anybody@jamzattack.xyz, archive it via IMAP.
  This will also archive it in the default nnfolder+archive group."
    (interactive)
    (let ((new-gcc
           (format-time-string
            "nnfolder+archive:sent.%Y-%m,nnimap+mail.jamzattack.xyz:Sent")))
      (save-excursion
        (goto-char (point-min))
        (ignore-errors
          (when (re-search-forward "^From: \\(.*\\)jamzattack.xyz>?")
            (message-replace-header "Gcc" new-gcc))))))
  

MIME

• mm-decode
  

  The library responsible for decoding mime parts. I prefer reading text/plain, so discourage the other common alternatives. I also want to verify messages that have a signature, so I set mm-verify-option.

  (use-package mm-decode
    :defer t
    :custom
    (mm-discouraged-alternatives
     '("text/html" "text/richtext"))
    (mm-verify-option 'known))
  

• mml-sec
  

  Yay for encryption. I set up messages to encrypt to myself as well as the recipient, and sign with the sender.

  (use-package mml-sec
    :defer t
    :custom
    (mml-secure-openpgp-encrypt-to-self t)
    (mml-secure-openpgp-sign-with-sender t))
  

Input methods

(use-package quail
  :defer t
  :config
  (push
   (cons "dvorak"
         (concat
          "                              "
          "`~1!2@3#4$5%6^7&8*9(0)[{]}    "   ; numbers
          "  '\",<.>pPyYfFgGcCrRlL/?=+\\|  " ; qwerty
          "  aAoOeEuUiIdDhHtTnNsS-_      "   ; asdf
          "  ;:qQjJkKxXbBmMwWvVzZ        "   ; zxcv
          "                              "))
   quail-keyboard-layout-alist)

  (defun toggle-quail-keyboard-layout ()
    "Toggle the keyboard layout between dvorak and qwerty.
  This sets `quail-keyboard-layout-type' to the opposite of what is
  currently selected."
    (interactive)
    (if (string-equal quail-keyboard-layout-type "dvorak")
        (quail-set-keyboard-layout "standard")
      (quail-set-keyboard-layout "dvorak"))
    (message "Switched to layout: %s"
             (propertize quail-keyboard-layout-type
                         'face 'bold)))

  (bind-key "s-\\" 'toggle-quail-keyboard-layout)
  (use-package maori-input-method
    :straight
    (maori-input-method
     :type git
     :repo "git@jamzattack.xyz:maori-input-method"))
  (use-package shavian-input-method
    :straight
    (shavian-input-method
     :type git
     :repo "git@jamzattack.xyz:shavian-input-method"))
  (with-eval-after-load "quail/hangul"
    (defun hangul2-input-method (key)
      "2-Bulsik input method."
      (setq key (quail-keyboard-translate key))
      (if (or buffer-read-only (not (alphabetp key)))
          (list key)
        (quail-setup-overlays nil)
        (let ((input-method-function nil)
              (echo-keystrokes 0)
              (help-char nil))
          (setq hangul-queue (make-vector 6 0))
          (hangul2-input-method-internal key)
          (unwind-protect
              (catch 'exit-input-loop
                (while t
                  (let* ((seq (read-key-sequence nil))
                         (cmd (lookup-key hangul-im-keymap seq))
                         key)
                    (cond
                     ((and (stringp seq)
                           (= 1 (length seq))
                           (setq key (quail-keyboard-translate (aref seq 0)))
                           (alphabetp key))
                      (hangul2-input-method-internal key))
                     ((commandp cmd)
                      (call-interactively cmd))
                     (t
                      (setq unread-command-events
                            (nconc (listify-key-sequence seq)
                                   unread-command-events))
                      (throw 'exit-input-loop nil))))))
            (quail-delete-overlays))))))
  )

• Dvorak keyboard layout
  

  Define a dvorak keyboard layout and enable it.

  Quail keyboard layouts are laid out in six 30-column blocks. The first and last are above and below the alphanumeric keys. Each key is represented by a pair of its non-shifted and shifted variants i.e. aA for the a key.

  This allows me to use another input method's physical layout rather than just the keys themselves.

  In the korean-hangul input method though, characters' positions are laid out according to the physical position, so I want that to be taken into account. In other words, I want to use the "qwerty k" rather than the "dvorak k".

  Qwerty	Dvorak	Hangul
  k	t	ㅏ
  r	p	ㄱ

  Unfortunately, whether a keyboard layout actually uses this system is totally random. See the examples in the following table, where a "layout dependent" input method means that it uses the keyboard translation according to quail-keyboard-layout.

  Layout	Layout dependent?	Should be?
  cyrillic-translit	t	nil
  programmer-dvorak	nil	t
  korean-hangul	nil	t
  japanese	nil	nil

  Because of this mess, I also define the function toggle-quail-keyboard-layout, which switches between the two and is bound to s-\.

  (push
   (cons "dvorak"
         (concat
          "                              "
          "`~1!2@3#4$5%6^7&8*9(0)[{]}    "   ; numbers
          "  '\",<.>pPyYfFgGcCrRlL/?=+\\|  " ; qwerty
          "  aAoOeEuUiIdDhHtTnNsS-_      "   ; asdf
          "  ;:qQjJkKxXbBmMwWvVzZ        "   ; zxcv
          "                              "))
   quail-keyboard-layout-alist)
  
  (defun toggle-quail-keyboard-layout ()
    "Toggle the keyboard layout between dvorak and qwerty.
  This sets `quail-keyboard-layout-type' to the opposite of what is
  currently selected."
    (interactive)
    (if (string-equal quail-keyboard-layout-type "dvorak")
        (quail-set-keyboard-layout "standard")
      (quail-set-keyboard-layout "dvorak"))
    (message "Switched to layout: %s"
             (propertize quail-keyboard-layout-type
                         'face 'bold)))
  
  (bind-key "s-\\" 'toggle-quail-keyboard-layout)
  

• Māori
  

  My own input method for Māori. It provides prefix and postfix variants.

  • Postfix:

  aa	ā
  a-	ā
  aaa	aa
  a--	a-

  • Prefix:

  aa	ā
  -a	ā
  aaa	aa
  –a	-a

  Hosted here.

  (use-package maori-input-method
    :straight
    (maori-input-method
     :type git
     :repo "git@jamzattack.xyz:maori-input-method"))
  

• Shavian
  

  My own input method for Shavian.

  Hosted here.

  (use-package shavian-input-method
    :straight
    (shavian-input-method
     :type git
     :repo "git@jamzattack.xyz:shavian-input-method"))
  

• Hangul
  

  An adjustment to the hangul input method that uses quail-keyboard-translate to determine the character, rather than assuming the standard layout.

  For more information, see this section and my blog post about the subject.

  (with-eval-after-load "quail/hangul"
    (defun hangul2-input-method (key)
      "2-Bulsik input method."
      (setq key (quail-keyboard-translate key))
      (if (or buffer-read-only (not (alphabetp key)))
          (list key)
        (quail-setup-overlays nil)
        (let ((input-method-function nil)
              (echo-keystrokes 0)
              (help-char nil))
          (setq hangul-queue (make-vector 6 0))
          (hangul2-input-method-internal key)
          (unwind-protect
              (catch 'exit-input-loop
                (while t
                  (let* ((seq (read-key-sequence nil))
                         (cmd (lookup-key hangul-im-keymap seq))
                         key)
                    (cond
                     ((and (stringp seq)
                           (= 1 (length seq))
                           (setq key (quail-keyboard-translate (aref seq 0)))
                           (alphabetp key))
                      (hangul2-input-method-internal key))
                     ((commandp cmd)
                      (call-interactively cmd))
                     (t
                      (setq unread-command-events
                            (nconc (listify-key-sequence seq)
                                   unread-command-events))
                      (throw 'exit-input-loop nil))))))
            (quail-delete-overlays))))))
  

• Fixing various input methods
  

  As said above, some input methods don't work the way they should with a custom quail-keyboard-layout.

  The variable quail-package-alist is an alist of the following values:

  Index	Description
  0	NAME
  1	TITLE
  2	QUAIL-MAP
  3	GUIDANCE
  4	DOCSTRING
  5	TRANSLATION-KEYS
  6	FORGET-LAST-SELECTION
  7	DETERMINISTIC
  8	KBD-TRANSLATE
  9	SHOW-LAYOUT
  10	DECODE-MAP
  11	MAXIMUM-SHORTEST
  12	OVERLAY-PLIST
  13	UPDATE-TRANSLATION-FUNCTION
  14	CONVERSION-KEYS
  15	SIMPLE

  The elements I'm mostly interested in are 8 (KBD-TRANSLATE) and 9 (SHOW-LAYOUT).

  (with-eval-after-load "quail/cyrillic"  ; no kbd-translate
    (setf (nth 8 (assoc "cyrillic-translit" quail-package-alist)) nil
          (nth 9 (assoc "cyrillic-translit" quail-package-alist)) t))
  
  (with-eval-after-load "quail/programmer-dvorak" ; kbd-translate
    (setf (nth 8 (assoc "programmer-dvorak" quail-package-alist)) t
          (nth 9 (assoc "programmer-dvorak" quail-package-alist)) t))
  

Abbrevs

(use-package abbrev
  :defer t
  :delight
  :config
  (setq save-abbrevs nil)
  (use-package text-mode-abbrevs
    :load-path "lisp/abbrev")
  )

• My text-mode abbrevs
  

  (use-package text-mode-abbrevs
    :load-path "lisp/abbrev")
  

Printing functions

(autoload 'ps-print-preprint "ps-print")

(defun please-print-buffer (&optional file color header side-by-side)
  "Print the current BUFFER.
FILE is a filename to save the generated postscript in.  If this
is provided, it will NOT be sent to the printer.

The arguments COLOR and SIDE-BY-SIDE are straightforward -- they
will be determined via `y-or-n-p'.

HEADER works weirdly interactively -- I don't usually want the
header printed so the `y-or-n-p' asks whether to remove it."
  (interactive
   (list
    ;; `ps-print-preprint' needs a list or number argument
    (ps-print-preprint (when (y-or-n-p "Save to file? ") 1))
    (y-or-n-p "Color? ")
    (not (y-or-n-p "Remove header? "))
    (y-or-n-p "Side by side? ")))
  (let* ((ps-font-size
          (if side-by-side
              '(10 . 12)
            ps-font-size))
         (ps-n-up-printing
          (if side-by-side
              2
            1))
         (ps-print-header header)
         (ps-print-color-p (if color
                               t
                             'black-white)))
    (ps-print-buffer-with-faces file)))

(defun please-print-buffer-side-by-side (file &optional color)
  "Print the current buffer, split into two subpages.
This calls `ps-print-buffer-with-faces' with the variable
`ps-n-up-printing' set to 2."
  (interactive
   (list (ps-print-preprint current-prefix-arg)
         (y-or-n-p "Color? ")))
  (please-print-buffer file color ps-print-header t))

(defun please-print-buffer-with-header (file &optional color)
  "Print the current buffer with a header.
This calls `ps-print-buffer-with-faces' with the variable
`ps-print-header' set to t."
  (interactive
   (list (ps-print-preprint current-prefix-arg)
         (y-or-n-p "Color? ")))
  (please-print-buffer file color t))

Library-genesis

(use-package library-genesis
  :load-path "lisp/library-genesis"
  :bind
  ("C-z l" . library-genesis-search))

Reddit-browse

(use-package reddit-browse
  :load-path "lisp/reddit-browse"
  :custom
  (reddit-subreddit-list '("emacs" "lisp" "lispmemes"
                           "vxjunkies" "linux" "nethack"
                           "cello" "throwers"))
  :bind
  ("C-z r" . reddit-goto-subreddit))

"Install with straight" button

(defun add-straight-button-to-epkg-describe (pkg &rest _ignored)
  (when (member pkg (straight-recipes-list))
    (let ((inhibit-read-only t))
      (with-current-buffer (help-buffer)
        (goto-char (point-min))
        (forward-line 1)
        (insert "\n")
        (insert-button (format "Install %s with straight"
                               (propertize pkg 'face '(:inherit bold)))
                       'action `(lambda (&rest _ignored)
                                  (straight-use-package ',(intern pkg))))
        (insert "\n")))))

(advice-add 'epkg-describe-package :after #'add-straight-button-to-epkg-describe)

un-helmifying some commands

(with-eval-after-load 'helm-mode
  (dolist (f '(highlight-symbol-at-point
               highlight-regexp
               highlight-lines-matching-regexp
               highlight-phrase
               insert-char))
    (add-to-list 'helm-completing-read-handlers-alist
                 (list f))))

Functions

• Kill buffer
  

  I rebind C-x k to kill the current buffer, because helm-mini is so useful.

  (defun kill-this-buffer-please ()
    "Actually kill this buffer, unlike `kill-this-buffer' which
  sometimes doesn't work."
    (interactive)
    (kill-buffer (current-buffer)))
  

• Split window
  

  The way Helm splits windows can get in the way a bit. This more predictable function selects the largest non-exwm window.

  (defun helm-split-window-please (window)
    "If the frame only has one window, split it.  Otherwise, select
  the largest non-exwm window."
    (if (one-window-p t)
        (split-window (selected-window) nil
                      (if (> (window-pixel-width) (window-pixel-height))
                          'right
                        'below))
      (select-window
       ;; Reworking of `get-largest-window', doesn't choose an exwm
       ;; window.
       (let ((best-size 0)
             best-window size)
         (dolist (window (window-list-1 nil 'nomini))
           (when (and (not (window-dedicated-p window))
                      (not (eq window (selected-window)))
                      (not (equal
                            (buffer-local-value
                             'major-mode (window-buffer window))
                            'exwm-mode)))
             (setq size (* (window-pixel-height window)
                           (window-pixel-width window)))
             (when (> size best-size)
               (setq best-size size)
               (setq best-window window))))
         best-window))))
  

Helm Imenu

(use-package helm-imenu
  :straight helm
  :defer t
  :bind
  ("C-c i" . helm-imenu)
  ("C-c I" . helm-imenu-in-all-buffers))

Helm man

(use-package helm-man
  :defer t
  :straight helm
  :custom
  (man-width 80)
  :bind
  (:map help-map
        ("C-m" . helm-man-woman)))

Helm system packages

(use-package helm-system-packages
  :straight t
  :bind
  (:map help-map
        ("C-p" . helm-system-packages)))

Helm eww

(use-package helm-eww
  :straight t
  :bind
  ("C-x r e" . helm-eww-bookmarks))

Helm org

(use-package helm-org
  :straight t
  :after org
  :bind
  (:map org-mode-map
        ("C-c i" . helm-org-in-buffer-headings)))

Helm color

(use-package helm-color
  :defer t
  :config
  (setf (alist-get 'action helm-source-customize-face)
        '(("Describe". (lambda (line)
                         (describe-face
                          (intern (car (split-string line))))))
          ("Customize". (lambda (line)
                          (customize-face
                           (intern (car (split-string line))))))
          ("Copy name" . (lambda (line)
                           (kill-new (car (split-string line " " t))))))))

Helm epa mode

(use-package helm-misc
  :after helm epa
  :config
  (helm-epa-mode))

Helm Files

(use-package helm-files
  :defer t
  :config
  (define-key helm-find-files-map (kbd "C-c d") nil)
  (define-key helm-find-files-map (kbd "C-c C-d") #'helm-ff-persistent-delete))

Helm grep

(use-package helm-grep
  :bind
  ("M-g a" . helm-do-grep-ag)
  ("M-g g" . helm-grep-do-git-grep))

Helm eshell

(use-package helm-eshell
  :after (eshell em-hist)
  :bind
  (:map eshell-hist-mode-map
        ("M-r" . helm-eshell-history))
  (:map eshell-mode-map
        ("<tab>" . helm-esh-pcomplete)))

Edit source

(defun helpful-edit-source-temporarily ()
  "Edit the source shown in the current helpful buffer.
This pops open a buffer with only the symbol's source, rather
than taking you to its file.

Works with both elisp and C source code."
  (interactive)
  (unless (derived-mode-p 'helpful-mode)
    (user-error "Not in a helpful buffer"))
  (save-excursion
    (let* ((buffer
            (get-buffer-create
             (format "*%s (source)*"
                     helpful--sym)))
           (min (progn
                  (goto-char (point-min))
                  (or (re-search-forward "^Source Code$" nil t)
                      (error "No source available"))
                  (forward-line 1)
                  (point)))
           (max (progn
                  (goto-char min)
                  (end-of-defun)
                  (point)))
           (primitive-p
            (helpful--primitive-p helpful--sym helpful--callable-p)))
      (copy-to-buffer buffer
                      min
                      max)
      (pop-to-buffer buffer)
      (if primitive-p
          (c-mode)
        (emacs-lisp-mode)))))

Save symbol to kill ring

(defun helpful-copy-to-kill-ring (buffer)
  "Copy the callable or variable of BUFFER to the kill ring.
Called interactively, BUFFER is the current buffer or, with
prefix arg, read from the minibuffer."
  (interactive (list
                (if current-prefix-arg
                    (read-buffer "Copy symbol from buffer: "
                                 (current-buffer)
                                 t
                                 (lambda (buffer)
                                   (with-current-buffer buffer
                                     (derived-mode-p 'helpful-mode))))
                  (current-buffer))))
  (with-current-buffer buffer
    (unless (eq major-mode 'helpful-mode)
      (user-error "%s is not a helpful buffer" (buffer-name buffer)))
    (kill-new (symbol-name helpful--sym))
    (message "\"%s\" saved to kill ring." helpful--sym)))

Replacing some describe-* functions with helpful

(defun helpful-string (str)
  "Describe the symbol named STR.
This uses the `helpful' library instead of `describe-*'.  If STR
doesn't name an existing symbol, call `apropos' on it."
  (let ((symbol (intern-soft str)))
    (if symbol
        (helpful-symbol symbol)
      (apropos str))))

;; Org links
(with-eval-after-load 'ol
  (advice-add 'org-link--open-help
              :override #'helpful-string))

;; Erc buttons
(with-eval-after-load 'erc-button
  (advice-add 'erc-button-describe-symbol
              :override #'helpful-string))

;; Transient help
(with-eval-after-load 'transient
  (advice-add 'transient--describe-function
              :override #'helpful-callable))

Nov.el - epub in emacs

(use-package nov
  :straight t
  :custom
  (nov-text-width 80)
  (nov-variable-pitch nil)
  :mode ("\\.epub\\'" . nov-mode)
  :commands nov-bookmark-jump-handler
  :config

  :bind
  (:map nov-mode-map
        ([remap set-fill-column] . nov-set-width)))

• Set text width in nov buffer
  

  (defun nov-set-width (width)
    "Set the nov rendering width to WIDTH.
  If prefix arg is a number, use it.  Otherwise, read number from
  the minibuffer."
    (interactive (list
                  (if (numberp current-prefix-arg)
                      current-prefix-arg
                    (read-number "Set width: "
                                 (- (window-width) 5)))))
    (when (derived-mode-p 'nov-mode)
      (setq nov-text-width width)
      (nov-render-document)))
  

PDF-tools

(use-package pdf-tools
  :straight t
  :magic ("%PDF" . pdf-view-mode)
  :custom
  (pdf-links-browse-uri-function #'pdf-links-open-please)
  :hook
  (pdf-view-mode . auto-revert-mode)
  :config
  (defun pdf-links-open-please (uri)
    "Open \"textedit://\" links via `find-file', and jump to the
  right point.  I use this because lilypond output contains such
  links."
    (if (string-match "textedit://" uri)
        (let* ((path
                ;; get rid of textedit://
                (replace-regexp-in-string
                 "\\`textedit://" "" uri))
               (split
                (split-string path ":"))
               (file
                (url-unhex-string
                 (apply #'concat (butlast split 3))))
               (extras
                (reverse (cdr split)))
               (line
                (string-to-number (caddr extras)))
               (column
                (string-to-number (car extras)))
               (buffer (find-file-noselect file)))
          (pop-to-buffer buffer)
          (goto-char (point-min))
          (forward-line (1- line))
          (move-to-column column))
      (pdf-links-browse-uri-default uri)))
  (pdf-tools-install))

• Custom link handler
  

  Awkward hacky workaround to get LilyPond's links to open properly.

  (defun pdf-links-open-please (uri)
    "Open \"textedit://\" links via `find-file', and jump to the
  right point.  I use this because lilypond output contains such
  links."
    (if (string-match "textedit://" uri)
        (let* ((path
                ;; get rid of textedit://
                (replace-regexp-in-string
                 "\\`textedit://" "" uri))
               (split
                (split-string path ":"))
               (file
                (url-unhex-string
                 (apply #'concat (butlast split 3))))
               (extras
                (reverse (cdr split)))
               (line
                (string-to-number (caddr extras)))
               (column
                (string-to-number (car extras)))
               (buffer (find-file-noselect file)))
          (pop-to-buffer buffer)
          (goto-char (point-min))
          (forward-line (1- line))
          (move-to-column column))
      (pdf-links-browse-uri-default uri)))
  

LilyPond-mode

(use-package lilypond-mode
  :straight
  (lilypond-mode :type git
                 :repo "git@jamzattack.xyz:lilypond-mode.git")
  :delight
  (LilyPond-mode "ly" :major)
  :init
  (defalias 'lilypond-mode 'LilyPond-mode)
  (defun custom-lilypond-setup ()
    "Sets a bunch of things up for `LilyPond-mode'."
    (interactive)
    (hack-local-variables)
    (unless (or (file-exists-p "Makefile")
                (local-variable-p 'compile-command (current-buffer)))
      (setq-local compile-command
                  (format "lilypond \"%s\"" buffer-file-name)))
    (setq-local comment-column 0)
    (setq-local imenu-generic-expression
                '(("Bar" "^% bar \\([0-9]+\\)" 1)
                  ("Page" "^% PAGE \\([A-Z0-9]+\\)" 1)
                  ("Movement" "^% \\([Mm]o?ve?m?e?n?t\\) \\([A-Za-z0-9]+\\)" 2)
                  ("TODO" "^%?.*TODO[: ]?*\\(.*\\)" 1)
                  ("Variables" "^\\([a-zA-Z]+\\) *=" 1)))
    (when (fboundp 'display-fill-column-indicator-mode)
      (setq fill-column 80)
      (display-fill-column-indicator-mode)))
  :config
  (defun lilypond-insert-repeat (&optional beg end)
    "Insert a repeat around BEG and END.
  Interactively, this is the selected region.  Prompt for the
  type (volta or unfold) and number."
    (interactive "*r")
    (setq beg (copy-marker (or beg (point)))
          end (copy-marker (or end (1+ (point)))))
    (save-excursion
      (goto-char beg)
      (insert (format "\\repeat %s %s {\n"
                      (completing-read "Repeat type: " '("volta" "unfold"))
                      (read-number "Repeat number: " 2)))
      (goto-char end)
      (insert "}\n")
      (indent-region beg (1+ end))))

  (define-key LilyPond-mode-map (kbd "C-c C-r") #'lilypond-insert-repeat)
  (defun lilypond-insert-tuplet (fraction)
    "Insert a tuplet form at point.
  Prompt for FRACTION from the minibuffer.  If no text is entered,
  assume 3/2."
    (interactive "sTuplet fraction (default 3/2): ")
    (insert (format "\\tuplet %s {  }"
                    (if (string-empty-p fraction)
                        "3/2"
                      fraction)))
    (backward-char 2))

  (define-key LilyPond-mode-map (kbd "C-c C-t") #'lilypond-insert-tuplet)
  :custom
  (LilyPond-midi-command "timidity -Oj")
  (LilyPond-all-midi-command "timidity -Oj -ia")
  :mode ("\\.ly\\'" . LilyPond-mode)
  :hook (LilyPond-mode . custom-lilypond-setup))

• Custom lilypond setup
  

  A few miscellaneous things to add to LilyPond-mode-hook.

  • Loads local variables (LilyPond-mode missed this somehow)
  • Set compile-command if there's no Makefile or local variable
  • Sets the comment-column to 0
  • Sets up imenu regexps to show:
    • Bar numbers
    • Page numbers
    • Movement numbers
    • TODOs
    • Definitions
  • Turns on display-fill-column-indicator-mode if it's available (currently on master branch)

  (defun custom-lilypond-setup ()
    "Sets a bunch of things up for `LilyPond-mode'."
    (interactive)
    (hack-local-variables)
    (unless (or (file-exists-p "Makefile")
                (local-variable-p 'compile-command (current-buffer)))
      (setq-local compile-command
                  (format "lilypond \"%s\"" buffer-file-name)))
    (setq-local comment-column 0)
    (setq-local imenu-generic-expression
                '(("Bar" "^% bar \\([0-9]+\\)" 1)
                  ("Page" "^% PAGE \\([A-Z0-9]+\\)" 1)
                  ("Movement" "^% \\([Mm]o?ve?m?e?n?t\\) \\([A-Za-z0-9]+\\)" 2)
                  ("TODO" "^%?.*TODO[: ]?*\\(.*\\)" 1)
                  ("Variables" "^\\([a-zA-Z]+\\) *=" 1)))
    (when (fboundp 'display-fill-column-indicator-mode)
      (setq fill-column 80)
      (display-fill-column-indicator-mode)))
  

• Fancy repeat command
  

  Nice little command to insert a repeat. Wraps the region in \repeat and prompts for the type and number.

  (defun lilypond-insert-repeat (&optional beg end)
    "Insert a repeat around BEG and END.
  Interactively, this is the selected region.  Prompt for the
  type (volta or unfold) and number."
    (interactive "*r")
    (setq beg (copy-marker (or beg (point)))
          end (copy-marker (or end (1+ (point)))))
    (save-excursion
      (goto-char beg)
      (insert (format "\\repeat %s %s {\n"
                      (completing-read "Repeat type: " '("volta" "unfold"))
                      (read-number "Repeat number: " 2)))
      (goto-char end)
      (insert "}\n")
      (indent-region beg (1+ end))))
  
  (define-key LilyPond-mode-map (kbd "C-c C-r") #'lilypond-insert-repeat)
  

• Fancy tuplet command
  

  (defun lilypond-insert-tuplet (fraction)
    "Insert a tuplet form at point.
  Prompt for FRACTION from the minibuffer.  If no text is entered,
  assume 3/2."
    (interactive "sTuplet fraction (default 3/2): ")
    (insert (format "\\tuplet %s {  }"
                    (if (string-empty-p fraction)
                        "3/2"
                      fraction)))
    (backward-char 2))
  
  (define-key LilyPond-mode-map (kbd "C-c C-t") #'lilypond-insert-tuplet)
  

Markdown

(use-package markdown-mode
  :straight t
  :mode "\\.md\\'"
  :hook (markdown-mode . view-mode))

GNU APL mode

(use-package gnu-apl-mode
  :straight t
  :mode
  "\\.apl'"
  :custom
  (gnu-apl-interactive-mode-map-prefix ". ")
  (gnu-apl-mode-map-prefix ". "))

Geiser

(use-package geiser
  :straight
  (geiser :type git
          :host gitlab
          :flavor melpa
          :repo "emacs-geiser/geiser")
  :defer t
  :delight
  (scheme-mode "scm" :major)
  (geiser-repl-mode "SCM>" :major)
  (geiser-autodoc-mode)
  :hook
  (scheme-mode . geiser-mode)
  (geiser-repl-mode . paredit-mode)
  :custom
  (scheme-program-name
   (or (executable-find "guile3.0")
       (executable-find "guile")
       (executable-find "chez")
       (executable-find "mit-scheme")
       "scheme"))
  (geiser-default-implementation 'guile)
  (geiser-repl-history-filename "~/.cache/geiser/history"))

• Geiser Implementations
  

  As of March 2021, geiser doesn't include any implementation-specific code, so they need to be installed separately. I mostly use Guile, but also install chez and mit just in case.

  (use-package geiser-guile
    :straight
    (geiser-guile :type git
                  :host gitlab
                  :flavor melpa
                  :repo "emacs-geiser/guile")
    :after geiser)
  
  (use-package geiser-chez
    :straight
    (geiser-chez :type git
                  :host gitlab
                  :flavor melpa
                  :repo "emacs-geiser/chez")
    :after geiser)
  
  (use-package geiser-mit
    :straight
    (geiser-mit :type git
                  :host gitlab
                  :flavor melpa
                  :repo "emacs-geiser/mit")
    :after geiser)
  

SLIME

(use-package slime
  :straight t
  :delight
  (lisp-mode "cl" :major)
  (slime-repl-mode "CL>" :major)
  (slime-mode)
  (slime-autodoc-mode)
  :init
  (autoload 'slime-switch-to-output-buffer "slime-repl")
  (defun disable-slime-completion ()
    (setq slime-completion-at-point-functions
          '(slime-simple-completion-at-point)))
  :hook (slime-connected . disable-slime-completion)
  :custom
  (slime-contribs '(slime-fancy))
  (slime-repl-history-file "~/.cache/slime/history")
  (common-lisp-hyperspec-root
   (if (file-exists-p "/usr/share/doc/clhs/HyperSpec/")
       "file:///usr/share/doc/clhs/HyperSpec/"
     "http://clhs.lisp.se/"))
  (slime-auto-start 'ask)
  :bind
  (:map slime-mode-map
        ("C-c C-z" . slime-switch-to-output-buffer))
  :config
  (with-eval-after-load 'slime-repl
    (bind-key "C-c C-z" #'quit-window slime-repl-mode-map))
  (setq slime-lisp-implementations
        '((roswell ("ros" "-Q" "run"))
          (sbcl ("sbcl"))
          (ccl ("ccl"))
          (clisp ("clisp")))))

Paredit

(use-package paredit
  :straight t
  :defer t
  :delight
  :bind
  ("M-\"" . paredit-meta-doublequote)
  ("M-(" . paredit-open-round)
  ("C-(" . paredit-backward-slurp-sexp)
  ("C-)" . paredit-forward-slurp-sexp)
  ("C-{" . paredit-backward-barf-sexp)
  ("C-}" . paredit-forward-barf-sexp)
  (:map paredit-mode-map
        ("M-R" . paredit-splice-sexp-killing-backward))
  :hook
  (emacs-lisp-mode . paredit-mode)
  (lisp-interaction-mode . paredit-mode)
  (ielm-mode . paredit-mode)
  (eval-expression-minibuffer-setup . paredit-mode)
  (lisp-mode . paredit-mode)
  (slime-repl-mode . paredit-mode)
  (scheme-mode . paredit-mode))

Elf-mode

(use-package elf-mode
  :straight t
  :magic ("\dELF" . elf-mode))

Macrostep

(use-package macrostep
  :straight t
  :bind
  (:map emacs-lisp-mode-map
        ("C-c M-e" . macrostep-expand)))

Regexp Expand

(use-package regexp-expand
  :straight
  (regexp-expand :type git
                 :host github
                 :repo "danielmartin/regexp-expand")
  :bind
  (:map emacs-lisp-mode-map
        ("C-c M-r" . regexp-expand)))

Selime   mine

(use-package selime
  :straight
  (selime :type git
          :flavor melpa
          :repo "git@jamzattack.xyz:selime.git")
  :delight
  :hook (emacs-lisp-mode . selime-mode))

Lex-hl   mine

(use-package lex-hl
  :straight
  (lex-hl :type git
          :flavor melpa
          :repo "git@jamzattack.xyz:lex-hl.git")
  :bind
  (:map emacs-lisp-mode-map
        ("C-c `" . lex-hl-unhighlight)
        ("C-c '" . lex-hl-top-level)
        ("C-c ," . lex-hl-prompt)
        ("C-c ." . lex-hl-nearest)))

LilyPond auto-insert   mine

(use-package lilypond-auto-insert
  :straight
  (lilypond-auto-insert :type git
                        :flavor melpa
                        :repo "git@jamzattack.xyz:lilypond-auto-insert.git")
  :after lilypond-mode
  :custom
  (lilypond-auto-insert-language "english")
  :bind
  (:map LilyPond-mode-map
        ("C-c a" . lilypond-auto-insert)))

Lua Mode

(use-package lua-mode
  :straight t
  :mode ("\\.lua\\'" . lua-mode))

Htmlize

(use-package htmlize
  :straight t
  :defer t)

Org web tools

(use-package org-web-tools
  :straight t
  :defer t)

Org Elisp index   mine

(use-package org-el-index
  :straight
  (org-el-index :type git
                :repo "git@jamzattack.xyz:org-el-index.git")
  :after org
  :bind
  (:map org-mode-map
        ("C-c M-i" . org-el-index-file-small)))

Desktop-environment (useful with EXWM)

(use-package desktop-environment
  :straight t
  :delight
  :hook
  (exwm-init . desktop-environment-mode)
  :config
  (defun custom-screenlock-command ()
    "Change the value of `desktop-environment-screenlock-command'
  to run i3lock with the background colour of the current theme."
    (let ((color (face-attribute 'default :background)))
      (setq desktop-environment-screenlock-command
            (format "i3lock -c '%s' -n"
                    (with-temp-buffer
                      (insert (if
                                  (= (length color) 7)
                                  color
                                "#000000"))
                      (beginning-of-line)
                      (delete-char 1)
                      (buffer-string))))))
  (defadvice desktop-environment-lock-screen
      (before change-bg-color activate)
    (custom-screenlock-command))
  (desktop-environment-mode))

• Change screenlock command based on theme colour
  

  (defun custom-screenlock-command ()
    "Change the value of `desktop-environment-screenlock-command'
  to run i3lock with the background colour of the current theme."
    (let ((color (face-attribute 'default :background)))
      (setq desktop-environment-screenlock-command
            (format "i3lock -c '%s' -n"
                    (with-temp-buffer
                      (insert (if
                                  (= (length color) 7)
                                  color
                                "#000000"))
                      (beginning-of-line)
                      (delete-char 1)
                      (buffer-string))))))
  

Vterm

(use-package vterm
  :straight t
  :defer t
  :config
  (defun eshell/vterm (&rest args)
    "Launch a program from eshell using vterm."
    (let ((vterm-shell
           (eshell-flatten-and-stringify args)))
      (vterm))))

• Launch a vterm from eshell
  

  The function eshell/vterm starts a program in vterm from eshell.

  (defun eshell/vterm (&rest args)
    "Launch a program from eshell using vterm."
    (let ((vterm-shell
           (eshell-flatten-and-stringify args)))
      (vterm)))
  

Music

(defvar my-music-map (make-sparse-keymap)
  "My keymap for playing music.")

(global-set-key (kbd "s-m") my-music-map)

• Libmpdee
  

  An mpd library. I use it only for random/shuffle, because MPDel doesn't support that somehow.

  (use-package libmpdee
    :straight t
    :when (executable-find "mpd")
    :bind
    (:map my-music-map
          ("z" . mpd-toggle-random)))
  

• MPDel
  

  A small and flexible mpd client. I bind a bunch of keys in my music map, loosely based on mpdel-core-map because I used to just use that directly.

  (use-package mpdel
    :straight t
    :when (executable-find "mpd")
    :bind
    (:map my-music-map
          ;; Playing music
          ("SPC" . libmpdel-playback-play-pause)
          ("n" . libmpdel-playback-next)
          ("p" . libmpdel-playback-previous)
          ("f" . mpdel-song-normal-increment)
          ("b" . mpdel-song-normal-decrement)
          ;; Choosing music
          ("l" . mpdel-playlist-open)
          ("L" . mpdel-core-open-stored-playlists)
          ("a" . mpdel-core-open-albums)
          (":" . mpdel-browser-open)
          ("?" . mpdel-song-open)
          ;; Searching
          ("s s" . mpdel-core-search-by-title)
          ("s l" . mpdel-core-search-by-album)
          ("s r" . mpdel-core-search-by-artist)
          ;; Volume
          ("+" . mpdel-core-volume-increase)
          ("-" . mpdel-core-volume-decrease)))
  

• Eradio
  

  A very simple internet radio player. It just prompts for a station from eradio-channels and streams it via a specified media player.

  I've started getting into electronic music, so I've added a few synth/vaporwave/lofi channels, as well as the national news and classical channels.

  (use-package eradio
    :straight t
    :config
    (setq eradio-channels
          '(("RNZ Concert" . "https://radionz-ice.streamguys.com/concert.mp3")
            ("RNZ National" . "https://radionz-ice.streamguys.com/national.mp3")
            ("Paekakariki FM" . "https://icecast.groundtruth.co.nz/paekakfm.mp3")
            ("Melancholy Corner" . "https://melancholy.xyz:8443/mp3")
            ("SG Radio" . "http://stream.laut.fm/synthesizergreatest")
            ("Chilled Cow" . "https://youtube.com/watch?v=5qap5aO4i9A")
            ("Darksynth" . "https://stream.laut.fm/darksynthradio"))
          eradio-player '("mpv" "--no-video" "--speed=1" "--no-terminal"))
    :bind
    (:map my-music-map
          ("r" . eradio-play)
          ("DEL" . eradio-stop)))
  

Transmission

(use-package transmission
  :straight t
  :when (executable-find "transmission-daemon")
  :defer t
  :commands transmission-mode
  :init
  (defun transmission-add-url-at-point (url &optional directory)
    "Adds torrent if point is on a magnet or torrent link.
With prefix arg, prompt for DIRECTORY in which to download."
    (interactive (list (shr-url-at-point nil)
                       (when current-prefix-arg
                         (read-directory-name "Download in: " "~/Downloads/"))))
    (transmission-add url directory))
  (defun open-transmission-in-this-window ()
    "Open the transmission buffer in the selected window.
This also sets the buffer's default directory to ~/Downloads."
    (interactive)
    (let ((buffer (get-buffer-create "*transmission*")))
      (with-current-buffer buffer
        (unless (derived-mode-p 'transmission-mode)
          (transmission-mode)
          (revert-buffer))
        (setq default-directory "~/Downloads/"))
      (pop-to-buffer-same-window buffer)))
  :bind
  ("C-z C-t" . open-transmission-in-this-window)
  :config
  (bind-keys :map transmission-mode-map
             ("M" . transmission-move)))

Elpher

(use-package elpher
  :straight t
  :defer t
  :commands elpher-go
  :bind
  (:map elpher-mode-map
        ("l" . elpher-back)
        ("t" . elpher-back-to-start)
        ("g" . elpher-reload)
        ("G" . elpher-go)
        ("w" . elpher-copy-link-url)
        ("W" . elpher-copy-current-url)
        ("v" . elpher-view-raw)
        )
  :init
  (defun elpher-go-please (url &rest _ignore)
    "Like `elpher-go', but allows extra arguments.
This is useful for `browse-url-handlers'"
    (elpher-go url))
  (with-eval-after-load 'browse-url
    (add-to-list 'browse-url-handlers
                 '("\\`\\(gopher\\|gemini\\)://" . elpher-go-please))))

• Elpher keybindings
  

  ("l" . elpher-back)
  ("t" . elpher-back-to-start)
  ("g" . elpher-reload)
  ("G" . elpher-go)
  ("w" . elpher-copy-link-url)
  ("W" . elpher-copy-current-url)
  ("v" . elpher-view-raw)
  

• Elpher org-link support   mine
  

  My own library to provide org-link support for elpher.

  Hosted here.

  (use-package ol-elpher
    :straight
    (ol-elpher :type git
               :repo "git@jamzattack.xyz:ol-elpher.git")
    :after ol)
  

EBDB

(use-package ebdb
  :straight
  (:host github :repo "girzel/ebdb")
  :defer t
  :custom
  (ebdb-mua-pop-up nil)
  (ebdb-sources
   (expand-file-name
    "ebdb.gpg" user-emacs-directory))
  (ebdb-completion-display-record nil)
  :init
  (with-eval-after-load 'gnus
    (require 'ebdb-gnus))
  (with-eval-after-load 'message
    (require 'ebdb-message)))

Magit

(use-package magit
  :straight t
  :custom
  (magit-display-buffer-function
   #'magit-display-buffer-same-window-except-diff-v1)
  (magit-log-section-commit-count 20)
  :bind
  ("C-x g" . magit-status)
  :config
  (with-eval-after-load 'exwm
    (setq magit-section-visibility-indicator
          '(magit-fringe-bitmap> . magit-fringe-bitmapv))))

Rainbow-delimiters

(use-package rainbow-delimiters
  :straight t
  :defer t
  :hook (prog-mode . rainbow-delimiters-mode))

Dimmer (dim inactive buffers)

(use-package dimmer
  :straight t
  :hook
  (after-init . dimmer-mode)
  :config
  (setq dimmer-fraction 0.3)
  (dimmer-configure-org)
  (dimmer-configure-magit)
  (dimmer-configure-helm)
  (dimmer-configure-gnus))

Edwina

(use-package edwina
  :straight t
  :defer t
  :config
  (edwina-setup-dwm-keys 'super))

Plumb   mine

(use-package plumb
  :straight
  (plumb :type git
         :flavor melpa
         :repo "git@jamzattack.xyz:plumb.git")
  :bind
  ("C-z d" . plumb)
  ("C-z C-d" . plumb))

Narrow-x   mine

(use-package narrow-x
  :straight
  (narrow-x :type git
            :repo "git@jamzattack.xyz:narrow-x.git")
  :bind
  (:map narrow-map
        ("h" . narrow-to-paragraph)
        ("M-n" . narrow-to-next-paragraph)
        ("M-p" . narrow-to-prev-paragraph)
        ("DEL" . narrow-to-prev-page)
        ("SPC" . narrow-to-next-page)
        ("b" . narrow-to-prev-defun)
        ("f" . narrow-to-next-defun)))

Search-query   mine

(use-package search-query
  :straight
  (search-query :type git
                :repo "git@jamzattack.xyz:search-query")
  :custom
  (search-query-tpb-mirror "piratebay.live")
  (search-query-invidious-mirror "yewtu.be")
  :bind
  ("C-z a" . search-archwiki)
  ("C-z t" . search-tpb)
  ("C-z y" . search-invidious)          ; just youtube really
  ("C-z w" . search-wikipedia)
  ("C-z C-w" . search-wiktionary)
  ("C-z C-e" . search-etymonline))

Insert Date   mine

(use-package insert-date
  :straight
  (insert-date :type git
               :repo "git@jamzattack.xyz:insert-date.git")
  :bind
  (:prefix "C-c d" :prefix-map insert-date-map
           ("v" . insert-date-version)
           ("d" . insert-date-only-date)
           ("t" . insert-date-only-time)
           ("l" . insert-date-locale)
           ("b" . insert-date-both)
           ("i" . insert-date-iso8601)))

Itch   mine

(use-package itch
  :straight (itch :type git
                  :repo "git@jamzattack.xyz:itch")
  :bind
  ("s-a" . itch-fundamental)
  ("s-A" . itch-switch-to-fundamental)
  ("s-u" . itch-elisp)
  ("s-U" . itch-switch-to-elisp)
  ("s-e" . itch-eshell)
  ("s-E" . itch-switch-to-eshell)
  ("s-o" . itch-org)
  ("s-O" . itch-switch-to-org))

Dired-async

(use-package dired-async
  :straight async
  :defer t
  :config
  (dired-async-mode))

Dired-subtree

(use-package dired-subtree
  :straight dired-hacks
  :after dired
  :demand t
  :custom
  (dired-subtree-use-backgrounds nil)
  :bind
  (:map dired-mode-map
        ("TAB" . dired-subtree-cycle)))

Eshell outline mode   mine

(use-package eshell-outline
  :straight
  (eshell-outline :type git
                  :flavor melpa
                  :repo "git@jamzattack.xyz:eshell-outline.git")
  :hook (eshell-mode . eshell-outline-mode))

Fish completion

(use-package fish-completion
  :straight t
  :after eshell
  :when (executable-find "fish")
  :config
  (global-fish-completion-mode))

Lorem Ipsum

(use-package lorem-ipsum
  :straight t
  :defer t)