Evie Litherland-Smith 454d446077 Add hook to enable eglot in prog-mode

2023-11-09 11:41:56 +00:00

36 KiB

Raw Blame History

Emacs Config

Common defaults
UI
Org-mode
Development Environment
- Eglot LSP
- Project
- Version control
- [5/7] Completion
  - Vertico
  - Marginalia
  - Orderless
  - Corfu and Cape
  - Consult
  - Embark
Internet
- Email
- Feeds
- Social
Media
Writing

Common defaults

  (setq custom-file (locate-user-emacs-file "custom.el"))
  (when (and custom-file (file-exists-p custom-file))
    (load custom-file nil 'nomessage))

  (setq user-full-name "Evie Litherland-Smith"
        user-mail-address "evie@xenia.me.uk"
        use-short-answers t
        load-prefer-newer t
        indent-tabs-mode nil
        global-auto-revert-non-file-buffers t
        dired-auto-revert-buffer t
        dired-dwim-target t
        tab-always-indent 'complete
        completion-cycle-threshold 3
        completions-detailed t
        xref-show-definitions-function #'xref-show-definitions-completing-read
        kill-do-not-save-duplicates t
        auto-window-vscroll nil
        fast-but-imprecise-scrolling t
        scroll-conservatively 101
        scroll-margin 0
        scroll-preserve-screen-position 1)

  (set-default-coding-systems 'utf-8)
  (set-terminal-coding-system 'utf-8)
  (set-keyboard-coding-system 'utf-8)

  (global-auto-revert-mode +1)
  (delete-selection-mode)

  ;; Misc useful keymaps
  (keymap-global-set "M-#" #'dictionary-lookup-definition)
  (keymap-global-set "C-c r" #'recentf)
  (keymap-global-set "C-c b" #'ibuffer)
  (keymap-global-set "C-c p l" #'list-packages)
  (keymap-global-set "C-c p r" #'package-refresh-contents)
  (keymap-global-set "C-c p i" #'package-install)
  (keymap-global-set "C-c p d" #'package-delete)

  ;; turn on spell checking, if available.
  (when (and (require 'ispell nil :noerror) (executable-find ispell-program-name))
    (add-hook 'text-mode-hook #'flyspell-mode)
    (add-hook 'prog-mode-hook #'flyspell-prog-mode))

  ;; Make shebang (#!) file executable when saved
  (add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p)

package-archive with priorities

  (when (require 'package nil :noerror)
    (add-to-list 'package-archives '("stable" . "https://stable.melpa.org/packages/"))
    (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))

    (setq package-archive-priorities '(("gnu" . 99)
                                       ("nongnu" . 80)
                                       ("stable" . 70)
                                       ("melpa" . 0))))

Authentication

  (when (require 'auth-source nil :noerror)
    (setq auth-sources '("secrets:Login"))
    (when (require 'auth-source-pass nil :noerror)
      (auth-source-pass-enable)))

Helpful

  ;; Make `describe-*' screens more helpful
  (use-package helpful
    :ensure t
    :bind (("<remap> <describe-command>" . helpful-command)
           ("<remap> <describe-function>" . helpful-callable)
           ("<remap> <describe-key>" . helpful-key)
           ("<remap> <describe-symbol>" . helpful-symbol)
           ("<remap> <describe-variable>" . helpful-variable)
           ("C-h F" . helpful-function)
           :map helpful-mode-map
           ("<remap> <revert-buffer>" . helpful-update)))

  ;; Bind extra `describe-*' commands
  (keymap-global-set "C-h K" #'describe-keymap)

Link hint keymaps

  (use-package link-hint
    :ensure t
    :bind (("C-c l o" . link-hint-open-link)
           ("C-c l c" . link-hint-copy-link)
           ("C-c l C-o" . link-hint-open-all-link)
           ("C-c l C-c" . link-hint-copy-all-link)))

UI

  (setq use-dialog-box nil
        fill-column 80
        truncate-lines nil
        truncate-partial-width-windows nil)

  (menu-bar-mode -1)
  (tab-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (line-number-mode)
  (global-display-line-numbers-mode -1)
  (global-prettify-symbols-mode +1)
  (global-visual-line-mode +1)

  (use-package which-key
    :ensure t
    :config (which-key-mode +1))

  (use-package page-break-lines
    :ensure t
    :config (global-page-break-lines-mode +1))

  ;; add visual pulse when changing focus, like beacon but built-in
  ;; from from https://karthinks.com/software/batteries-included-with-emacs/
  (defun pulse-line (&rest _)
    "Pulse the current line."
    (pulse-momentary-highlight-one-line (point)))

  (dolist (command '(scroll-up-command
                     scroll-down-command
                     recenter-top-bottom
                     other-window))
    (advice-add command :after #'pulse-line))

Theme, font and nerd-icons

  (set-frame-font "Fira Code-12")
  (set-frame-parameter nil 'alpha-background 80)

  ;; Theme
  (use-package modus-themes
    :ensure t
    :config (load-theme 'modus-vivendi-tinted :noconfirm))

  ;; Nerd-Icons modes
  (use-package nerd-icons
    :ensure t
    :config (nerd-icons-set-font "Symbols Nerd Font Mono"))

  (use-package nerd-icons-dired
    :ensure t
    :hook (dired-mode))

  (use-package nerd-icons-ibuffer
    :ensure t
    :hook (ibuffer-mode))

  (use-package nerd-icons-completion
    :ensure t
    :config (nerd-icons-completion-mode +1))

Font ligatures

  (use-package ligature
    :ensure t
    :config
    ;; Enable the "www" ligature in every possible major mode
    (ligature-set-ligatures 't '("www"))
    ;; Enable traditional ligature support in eww-mode, if the
    ;; `variable-pitch' face supports it
    (ligature-set-ligatures 'eww-mode '("ff" "fi" "ffi"))
    ;; Enable all Cascadia and Fira Code ligatures in programming modes
    (ligature-set-ligatures 'prog-mode
                            '(;; == === ==== => =| =>>=>=|=>==>> ==< =/=//=// =~
                              ;; =:= =!=
                              ("=" (rx (+ (or ">" "<" "|" "/" "~" ":" "!" "="))))
                              ;; ;; ;;;
                              (";" (rx (+ ";")))
                              ;; && &&&
                              ("&" (rx (+ "&")))
                              ;; !! !!! !. !: !!. != !== !~
                              ("!" (rx (+ (or "=" "!" "\." ":" "~"))))
                              ;; ?? ??? ?:  ?=  ?.
                              ("?" (rx (or ":" "=" "\." (+ "?"))))
                              ;; %% %%%
                              ("%" (rx (+ "%")))
                              ;; |> ||> |||> ||||> |] |} || ||| |-> ||-||
                              ;; |->>-||-<<-| |- |== ||=||
                              ;; |==>>==<<==<=>==//==/=!==:===>
                              ("|" (rx (+ (or ">" "<" "|" "/" ":" "!" "}" "\]"
                                              "-" "=" ))))
                              ;; \\ \\\ \/
                              ("\\" (rx (or "/" (+ "\\"))))
                              ;; ++ +++ ++++ +>
                              ("+" (rx (or ">" (+ "+"))))
                              ;; :: ::: :::: :> :< := :// ::=
                              (":" (rx (or ">" "<" "=" "//" ":=" (+ ":"))))
                              ;; // /// //// /\ /* /> /===:===!=//===>>==>==/
                              ("/" (rx (+ (or ">"  "<" "|" "/" "\\" "\*" ":" "!"
                                              "="))))
                              ;; .. ... .... .= .- .? ..= ..<
                              ("\." (rx (or "=" "-" "\?" "\.=" "\.<" (+ "\."))))
                              ;; -- --- ---- -~ -> ->> -| -|->-->>->--<<-|
                              ("-" (rx (+ (or ">" "<" "|" "~" "-"))))
                              ;; *> */ *)  ** *** ****
                              ("*" (rx (or ">" "/" ")" (+ "*"))))
                              ;; www wwww
                              ("w" (rx (+ "w")))
                              ;; <> <!-- <|> <: <~ <~> <~~ <+ <* <$ </  <+> <*>
                              ;; <$> </> <|  <||  <||| <|||| <- <-| <-<<-|-> <->>
                              ;; <<-> <= <=> <<==<<==>=|=>==/==//=!==:=>
                              ;; << <<< <<<<
                              ("<" (rx (+ (or "\+" "\*" "\$" "<" ">" ":" "~"  "!"
                                              "-"  "/" "|" "="))))
                              ;; >: >- >>- >--|-> >>-|-> >= >== >>== >=|=:=>>
                              ;; >> >>> >>>>
                              (">" (rx (+ (or ">" "<" "|" "/" ":" "=" "-"))))
                              ;; #: #= #! #( #? #[ #{ #_ #_( ## ### #####
                              ("#" (rx (or ":" "=" "!" "(" "\?" "\[" "{" "_(" "_"
                                           (+ "#"))))
                              ;; ~~ ~~~ ~=  ~-  ~@ ~> ~~>
                              ("~" (rx (or ">" "=" "-" "@" "~>" (+ "~"))))
                              ;; __ ___ ____ _|_ __|____|_
                              ("_" (rx (+ (or "_" "|"))))
                              ;; Fira code: 0xFF 0x12
                              ("0" (rx (and "x" (+ (in "A-F" "a-f" "0-9")))))
                              ;; Fira code:
                              "Fl"  "Tl"  "fi"  "fj"  "fl"  "ft"
                              ;; The few not covered by the regexps.
                              "{|"  "[|"  "]#"  "(*"  "}#"  "$>"  "^="))
    ;; Enables ligature checks globally in all buffers. You can also do it
    ;; per mode with `ligature-mode'.
    (global-ligature-mode t))

Modeline

  ;; Doom-Modeline
  (setq doom-modeline-icon t
        doom-modeline-mu4e nil ;; Use mu4e own formatting
        doom-modeline-modal nil
        doom-modeline-modal-icon nil
        doom-modeline-persp-name nil
        doom-modeline-persp-icon nil)
  (use-package doom-modeline
    :ensure t
    :config (doom-modeline-mode +1))

Dashboard

  ;; Dashboard
  (setq dashboard-icon-type 'nerd-icons
        dashboard-set-heading-icons t
        dashboard-set-file-icons t
        dashboard-set-navigator t
        dashboard-set-init-info t
        dashboard-startup-banner 'ascii
        dashboard-projects-backend 'project-el
        dashboard-projects-switch-function 'project-switch-project
        dashboard-projects-show-base t
        dashboard-recentf-show-base 'align
        dashboard-items '()
        dashboard-banner-ascii (concat "          .000000.          \n"
                                       "         .0.    .0.         \n"
                                       "       .00.      .00.       \n"
                                       " .000cl.            .lc000. \n"
                                       ".0                        0.\n"
                                       "0.        .o0000o.        .0\n"
                                       " 00     .0'      '0.     00 \n"
                                       "  00   .0          0.   00  \n"
                                       "  HHHHH HHHHHHHHHHHH HHHHH  \n"
                                       "HHHH HHH HHHHHHHHHHHHHH HHHH\n"
                                       " HHHHHH HHHHHHHHH HHHHHHHH  \n"
                                       "  HHH HHHH HHHHHHHHH HHHH   \n"
                                       "         HHH HHHHHH         \n"
                                       "          HHHHH HH          \n"))
  (use-package dashboard
    :ensure t
    :config (setq initial-buffer-choice 'dashboard-open))

Org-mode

For reference information, see Org-mode website

  (setq org-directory "~/Org"
        org-default-notes-file (expand-file-name "notes.org" org-directory)
        org-pretty-entities-include-sub-superscripts t
        org-pretty-entities-include-sub-superscripts t
        org-tags-column 0
        org-modern-tag nil
        org-outline-path-complete-in-steps nil
        org-refile-use-outline-path t
        org-refile-allow-creating-parent-nodes t
        org-refile-use-outline-path 'file
        org-refile-targets '((nil :maxlevel . 3)
                             (org-agenda-files :maxlevel . 3)))

Keymaps

  (keymap-global-set "C-c o e" #'org-edit-src-code)
  (keymap-global-set "C-c o a" #'org-agenda)
  (keymap-global-set "C-c o n" #'org-capture)
  (keymap-global-set "C-c o l" #'org-capture-goto-last-stored)
  (keymap-global-set "C-c o j j" #'org-journal-new-entry)
  (keymap-global-set "C-c o j n" #'org-journal-new-date-entry)
  (keymap-global-set "C-c o j s" #'org-journal-new-scheduled-entry)

  (add-hook 'org-mode-hook #'org-modern-mode)
  (add-hook 'org-agenda-finalize-hook #'org-modern-agenda)

org-agenda

  (setq org-agenda-span 'week
        org-agenda-start-on-weekday 1
        org-agenda-files (list (expand-file-name org-directory)
                               (expand-file-name "journal" org-directory)
                               (expand-file-name "projects" org-directory))
        org-agenda-sticky t
        org-agenda-window-setup 'current-window
        org-agenda-prefix-format '((agenda . " %-12:c%?-12t% s")
                                   (todo . " %-12:c")
                                   (tags . " %-12:c")
                                   (search . " %-12:c")))

org-journal

  (setq org-journal-dir (expand-file-name "journal" org-directory)
        org-journal-file-type 'monthly
        org-journal-file-format "%Y-%m.org")

Capture templates

  (setq org-capture-templates
        '(("n" "Note" entry
           (file+headline "inbox.org" "Note")
           "* %?"
           :prepend t
           :empty-lines 1)
          ("t" "Task" entry
           (file+headline "inbox.org" "Task")
           "* TODO %?"
           :prepend t
           :empty-lines 1)
          ("m" "Email Workflow")
          ("mf" "Follow Up" entry (file+olp "mail.org" "Follow Up")
           "* TODO Follow up with %:fromname on %a\nSCHEDULED:%t\nDEADLINE: %(org-insert-time-stamp (org-read-date nil t \"+2d\"))\n\n%i")
          ("mr" "Read Later" entry (file+olp "mail.org" "Read Later")
           "* TODO Read %:subject\nSCHEDULED:%t\nDEADLINE: %(org-insert-time-stamp (org-read-date nil t \"+2d\"))\n\n%a\n\n%i")
          ))

Citar

  (setq citar-bibliography '("~/.references/main.bib")
        citar-library-paths '("~/.references/library")
        citar-notes-paths '("~/.references/notes")
        citar-symbols '((file "F" . "󰂺")
                        (note "N" . "󰎞")
                        (link "L" . "󰌹")))
  (when (require 'citar nil :noerror)
    (keymap-global-set "C-c o c o" #'citar-open))

Khalel

  (setq khalel-import-org-file (expand-file-name "calendar.org" org-directory)
        khalel-import-org-file-read-only nil
        khalel-import-org-file-confirm-overwrite nil
        khalel-import-start-date "-30d"
        khalel-import-end-date "+30d")
  (when (require 'khalel nil :noerror)
    (add-hook 'org-agenda-mode-hook #'khalel-import-events)
    (khalel-add-capture-template "e"))

TODO Crafted config

  ;; Return or left-click with mouse follows link
  (customize-set-variable 'org-return-follows-link t)
  (customize-set-variable 'org-mouse-1-follows-link t)

  ;; Display links as the description provided
  (customize-set-variable 'org-link-descriptive t)

  ;; Visually indent org-mode files to a given header level
  (add-hook 'org-mode-hook #'org-indent-mode)

  ;; Hide markup markers
  (customize-set-variable 'org-hide-emphasis-markers t)
  (when (locate-library "org-appear")
    (add-hook 'org-mode-hook 'org-appear-mode))

  ;; Disable auto-pairing of "<" in org-mode with electric-pair-mode
  (defun crafted-org-enhance-electric-pair-inhibit-predicate ()
    "Disable auto-pairing of \"<\" in `org-mode' when using `electric-pair-mode'."
    (when (and electric-pair-mode (eql major-mode #'org-mode))
      (setq-local electric-pair-inhibit-predicate
                  `(lambda (c)
                     (if (char-equal c ?<)
                         t
                       (,electric-pair-inhibit-predicate c))))))

  ;; Add hook to both electric-pair-mode-hook and org-mode-hook
  ;; This ensures org-mode buffers don't behave weirdly,
  ;; no matter when electric-pair-mode is activated.
  (add-hook 'electric-pair-mode-hook #'crafted-org-enhance-electric-pair-inhibit-predicate)
  (add-hook 'org-mode-hook #'crafted-org-enhance-electric-pair-inhibit-predicate)

Development Environment

  (use-package rainbow-delimiters
    :ensure t
    :hook (prog-mode))

  (setq apheleia-remote-algorithm 'local)
  (use-package apheleia
    :ensure t
    :defer nil
    :bind (("C-c c f" . apheleia-format-buffer))
    :config (apheleia-global-mode +1))

  (use-package ibuffer-project
    :ensure t
    :hook ((ibuffer . (lambda ()
                        (setq ibuffer-filter-groups (ibuffer-project-generate-filter-groups))
                        (unless (eq ibuffer-sorting-mode 'project-file-relative)
                          (ibuffer-do-sort-by-project-file-relative))))))

  (use-package treesit-auto
    :config (global-treesit-auto-mode +1))

  (setq direnv-always-show-summary nil)
  (use-package direnv
    :config (direnv-mode +1))

Eglot LSP

  (when (require 'eglot nil :noerror)
    ;; Currently just using prog-mode
    ;; Should probably use individual language modes
    ;; One day...
    (add-hook 'prog-mode-hook #'eglot-ensure))
  ;;; Eglot
  (defun crafted-ide--add-eglot-hooks (mode-list)
    "Add `eglot-ensure' to modes in MODE-LIST.

  The mode must be loaded, i.e. found with `fboundp'.  A mode which
  is not loaded will not have a hook added, in which case add it
  manually with something like this:

  `(add-hook 'some-mode-hook #'eglot-ensure)'"
    (dolist (mode-def mode-list)
      (let ((mode (if (listp mode-def) (car mode-def) mode-def)))
        (cond
         ((listp mode) (crafted-ide--add-eglot-hooks mode))
         (t
          (when (and (fboundp mode)
                     (not (eq 'clojure-mode mode))  ; prefer cider
                     (not (eq 'lisp-mode mode))     ; prefer sly/slime
                     (not (eq 'scheme-mode mode))   ; prefer geiser
                     )
            (let ((hook-name (format "%s-hook" (symbol-name mode))))
              (message "adding eglot to %s" hook-name)
              (add-hook (intern hook-name) #'eglot-ensure))))))))

  ;; add eglot to existing programming modes when eglot is loaded.
  (with-eval-after-load "eglot"
    (crafted-ide--add-eglot-hooks eglot-server-programs))

  ;; Shutdown server when last managed buffer is killed
  (customize-set-variable 'eglot-autoshutdown t)

Project

  (setq project-switch-use-entire-map t
        project-switch-commands
        '((project-dired "Browse directory")
          (project-find-file "Find file")
          (project-find-regexp "Find regexp")
          (project-find-dir "Find directory")
          (project-eshell "Eshell")))

Version control

  (setq magit-clone-default-directory "~/Projects/")
  (use-package magit
    :ensure t)

`[5/7]` Completion

DONE Vertico

  (setq vertico-cycle t)
  (use-package vertico
    :ensure t
    :config
    (require 'vertico-directory)
    (vertico-mode +1))

DONE Marginalia

  (setq marginalia-annotators '(marginalia-annotators-heavy
                                marginalia-annotators-light
                                nil))
  (use-package marginalia
    :ensure t
    :config (marginalia-mode +1))

DONE Orderless

  (use-package orderless
    :ensure t
    :config (setq completion-styles '(orderless basic)
                  completion-category-overrides '((file (styles . (partial-completion))))))

TODO Corfu and Cape

  (setq corfu-cycle t
        corfu-auto t
        corfu-auto-prefix 3
        corfu-auto-delay 0.5)

  (use-package corfu
    :ensure t
    :config
    (global-corfu-mode +1)
    (when (require 'corfu-popupinfo nil :noerror)
      (corfu-popupinfo-mode 1)
      (eldoc-add-command #'corfu-insert)
      (keymap-set corfu-map "M-p" #'corfu-popupinfo-scroll-down)
      (keymap-set corfu-map "M-n" #'corfu-popupinfo-scroll-up)
      (keymap-set corfu-map "M-d" #'corfu-popupinfo-toggle)))

  (use-package cape
    :ensure t
    :config
    ;; Setup Cape for better completion-at-point support and more

    ;; Add useful defaults completion sources from cape
    (add-to-list 'completion-at-point-functions #'cape-file)
    (add-to-list 'completion-at-point-functions #'cape-dabbrev)

    ;; Silence the pcomplete capf, no errors or messages!
    ;; Important for corfu
    (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-silent)

    ;; Ensure that pcomplete does not write to the buffer
    ;; and behaves as a pure `completion-at-point-function'.
    (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-purify)

    ;; No auto-completion or completion-on-quit in eshell
    (defun crafted-completion-corfu-eshell ()
      "Special settings for when using corfu with eshell."
      (setq-local corfu-quit-at-boundary t
                  corfu-quit-no-match t
                  corfu-auto nil)
      (corfu-mode))
    (add-hook 'eshell-mode-hook #'crafted-completion-corfu-eshell))

DONE Consult

  (use-package consult
    :ensure t
    :bind (("C-s" . consult-line)
           ("<remap> <imenu>" . consult-imenu )
           ("<remap> <switch-to-buffer>" . consult-buffer)
           ("<remap> <project-switch-to-buffer>" . consult-project-buffer)
           ("C-c s s" . consult-line)
           ("C-c s f" . consult-fd)
           ("C-c s g" . consult-ripgrep)
           ("C-c s e" . consult-flymake)
           ("C-c s t" . consult-theme)
           :map minibuffer-local-map
           ("C-r" . consult-history)
           :map org-mode-map
           ("<remap> <org-goto>" . consult-org-heading))
    :config (setq completion-in-region-function #'consult-completion-in-region))

DONE Embark

  (use-package embark
    :ensure t
    :bind (("<remap> <describe-bindings>" . embark-bindings)
           ("C-." . embark-act))
    :config (setq prefix-help-command #'embark-prefix-help-command))

  (use-package embark-consult
    :ensure t
    :after (embark consult)
    :hook (embark-collect-mode . consult-preview-at-point-mode))

Internet

Email

  (setq sendmail-program (executable-find "msmtp")
        send-mail-function #'smtpmail-send-it
        message-sendmail-f-is-evil t
        message-sendmail-extra-arguments '("--read-envelope-from")
        message-send-mail-function #'message-send-mail-with-sendmail
        message-kill-buffer-on-exit t
        mail-user-agent 'mu4e-user-agent
        read-mail-command 'mu4e
        mu4e-split-view 'single-window
        mu4e-maildir "~/Mail"
        mu4e-attachment-dir "~/Downloads"
        mu4e-get-mail-command "mbsync -a"
        mu4e-update-interval (* 5 60) ; Every 5 minutes
        mu4e-sent-messages-behavior 'sent
        mu4e-change-filenames-when-moving t
        mu4e-context-policy 'pick-first
        mu4e-use-fancy-chars t
        mu4e-headers-thread-single-orphan-prefix '("─>" . "─▶")
        mu4e-headers-thread-orphan-prefix        '("┬>" . "┬▶")
        mu4e-headers-thread-connection-prefix    '("│ " . "│ ")
        mu4e-headers-thread-first-child-prefix   '("├>" . "├▶")
        mu4e-headers-thread-child-prefix         '("├>" . "├▶")
        mu4e-headers-thread-last-child-prefix    '("└>" . "╰▶")
        mu4e-modeline-all-read '("R:" . "󰑇 ")
        mu4e-modeline-all-clear '("C:" . "󰚭 ")
        mu4e-modeline-new-items '("N:" . "󰎔 ")
        mu4e-modeline-unread-items '("U:" . "󰶊 ")
        mu4e-search-full-label '("F" . "󱊖 ")
        mu4e-search-hide-label '("H" . "󰘓 ")
        mu4e-search-related-label '("R" . "󰌹 ")
        mu4e-search-skip-duplicates-label '("D" . "󰆑 ")
        mu4e-search-threaded-label'("T" . "󱇫 ")
        mu4e-alert-modeline-formatter 'mu4e-alert-default-mode-line-formatter
        mu4e-headers-fields '((:human-date . 12)
                              (:flags . 6)
                              (:from-or-to . 25)
                              (:subject))
        mu4e-headers-actions '(("org capture message" . mu4e-org-store-and-capture)
                               ("capture message" . mu4e-action-capture-message)
                               ("show this thread" . mu4e-action-show-thread))
        mu4e-maildir-shortcuts '((:maildir "/Proton/Inbox/" :key ?p)
                                 (:maildir "/iCloud/Inbox/" :key ?i)
                                 (:maildir "/Outlook/Inbox/" :key ?w)))

  (use-package mu4e
    :bind (("C-c m m" . mu4e)
           ("C-c m c" . mu4e-compose-new)
           ("C-c m s" . mu4e-search)
           ("C-c m b" . mu4e-search-bookmark)
           ("C-c m j" . mu4e-search-maildir))
    :config (setq mu4e-contexts
                  (list
                   (make-mu4e-context
                    :name "Xenia"
                    :vars '((user-mail-address . "evie@xenia.me.uk")
                            (mu4e-sent-folder . "/Proton/Sent")
                            (mu4e-drafts-folder . "/Proton/Drafts")
                            (mu4e-trash-folder . "/Proton/Trash")
                            (mu4e-refile-folder . "/Proton/Archive")))
                   (make-mu4e-context
                    :name "Proton"
                    :match-func (lambda (msg) (when msg (string-prefix-p "/Proton" (mu4e-message-field msg :maildir))))
                    :vars '((user-mail-address . "e.litherlandsmith@proton.me")
                            (mu4e-sent-folder . "/Proton/Sent")
                            (mu4e-drafts-folder . "/Proton/Drafts")
                            (mu4e-trash-folder . "/Proton/Trash")
                            (mu4e-refile-folder . "/Proton/Archive")))
                   (make-mu4e-context
                    :name "iCloud"
                    :match-func (lambda (msg) (when msg (string-prefix-p "/iCloud" (mu4e-message-field msg :maildir))))
                    :vars '((user-mail-address . "e.litherlandsmith@icloud.com")
                            (mu4e-sent-folder . "/iCloud/Sent Messages")
                            (mu4e-drafts-folder . "/iCloud/Drafts")
                            (mu4e-trash-folder . "/iCloud/Deleted Messages")
                            (mu4e-refile-folder . "/iCloud/Archive")))
                   (make-mu4e-context
                    :name "Work"
                    :match-func (lambda (msg) (when msg (string-prefix-p "/Outlook" (mu4e-message-field msg :maildir))))
                    :vars '((user-mail-address . "evie.litherland-smith@ukaea.uk")
                            (mu4e-sent-folder . "/Outlook/Sent")
                            (mu4e-drafts-folder . "/Outlook/Drafts")
                            (mu4e-trash-folder . "/Outlook/Trash")
                            (mu4e-refile-folder . "/Outlook/Archive"))))))

  (use-package mu4e-alert
    :after mu4e
    :config
    (mu4e-alert-set-default-style 'libnotify)
    (mu4e-alert-enable-notifications)
    (mu4e-alert-enable-mode-line-display))

Feeds

  (let ((elfeed-base-directory "~/.elfeed"))
    (setq elfeed-db-directory (expand-file-name "db" elfeed-base-directory)
          elfeed-enclosure-default-dir (expand-file-name "enclosures" elfeed-base-directory)
          rmh-elfeed-org-files (list (expand-file-name "feeds.org" elfeed-base-directory))))

  (use-package elfeed
    :bind (("C-c f f" . elfeed)
           ("C-c f u" . elfeed-update))
    :hook (elfeed-search-mode . elfeed-update)
    :config
    (use-package elfeed-org
      :ensure t
      :config (elfeed-org))
    (use-package elfeed-tube
      :ensure t
      :config (elfeed-tube-setup)))

Social

  (setq mastodon-instance-url "https://tech.lgbt"
        mastodon-active-user "Tux922")
  (use-package mastodon
    :commands mastodon)

  (use-package ement
    :commands ement-connect)

TODO Media

  (when (require 'emms-setup nil :noerror)
    (setq emms-player-list '(emms-player-mpv)
          emms-info-functions '(emms-info-native)
          emms-source-file-default-directory "~/Music"
          emms-lyrics-dir "~/Music/lyrics"
          emms-mode-line-icon-color "white")

    (emms-all)
    (add-hook 'emms-player-started-hook #'emms-show)
    (add-hook 'emms-player-paused-hook #'emms-show)

    (when (require 'hydra nil :noerror)
      (defhydra emms (global-map "C-c e")
        "emms"
        ("b" emms-smart-browse)
        ("d" emms-show)
        ("s" emms-start)
        ("S" emms-stop)
        ("n" emms-next)
        ("p" emms-previous)
        ("P" emms-pause))))

TODO Writing

  ;;; Whitespace
  (defun crafted-writing-configure-whitespace (use-tabs &optional use-globally &rest enabled-modes)
    "Helper function to configure `whitespace' mode.

  Enable using TAB characters if USE-TABS is non-nil.  If
  USE-GLOBALLY is non-nil, turn on `global-whitespace-mode'.  If
  ENABLED-MODES is non-nil, it will be a list of modes to activate
  whitespace mode using hooks.  The hooks will be the name of the
  mode in the list with `-hook' appended.  If USE-GLOBALLY is
  non-nil, ENABLED-MODES is ignored.

  Configuring whitespace mode is not buffer local.  So calling this
  function twice with different settings will not do what you
  think.  For example, if you wanted to use spaces instead of tabs
  globally except for in Makefiles, doing the following won't work:

  ;; turns on global-whitespace-mode to use spaces instead of tabs
  (crafted-writing-configure-whitespace nil t)

  ;; overwrites the above to turn to use tabs instead of spaces,
  ;; does not turn off global-whitespace-mode, adds a hook to
  ;; makefile-mode-hook
  (crafted-writing-configure-whitespace t nil 'makefile-mode)

  Instead, use a configuration like this:
  ;; turns on global-whitespace-mode to use spaces instead of tabs
  (crafted-writing-configure-whitespace nil t)

  ;; turn on the buffer-local mode for using tabs instead of spaces.
  (add-hook 'makefile-mode-hook #'indent-tabs-mode)

  For more information on `indent-tabs-mode', See the info
  node `(emacs)Just Spaces'

  Example usage:

  ;; Configuring whitespace mode does not turn on whitespace mode
  ;; since we don't know which modes to turn it on for.
  ;; You will need to do that in your configuration by adding
  ;; whitespace mode to the appropriate mode hooks.
  (crafted-writing-configure-whitespace nil)

  ;; Configure whitespace mode, but turn it on globally.
  (crafted-writing-configure-whitespace nil t)

  ;; Configure whitespace mode and turn it on only for prog-mode
  ;; and derived modes.
  (crafted-writing-configure-whitespace nil nil 'prog-mode)"
    (if use-tabs
        (customize-set-variable 'whitespace-style
                                '(face empty trailing indentation::tab
                                       space-after-tab::tab
                                       space-before-tab::tab))
      ;; use spaces instead of tabs
      (customize-set-variable 'whitespace-style
                              '(face empty trailing tab-mark
                                     indentation::space)))

    (if use-globally
        (global-whitespace-mode 1)
      (when enabled-modes
        (dolist (mode enabled-modes)
          (add-hook (intern (format "%s-hook" mode)) #'whitespace-mode))))

    ;; cleanup whitespace
    (customize-set-variable 'whitespace-action '(cleanup auto-cleanup)))

  ;;; parentheses
  (electric-pair-mode 1) ; auto-insert matching bracket
  (show-paren-mode 1)    ; turn on paren match highlighting

  ;;; LaTeX configuration
  (with-eval-after-load 'latex
    (customize-set-variable 'TeX-auto-save t)
    (customize-set-variable 'TeX-parse-self t)
    (setq-default TeX-master nil)

    ;; compile to pdf
    (tex-pdf-mode)

    ;; correlate the source and the output
    (TeX-source-correlate-mode)

    ;; set a correct indentation in a few additional environments
    (add-to-list 'LaTeX-indent-environment-list '("lstlisting" current-indentation))
    (add-to-list 'LaTeX-indent-environment-list '("tikzcd" LaTeX-indent-tabular))
    (add-to-list 'LaTeX-indent-environment-list '("tikzpicture" current-indentation))

    ;; add a few macros and environment as verbatim
    (add-to-list 'LaTeX-verbatim-environments "lstlisting")
    (add-to-list 'LaTeX-verbatim-environments "Verbatim")
    (add-to-list 'LaTeX-verbatim-macros-with-braces "lstinline")
    (add-to-list 'LaTeX-verbatim-macros-with-delims "lstinline")

    ;; electric pairs in auctex
    (customize-set-variable 'TeX-electric-sub-and-superscript t)
    (customize-set-variable 'LaTeX-electric-left-right-brace t)
    (customize-set-variable 'TeX-electric-math (cons "$" "$"))

    ;; open all buffers with the math mode and auto-fill mode
    (add-hook 'LaTeX-mode-hook #'auto-fill-mode)
    (add-hook 'LaTeX-mode-hook #'LaTeX-math-mode)

    ;; add support for references
    (add-hook 'LaTeX-mode-hook #'turn-on-reftex)
    (customize-set-variable 'reftex-plug-into-AUCTeX t)

    ;; to have the buffer refresh after compilation
    (add-hook 'TeX-after-compilation-finished-functions #'TeX-revert-document-buffer))

  (defun crafted-latex-use-pdf-tools ()
    "Use PDF Tools instead of docview, requires a build environment
  to compile PDF Tools.

  Depends on having `pdf-tools'."

    (with-eval-after-load 'latex
      (customize-set-variable 'TeX-view-program-selection '((output-pdf "PDF Tools")))
      (customize-set-variable 'TeX-view-program-list '(("PDF Tools" TeX-pdf-tools-sync-view)))
      (customize-set-variable 'TeX-source-correlate-start-server t)))

  ;; message the user if the latex executable is not found
  (defun crafted-writing-tex-warning-if-no-latex-executable ()
    "Print a message to the minibuffer if the \"latex\" executable cannot be found."
    (unless (executable-find "latex")
      (message "latex executable not found")))
  (add-hook 'tex-mode-hook #'crafted-writing-tex-warning-if-no-latex-executable)

  (when (and (executable-find "latex")
             (executable-find "latexmk"))
    (with-eval-after-load 'latex
      (when (require 'auctex-latexmk nil 'noerror)
        (with-eval-after-load 'auctex-latexmk
          (auctex-latexmk-setup)
          (customize-set-variable 'auctex-latexmk-inherit-TeX-PDF-mode t))

        (defun crafted-writing-tex-make-latexmk-default-command ()
          "Set `TeX-command-default' to \"LatexMk\"."
          (setq TeX-command-default "LatexMk"))
        (add-hook 'TeX-mode-hook #'crafted-writing-tex-make-latexmk-default-command))))

  ;;; Markdown
  (when (fboundp 'markdown-mode)
    ;; because the markdown-command variable may not be loaded (yet),
    ;; check manually for the other markdown processors.  If it is
    ;; loaded, the others are superfluous but `or' fails fast, so they
    ;; are not checked if `markdown-command' is set and the command is
    ;; indeed found.
    (unless (or (and (boundp 'markdown-command)
                     (executable-find markdown-command))
                (executable-find "markdown")
                (executable-find "pandoc"))
      (message "No markdown processor found, preview may not possible."))

    (with-eval-after-load 'markdown-mode
      (customize-set-variable 'markdown-enable-math t)
      (customize-set-variable 'markdown-enable-html t)
      (add-hook 'markdown-mode-hook #'conditionally-turn-on-pandoc)))

  ;;; PDF Support when using pdf-tools
  (when (locate-library "pdf-tools")
    ;; load pdf-tools when going into doc-view-mode
    (defun crafted-writing-load-pdf-tools ()
      "Attempts to require pdf-tools, but for attaching to hooks."
      (require 'pdf-tools nil :noerror))
    (add-hook 'doc-view-mode-hook #'crafted-writing-load-pdf-tools)

    ;; when pdf-tools is loaded, apply settings.
    (with-eval-after-load 'pdf-tools
      (setq-default pdf-view-display-size 'fit-width)))

36 KiB Raw Blame History

Emacs Config

Common defaults

package-archive with priorities

Authentication

Helpful

Link hint keymaps

UI

Theme, font and nerd-icons

Font ligatures

Modeline

Dashboard

Org-mode

Keymaps

org-agenda

org-journal

Capture templates

Citar

Khalel

TODO Crafted config

Development Environment

Eglot LSP

Project

Version control

[5/7] Completion

DONE Vertico

DONE Marginalia

DONE Orderless

TODO Corfu and Cape

DONE Consult

DONE Embark

Internet

Email

Feeds

Social

TODO Media

TODO Writing

36 KiB

Raw Blame History

`[5/7]` Completion