-*- eval: (add-hook 'after-save-hook 'org-babel-tangle 0 t) -*- #+PROPERTY: header-args :results silent #+PROPERTY: header-args:emacs-lisp :lexical t :tangle ~/.emacs.el This is a literate init file holding my Emacs configuration. It is initially loaded by a [[file:.emacs.d/init.el::;;; -*- lexical-binding: t; -*-][bootstrap file]] that lives at ~/.emacs.d/init.el; after the initial bootstrapping it writes itself to ~/.emacs.el. Since ~/.emacs.el takes priority over ~/.emacs.d/init.el, after the initial bootstrapping process the tangled ~/.emacs.el file will get loaded without needing to load the bootstrap file first. * Prelude Enables lexical binding for everything in init.el: #+BEGIN_SRC emacs-lisp ;;; -*- lexical-binding: t; -*- #+END_SRC ** Garbage collection Some GC tweaks [[https://github.com/hlissner/doom-emacs/blob/develop/docs/faq.org#how-does-doom-start-up-so-quickly]["borrowed" from Doom emacs]]. Turn off GC during init and restore it afterwards: #+BEGIN_SRC emacs-lisp (setq gc-cons-threshold most-positive-fixnum gc-cons-percentage 0.6) (add-hook 'emacs-startup-hook (lambda () (setq gc-cons-threshold 100000000 gc-cons-percentage 0.1))) #+END_SRC Also suppress GC for 1 second after the minibuffer is active to avoid stuttering autocompletion and other GC hangups: #+BEGIN_SRC emacs-lisp (defun defer-garbage-collection () (setq gc-cons-threshold most-positive-fixnum)) (defun restore-garbage-collection () (run-at-time 1 nil (lambda () (setq gc-cons-threshold 100000000)))) (add-hook 'minibuffer-setup-hook #'defer-garbage-collection) (add-hook 'minibuffer-exit-hook #'restore-garbage-collection) #+END_SRC ** Unset file-handler-alist during initialization Another optimization from [[https://github.com/hlissner/doom-emacs/blob/develop/docs/faq.org#how-does-doom-start-up-so-quickly][Doom Emacs]]. #+BEGIN_SRC emacs-lisp (defvar file-name-handler-alist-backup file-name-handler-alist) (setq file-name-handler-alist nil) (add-hook 'emacs-startup-hook (lambda () (setq file-name-handler-alist file-name-handler-alist-backup))) #+END_SRC ** Variables #+BEGIN_SRC emacs-lisp (setq vc-follow-symlinks t frame-resize-pixelwise t tab-always-indent 'complete enable-recursive-minibuffers t read-process-output-max (* 1024 1024)) (setq-default indent-tabs-mode nil) #+END_SRC * Default directory #+BEGIN_SRC emacs-lisp (cd "~") #+END_SRC * Packages Load [[https://github.com/raxod502/straight.el][straight.el]] to manage package installation: #+BEGIN_SRC emacs-lisp (defvar bootstrap-version) (unless (boundp 'bootstrapping-init) (let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory)) (bootstrap-version 5)) (unless (file-exists-p bootstrap-file) (with-current-buffer (url-retrieve-synchronously "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el" 'silent 'inhibit-cookies) (goto-char (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))) #+END_SRC `use-package` is a macro that simplifies installing and loading packages. #+BEGIN_SRC emacs-lisp (straight-use-package 'use-package) (setq straight-use-package-by-default t) #+END_SRC * Benchmarking `benchmark-init` does what it says on the box. This sets it up to benchmark my init time and then disable benchmarking after init completes. #+BEGIN_SRC emacs-lisp (use-package benchmark-init :config (add-hook 'after-init-hook 'benchmark-init/deactivate)) #+END_SRC * Load org mode Load org-mode early to [[https://github.com/raxod502/straight.el#the-wrong-version-of-my-package-was-loaded][avoid a version clash]]. #+BEGIN_SRC emacs-lisp (use-package org :straight org-plus-contrib :commands (org-element-map) :mode (("\\.org\\'" . org-mode))) ;; Annoying that this is necessary... (require 'org) (require 'org-refile) (require 'org-protocol) #+END_SRC * Doom themes #+BEGIN_SRC emacs-lisp (use-package doom-themes) (use-package doom-modeline) (doom-modeline-mode 1) #+END_SRC * Ewal theme #+BEGIN_SRC emacs-lisp (use-package doom-ewal-themes :straight (doom-ewal-themes :host github :repo "jdormit/doom-ewal-themes" :files ("themes" :defaults))) #+END_SRC * Customization File I don't want anything to write to my init.el, so save customizations in a separate file: #+BEGIN_SRC emacs-lisp (setq custom-file (expand-file-name "custom.el" user-emacs-directory)) (load custom-file t) #+END_SRC * Path `exec-path-from-shell` uses Bash to set MANPATH, PATH, and exec-path from those defined in the user's shell config. This won't work on Windows. #+BEGIN_SRC emacs-lisp (use-package exec-path-from-shell :if (memq window-system '(mac ns x)) :config (setq exec-path-from-shell-variables '("PATH" "MANPATH" "LEDGER_FILE" "LOLA_HOME" "MODELS_HOME" "LOLA_TRAVEL_SERVICE_HOME" "WORKON_HOME" "PIPENV_VERBOSITY" "PIPENV_DONT_LOAD_ENV" "PIPENV_MAX_DEPTH" "PYENV_ROOT") exec-path-from-shell-check-startup-files nil) (exec-path-from-shell-initialize)) #+END_SRC * General Better keybinding. #+BEGIN_SRC emacs-lisp (use-package general :init (setq general-override-states '(insert emacs hybrid normal visual motion operator replace))) #+END_SRC Delete trailing whitespace on save: #+BEGIN_SRC emacs-lisp (defvar *should-delete-trailing-whitespace* t) (defun delete-trailing-whitespace-hook-fn () (when *should-delete-trailing-whitespace* (delete-trailing-whitespace))) (add-hook 'before-save-hook #'delete-trailing-whitespace-hook-fn) #+END_SRC * Autocompletion There seems to be [[https://github.com/company-mode/company-mode/issues/68][some contention]] about whether autocomplete or company are better autocomplete packages. I'm going with company for now because the maintainer seems nicer... #+BEGIN_SRC emacs-lisp (use-package company :config (setq company-idle-delay 0.3) (add-hook 'after-init-hook #'global-company-mode)) (general-def "C-M-i" #'company-complete) (general-def "M-" #'company-complete) #+END_SRC * Which-key `which-key` makes keybindings discoverable. #+BEGIN_SRC emacs-lisp (use-package which-key :config (which-key-mode)) #+END_SRC This function defines a prefix group for `which-key` so that it doesn't display `prefix`. #+BEGIN_SRC emacs-lisp (defun jdormit/define-prefix (binding name) (which-key-add-key-based-replacements (concat leader " " binding) name) (which-key-add-key-based-replacements (concat "," " " binding) name)) #+END_SRC * Evil Mode Because I like modal editing and dislike RSI. #+BEGIN_SRC emacs-lisp (use-package evil :init (setq evil-want-keybinding nil) :config (evil-mode 1)) #+END_SRC Make undo not undo paragraphs at a time: #+BEGIN_SRC emacs-lisp (setq evil-want-fine-undo t) #+END_SRC Add a convenience function for making buffer-local ex-commands: #+BEGIN_SRC emacs-lisp (defun evil-ex-define-local-cmd (cmd function) (set (make-local-variable 'evil-ex-commands) (copy-tree evil-ex-commands)) (evil-ex-define-cmd cmd function)) #+END_SRC ** evil-collection A collection of evil bindings for various modes #+BEGIN_SRC emacs-lisp (use-package evil-collection :after (evil) :config (setq evil-collection-company-use-tng nil) (evil-collection-init)) #+END_SRC ** leader key Use the spacebar as a leader key in evil-mode's normal state and in various other modes: #+BEGIN_SRC emacs-lisp (defconst leader "SPC") (general-define-key :keymaps 'override :states '(normal visual motion) "SPC" nil) (general-create-definer leader-def-key :keymaps 'override :states '(normal visual motion) :prefix leader :prefix-map 'leader-map) #+END_SRC #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "?" "help") (leader-def-key "?" help-map) #+END_SRC ** evil-snipe #+BEGIN_SRC emacs-lisp (use-package evil-snipe :after (evil) :config (evil-snipe-mode 1) (evil-snipe-override-mode 1) (add-to-list 'evil-snipe-disabled-modes 'dired-mode) (add-to-list 'evil-snipe-disabled-modes 'structlog-mode) (with-eval-after-load 'magit (add-hook 'magit-mode-hook 'turn-off-evil-snipe-override-mode)) (with-eval-after-load 'prodigy (add-hook 'prodigy-mode-hook 'turn-off-evil-snipe-mode)) (with-eval-after-load 'pass (add-hook 'pass-mode-hook 'turn-off-evil-snipe-mode))) #+END_SRC ** evil-commentary Adds Evil commands to comment out lines of code: #+BEGIN_SRC emacs-lisp (use-package evil-commentary :after (evil) :hook ((prog-mode . evil-commentary-mode))) #+END_SRC ** Additional keybindings #+BEGIN_SRC emacs-lisp (general-def 'normal "zM" #'hs-hide-level :keymaps 'override) (general-def 'normal "z=" #'text-scale-increase :keymaps 'override) (general-def 'normal "z-" #'text-scale-decrease :keymaps 'override) (general-def 'normal "z0" #'text-scale-adjust :keymaps 'override) (general-def 'normal view-mode-map "0" nil :keymaps 'override) (general-def 'normal prodigy-view-mode-map "0" nil :keymaps 'override) (general-def 'normal messages-buffer-mode-map "SPC" leader-map :keymaps 'override) #+END_SRC * Multiple cursors #+BEGIN_SRC emacs-lisp (use-package evil-mc :defer 0 :config (global-evil-mc-mode) (general-def '(normal visual) "gs" evil-mc-cursors-map "M-n" #'evil-mc-make-and-goto-next-cursor "M-p" #'evil-mc-make-and-goto-prev-cursor "C-n" #'evil-mc-make-and-goto-next-match "C-t" #'evil-mc-skip-and-goto-next-match "C-p" #'evil-mc-make-and-goto-prev-match)) #+END_SRC #+BEGIN_SRC emacs-lisp (use-package evil-multiedit :defer 0 :config (evil-multiedit-default-keybinds)) #+END_SRC * Transient A framework for creating Magit-style popups: #+BEGIN_SRC emacs-lisp (use-package transient :commands (define-transient-command)) #+END_SRC * Hydra [[https://github.com/abo-abo/hydra][Hydra]]s are convenient keybinding menus. #+BEGIN_SRC emacs-lisp (use-package hydra :defer t) #+END_SRC * Magit Magit is objectively the best Git interface. #+BEGIN_SRC emacs-lisp (use-package magit :commands (magit-status magit-blame magit-find-file magit-name-local-branch)) #+END_SRC #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "g" "git") (leader-def-key "gs" #'magit-status) (leader-def-key "gg" #'magit-file-dispatch) (leader-def-key "gf" #'magit-find-file) #+END_SRC Use ido-mode for completion within Magit: #+BEGIN_SRC emacs-lisp ;; (setq magit-completing-read-function 'magit-ido-completing-read) #+END_SRC ** Forge [[https://github.com/magit/forge][Forge]] is an extension for Magit that lets it interact with code forges (e.g. GitHub). #+BEGIN_SRC emacs-lisp (use-package forge :after (magit) :config (add-to-list 'forge-alist '("git.jeremydormitzer.com" "git.jeremydormitzer.com/api/v1" "git.jeremydormitzer.com" forge-gitea-repository)) (with-eval-after-load 'evil-magit (general-def '(normal motion) magit-mode-map "yu" #'forge-copy-url-at-point-as-kill)) :general ((normal motion visual) forge-topic-list-mode-map "y" #'forge-copy-url-at-point-as-kill "q" #'quit-window) :custom (forge-owned-accounts '((jdormit . (remote-name "jdormit"))))) #+END_SRC ** evil-magit Evil keybindings for magit! #+BEGIN_SRC emacs-lisp (use-package evil-magit :after (evil magit) :config (with-eval-after-load 'magit (require 'evil-magit)) :general ('normal magit-mode-map "SPC" leader-map)) #+END_SRC ** Transient #+BEGIN_SRC emacs-lisp (setq transient-default-level 7) #+END_SRC * git-link Open files in Git forges (GitHub, GitLab, etc.): #+BEGIN_SRC emacs-lisp (use-package git-link :init (defun git-link-copy () (interactive) (let ((git-link-open-in-browser nil)) (call-interactively 'git-link))) (leader-def-key "gl" #'git-link) (leader-def-key "gy" #'git-link-copy) :custom (git-link-open-in-browser t) (git-link-remote-alist '(("git.sr.ht" git-link-sourcehut) ("github" git-link-github) ("bitbucket" git-link-bitbucket) ("gitorious" git-link-gitorious) ("gitlab" git-link-gitlab) ("visualstudio\\|azure" git-link-azure) ("git.jeremydormitzer.com" git-link-bitbucket)))) #+END_SRC * with-editor A utility from the author of Magit to run shell commands using the current Emacs instance as $EDITOR. #+BEGIN_SRC emacs-lisp (shell-command-with-editor-mode) (add-hook 'shell-mode-hook #'with-editor-export-editor) (add-hook 'term-exec-hook #'with-editor-export-editor) (add-hook 'eshell-mode-hook #'with-editor-export-editor) #+END_SRC * Password Store Interfacing with Pass, the "standard Unix password manager". This should also be loaded before `exec-path-from-shell`. #+BEGIN_SRC emacs-lisp (defun password-store-synchronize () (interactive) (with-editor-async-shell-command "pass git pull && pass git push")) (use-package password-store :defer t :if (executable-find "pass") :config (setq password-store-password-length 20) :init (leader-def-key "P" 'password-store-copy) (epa-file-enable)) (use-package pass :if (executable-find "pass") :commands pass :general ('(normal motion visual) pass-mode-map "S" #'password-store-synchronize)) (leader-def-key "ap" #'pass) (setq auth-sources '("~/.authinfo" password-store)) #+END_SRC * Emacs Lisp ** Packages Some helpful ELisp packages: - [[https://github.com/kiwanami/emacs-deferred][deferred]] is an async API library - [[https://github.com/magnars/s.el][s.el]] is a string manipulation library - [[https://github.com/magnars/dash.el][dash.el]] is a list manipulation library - [[https://github.com/rejeep/f.el][f.el]] is a file manipulation library - [[https://github.com/tkf/emacs-request][request]] is an HTTP library #+BEGIN_SRC emacs-lisp (use-package deferred :commands (deferred:next deferred:nextc deferred:error deferred:cancel deferred:watch deferred:wait deferred:$ deferred:loop deferred:parallel deferred:earlier deferred:call deferred:apply deferred:process deferred:process-buffer deferred:wait-idle deferred:url-retrieve deferred:url-get deferred:url-post deferred:new deferred:succeed deferred:fail deferred:callback deferred:callback-post deferred:errorback deferred:errorback-post deferred:try deferred:timeout deferred:process)) (use-package s :defer t :init (add-hook 'emacs-startup-hook (lambda () (require 's))) :config (defun camel-case (&optional arg) (interactive "P") (let* ((bounds (bounds-of-thing-at-point 'symbol)) (word (buffer-substring (car bounds) (cdr bounds))) (camel (if arg (s-upper-camel-case word) (s-lower-camel-case word)))) (delete-region (car bounds) (cdr bounds)) (insert camel)))) (use-package dash :defer t :init (add-hook 'emacs-startup-hook (lambda () (require 'dash)))) (use-package dash-functional :defer t :init (add-hook 'emacs-startup-hook (lambda () (require 'dash-functional)))) (use-package f :defer t :init (add-hook 'emacs-startup-hook (lambda () (require 'f)))) (use-package request :commands (request request-deferred)) #+END_SRC ** Editing Elisp #+BEGIN_SRC emacs-lisp (general-def '(normal motion) emacs-lisp-mode-map "C-c C-c" #'eval-defun :keymaps 'override) (general-def '(normal motion insert) lisp-interaction-mode-map "C-c C-c" #'eval-print-last-sexp :keymaps 'override) (add-hook 'ielm-mode-hook 'smartparens-strict-mode) #+END_SRC ** Load path For machine or user specific libraries: #+BEGIN_SRC emacs-lisp (add-to-list 'load-path (expand-file-name "~/site-lisp")) #+END_SRC And for global ones: #+BEGIN_SRC emacs-lisp (add-to-list 'load-path "/usr/local/share/emacs/site-lisp") #+END_SRC ** Utilities Reading a file as a string: #+BEGIN_SRC emacs-lisp (defun read-file (path) "Returns the contents of the file as a string" (with-temp-buffer (insert-file-contents path) (buffer-string))) #+END_SRC Opening a file as sudo: #+BEGIN_SRC emacs-lisp (defun sudo-find-file (file-name) "Like find file, but opens the file as root." (interactive "F") (let ((tramp-file-name (concat "/sudo::" (expand-file-name file-name)))) (find-file tramp-file-name))) #+END_SRC Recursive =assoc= for nested alists: #+BEGIN_SRC emacs-lisp (defun assoc-recursive (alist &rest keys) "Recursively find KEYs in ALIST." (while keys (setq alist (cdr (assoc (pop keys) alist)))) alist) #+END_SRC Format a millis timestamp into human-readable form: #+BEGIN_SRC emacs-lisp (defun format-epoch-millis (millis) (interactive "nTimestamp: ") (message (format-time-string "%F %r" (/ millis 1000)))) #+END_SRC The same but for seconds: #+BEGIN_SRC emacs-lisp (defun format-epoch-seconds (seconds) (interactive "nTimestamp: ") (message (format-time-string "%F %r" seconds))) #+END_SRC Checking if a buffer contains a string: #+BEGIN_SRC emacs-lisp (defun buffer-contains-substring (string) (save-excursion (save-match-data (goto-char (point-min)) (search-forward string nil t)))) #+END_SRC Pretty-print JSON: #+BEGIN_SRC emacs-lisp (defun pprint-json (raw-json) (with-temp-buffer (insert raw-json) (json-pretty-print (point-min) (point-max)) (buffer-substring (point-min) (point-max)))) #+END_SRC Load environment variables into Emacs from a shell script: #+BEGIN_SRC emacs-lisp (cl-defun extract-vars-from-env-file (file &key dir) "Extracts an alist of variable name to value from a bash script that exports environment variables." (let ((file (expand-file-name file)) (var-re "\\(.+?\\)=\\(.+\\)$") (env '())) (with-temp-buffer (cd (expand-file-name (or dir (file-name-directory file)))) (insert (shell-command-to-string (concat "source " (shell-quote-argument file) " > /dev/null && env"))) (goto-char (point-min)) (save-match-data (while (re-search-forward var-re nil t) (push (cons (match-string 1) (match-string 2)) env)))) env)) (defun source-env-file (file) (interactive "fFile: \n") (let ((env (extract-vars-from-env-file file))) (dolist (binding env) (setenv (car binding) (cdr binding))))) (cl-defmacro with-env-from-file (file &rest body) (declare (indent 1)) (let ((env-var (make-symbol "the-env")) (path-var (make-symbol "the-path"))) `(let* ((,env-var (extract-vars-from-env-file ,file)) (,path-var (assoc "PATH" ,env-var)) (exec-path (if ,path-var (append (split-string (cdr ,path-var) ":") exec-path) exec-path)) (process-environment (append (mapcar (lambda (elt) (format "%s=%s" (car elt) (cdr elt))) ,env-var) process-environment))) ,@body))) (cl-defun call-with-env-from-file (file callback &key dir) (let* ((env (extract-vars-from-env-file file :dir dir)) (path (assoc "PATH" env)) (exec-path (if path (append (split-string (cdr path) ":") exec-path) exec-path)) (process-environment (append (mapcar (lambda (elt) (format "%s=%s" (car elt) (cdr elt))) env) process-environment))) (funcall callback))) (defmacro with-env (env &rest body) (declare (indent 1)) `(let* ((process-environment (append (mapcar (lambda (elt) (format "%s=%s" (car elt) (cdr elt))) ,env) process-environment))) ,@body)) #+END_SRC Convenience macro to run some code in a particular default-directory: #+BEGIN_SRC emacs-lisp (defmacro with-default-directory (dir &rest body) (declare (indent 1)) `(let ((default-directory ,dir)) ,@body)) #+END_SRC #+BEGIN_SRC emacs-lisp (defun random-alnum (&optional n) (let* ((n-chars (or n 1)) (alnum "abcdefghijklmnopqrstuvwxyz0123456789") (result "")) (dotimes (_ n-chars result) (let ((i (% (abs (random)) (length alnum)))) (setq result (concat result (substring alnum i (1+ i)))))))) #+END_SRC A handy function to colorize a buffer with ANSI escape characters in it: #+BEGIN_SRC emacs-lisp (defun ansi-color (&optional begin end) (interactive) (let ((begin (or begin (point-min))) (end (or end (point-max))) (inhibit-read-only t)) (ansi-color-apply-on-region begin end))) #+END_SRC ** Persisting variables between session The idea behind this is pretty simple - variables get persisted in ~/.emacs.d/ as a plist of (variable-name variable-value). #+BEGIN_SRC emacs-lisp (defvar persisted-vars-file "~/.emacs.d/persisted-vars") #+END_SRC This function retrieves the plist of persisted variables or nil if it doesn't exist: #+BEGIN_SRC emacs-lisp (defun get-persisted-plist () (let ((file (expand-file-name persisted-vars-file))) (when (file-exists-p file) (let ((vars-plist-str (read-file file))) (unless (string= vars-plist-str "") (car (read-from-string vars-plist-str))))))) #+END_SRC This function retrieves a persisted variable: #+BEGIN_SRC emacs-lisp (defun get-persisted-var (var-name) "Retrieves the value of persisted variable `var-name`, or nil if not found" (let ((vars-plist (get-persisted-plist))) (when vars-plist (plist-get vars-plist var-name)))) #+END_SRC And this function persists a variable: #+BEGIN_SRC emacs-lisp (defun persist-variable (var-name value) (let ((file (expand-file-name persisted-vars-file)) (vars-plist (get-persisted-plist))) (if vars-plist (progn (plist-put vars-plist var-name value) (write-region (prin1-to-string vars-plist) nil file)) (let ((vars-plist `(,var-name ,value))) (write-region (prin1-to-string vars-plist) nil file))))) #+END_SRC ** Process handling Some utilities for calling out to other processes. #+BEGIN_SRC emacs-lisp (defun make-process-sentinel (success err) "Makes a process sentinel that calls `success` on success and `err` on error" (lambda (proc event) (cond ((string-match-p "finished" event) (funcall success)) (t (funcall err))))) (defun make-success-err-msg-sentinel (buf success-msg err-msg &optional kill-on-err) (make-process-sentinel (lambda () (message success-msg) (kill-buffer buf)) (lambda () (message err-msg) (when kill-on-err (kill-buffer buf))))) #+END_SRC A function to call a process passing some string as stdin and returning the process output: #+BEGIN_SRC emacs-lisp (defun make-process-fn (program &rest args) "Returns a function that, when called, call `program` with arguments `args`, passing the function argument as stdin" (lambda (&optional input) (with-temp-buffer (if input (progn (insert input) (apply #'call-process-region (point-min) (point-max) program t t nil args)) (apply #'call-process program nil t nil args)) (buffer-substring-no-properties (point-min) (point-max))))) #+END_SRC The same function but for commands that need to run in a shell: #+BEGIN_SRC emacs-lisp (defun make-shell-fn (program &rest args) "Returns a function that, when called, calls `program` in a shell with arguments `args`, passing the function argument as stdin" (lambda (&optional input) (let ((cmd (combine-and-quote-strings `(,program ,@args)))) (with-temp-buffer (if input (progn (insert input) (call-shell-region (point-min) (point-max) cmd t t)) (call-process-shell-command cmd nil t)) (buffer-substring-no-properties (point-min) (point-max)))))) #+END_SRC Running a shell command as sudo: #+BEGIN_SRC emacs-lisp (defun sudo-shell-command (command) (with-temp-buffer (cd "/sudo::/") (shell-command command))) #+END_SRC ** Buffer switch hooks I want to be able to run code whenever I switch to a buffer running certain modes. The code to run is stored in a alist mapping mode names to lists of code to run (stored as a raw data structure to be eval'ed): #+BEGIN_SRC emacs-lisp (defvar buffer-mode-hooks '()) #+END_SRC To add a new hook, push the code to run onto the correct list: #+BEGIN_SRC emacs-lisp (defun add-buffer-mode-hook (mode fn) (if-let ((existing-entry (assoc mode buffer-mode-hooks))) (push fn (cdr existing-entry)) (let ((new-entry `(,mode . (,fn)))) (push new-entry buffer-mode-hooks)))) #+END_SRC Whenever the buffer changes, look up the major-mode to see if there is any code to run: #+BEGIN_SRC emacs-lisp (defun run-buffer-mode-hooks () (when-let ((entry (assoc major-mode buffer-mode-hooks))) (dolist (fn (cdr entry)) (funcall fn)))) (add-hook 'buffer-list-update-hook #'run-buffer-mode-hooks) #+END_SRC ** Aliases #+BEGIN_SRC emacs-lisp (defalias 'doc 'describe-symbol) #+END_SRC ** Miscellaneous #+BEGIN_SRC emacs-lisp (setq warning-suppress-types '((undo discard-info))) #+END_SRC * Dropbox I put lots of stuff in Dropbox, but the actual folder location differs on my different computers. This function resolves to the Dropbox directory: #+BEGIN_SRC emacs-lisp (defun get-dropbox-directory () (cond ((file-exists-p (expand-file-name "~/Dropbox (Personal)")) (expand-file-name "~/Dropbox (Personal)")) (t (expand-file-name "~/Dropbox")))) #+END_SRC Load up libraries from Dropbox, if there are any: #+BEGIN_SRC emacs-lisp (add-to-list 'load-path (concat (file-name-as-directory (get-dropbox-directory)) "site-lisp")) #+END_SRC * Init File A function to reload my init file. It reloads the major mode after the init file is loaded to rebind keymappings. #+BEGIN_SRC emacs-lisp (defun reload-init-file () (interactive) (load-file "~/.emacs.el") (funcall major-mode)) #+END_SRC And another one to edit it: #+BEGIN_SRC emacs-lisp (defun find-init-file () (interactive) (find-file "~/init.org")) #+END_SRC * Keybindings These are general keybindings; those specific to certain packages are in the sections for those packages. In some modes I want vanilla Emacs bindings: #+BEGIN_SRC emacs-lisp (with-eval-after-load 'evil (add-to-list 'evil-emacs-state-modes 'benchmark-init/tabulated-mode) (add-to-list 'evil-emacs-state-modes 'benchmark-init/tree-mode) (add-to-list 'evil-emacs-state-modes 'cider-stacktrace-mode) (add-to-list 'evil-emacs-state-modes 'geiser-debug-mode) (add-to-list 'evil-emacs-state-modes 'undo-tree-visualizer-mode) (add-to-list 'evil-emacs-state-modes 'makey-key-mode) (add-to-list 'evil-emacs-state-modes 'term-mode)) #+END_SRC ** Visual line navigation #+BEGIN_SRC emacs-lisp (general-def 'motion "j" #'evil-next-visual-line) (general-def 'motion "k" #'evil-previous-visual-line) (general-def 'motion "j" #'evil-next-visual-line) (general-def 'motion "k" #'evil-previous-visual-line) #+END_SRC ** M-x #+BEGIN_SRC emacs-lisp (leader-def-key "SPC" 'execute-extended-command) #+END_SRC ** Eval-ing #+BEGIN_SRC emacs-lisp (leader-def-key ":" #'eval-expression) #+END_SRC ** Init file commands #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "." "dotfile") (leader-def-key ".r" 'reload-init-file) (leader-def-key ".f" 'find-init-file) #+END_SRC ** Commands about files #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "f" "files") (leader-def-key "ff" 'find-file) (leader-def-key "fd" 'dired) (leader-def-key "fs" 'sudo-find-file) (leader-def-key "ft" 'auto-revert-tail-mode) (leader-def-key "fp" 'find-file-at-point) (general-def '(normal motion visual) "gf" 'find-file-at-point) #+END_SRC ** Window commands #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "w" "window") (leader-def-key "w/" 'split-window-right) (leader-def-key "w-" 'split-window-below) (leader-def-key "wm" 'delete-other-windows) (leader-def-key "wd" 'delete-window) (leader-def-key "ws" 'window-swap-states) #+END_SRC ** Buffer commands A function to switch to previous buffer from [[http://emacsredux.com/blog/2013/04/28/switch-to-previous-buffer/][this blog post]]: #+BEGIN_SRC emacs-lisp (defun switch-to-previous-buffer () "Switch to previously open buffer. Repeated invocations toggle between the two most recently open buffers." (interactive) (switch-to-buffer (other-buffer (current-buffer) 1))) (leader-def-key "TAB" 'switch-to-previous-buffer) #+END_SRC A function to kill all buffers except the current one from [[https://www.emacswiki.org/emacs/KillingBuffers#toc2][EmacsWiki]]: #+BEGIN_SRC emacs-lisp (defun kill-other-buffers () "Kill all other buffers." (interactive) (mapc 'kill-buffer (delq (current-buffer) (buffer-list)))) #+END_SRC #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "b" "buffer") (leader-def-key "bb" #'switch-to-buffer) (leader-def-key "bn" #'next-buffer) (leader-def-key "bp" #'previous-buffer) (leader-def-key "bd" #'kill-buffer) (leader-def-key "bm" #'kill-other-buffers) (leader-def-key "br" #'rename-buffer) #+END_SRC ** Frame commands #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "F" "frame") (leader-def-key "Fn" #'make-frame-command) (leader-def-key "Fo" #'other-frame) (leader-def-key "Fm" #'delete-other-frames) (leader-def-key "Fd" #'delete-frame) #+END_SRC ** Running shell commands #+BEGIN_SRC emacs-lisp (leader-def-key "!" 'shell-command) (leader-def-key "|" 'shell-command-on-region) #+END_SRC ** Toggles Like in Spacemacs, put all toggle commands behind a prefix: #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "t" "toggle") #+END_SRC Toggles about line truncation: #+BEGIN_SRC emacs-lisp (leader-def-key "tt" 'toggle-truncate-lines) (leader-def-key "tT" 'visual-line-mode) (leader-def-key "tf" 'auto-fill-mode) #+END_SRC Toggle lisp debugging: #+BEGIN_SRC emacs-lisp (leader-def-key "td" 'toggle-debug-on-error) #+END_SRC ** Shells/REPLs Emacs has a shell for every mood! #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "s" "shells/REPLs") (leader-def-key "ss" 'shell) (leader-def-key "si" 'ielm) (leader-def-key "se" 'eshell) (leader-def-key "sa" 'ansi-term) #+END_SRC ** Applications #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "a" "applications") #+END_SRC ** Help Buffers #+BEGIN_SRC emacs-lisp (general-def 'motion help-mode-map "TAB" #'forward-button) #+END_SRC ** Code commands #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "c" "code") (leader-def-key "cd" #'xref-find-definitions) (leader-def-key "cr" #'xref-find-references) (leader-def-key "ca" #'xref-find-apropos) (general-def 'normal "M-." #'xref-find-definitions) #+END_SRC ** Process list #+BEGIN_SRC emacs-lisp (general-def '(normal motion visual) process-menu-mode-map "d" #'process-menu-delete-process) #+END_SRC * Evil-numbers Handy functions to increment/decrement numbers at point: #+BEGIN_SRC emacs-lisp (use-package evil-numbers :straight (:host github :repo "janpath/evil-numbers") :general ((normal visual motion) "g+" 'evil-numbers/inc-at-pt) ((normal visual motion) "g-" 'evil-numbers/dec-at-pt) ((normal visual motion) "g C-+" 'evil-numbers/inc-at-pt-incremental) ((normal visual motion) "g C--" 'evil-numbers/dec-at-pt-incremental)) #+END_SRC * Winner Winner is a minor mode that keeps an undo/redo history of the window configuration: #+BEGIN_SRC emacs-lisp (winner-mode 1) (leader-def-key "wn" #'winner-redo) (leader-def-key "wp" #'winner-undo) #+END_SRC * Buffer move A handy package to shift buffers between open windows: #+BEGIN_SRC emacs-lisp (use-package buffer-move :general ("C-S-j" #'buf-move-down) ("C-S-k" #'buf-move-up) ("C-S-h" #'buf-move-left) ("C-S-l" #'buf-move-right)) #+END_SRC * Info #+BEGIN_SRC emacs-lisp (use-package info :init (defhydra hydra-info (:color blue :hint nil) " Info-mode: ^^_]_ forward (next logical node) ^^_l_ast (←) _u_p (↑) _f_ollow reference _T_OC ^^_[_ backward (prev logical node) ^^_r_eturn (→) _m_enu (↓) (C-u for new window) _i_ndex _d_irectory ^^_n_ext (same level only) ^^_H_istory _g_oto (C-u for new window) _,_ next index item _c_opy node name ^^_p_rev (same level only) _<_/_t_op _b_eginning of buffer virtual _I_ndex _C_lone buffer regex _s_earch (_S_ case sensitive) ^^_>_ final _e_nd of buffer ^^ _a_propos _1_ .. _9_ Pick first .. ninth item in the node's menu. " ("]" Info-forward-node) ("[" Info-backward-node) ("n" Info-next) ("p" Info-prev) ("s" Info-search) ("S" Info-search-case-sensitively) ("l" Info-history-back) ("r" Info-history-forward) ("H" Info-history) ("t" Info-top-node) ("<" Info-top-node) (">" Info-final-node) ("u" Info-up) ("^" Info-up) ("m" Info-menu) ("g" Info-goto-node) ("b" beginning-of-buffer) ("e" end-of-buffer) ("f" Info-follow-reference) ("i" Info-index) ("," Info-index-next) ("I" Info-virtual-index) ("T" Info-toc) ("d" Info-directory) ("c" Info-copy-current-node-name) ("C" clone-buffer) ("a" info-apropos) ("1" Info-nth-menu-item) ("2" Info-nth-menu-item) ("3" Info-nth-menu-item) ("4" Info-nth-menu-item) ("5" Info-nth-menu-item) ("6" Info-nth-menu-item) ("7" Info-nth-menu-item) ("8" Info-nth-menu-item) ("9" Info-nth-menu-item) ("?" Info-summary "Info summary") ("h" Info-help "Info help") ("q" Info-exit "Info exit") ("C-g" nil "cancel" :color blue)) :general (Info-mode-map "C-/" 'hydra-info/body)) #+END_SRC * xref After I select an xref reference, I want the xref buffer closed: #+BEGIN_SRC emacs-lisp (defun xref-goto-xref-and-quit () (interactive) (xref-goto-xref t)) (general-def 'normal xref--xref-buffer-mode-map "RET" #'xref-goto-xref-and-quit :keymaps 'override) #+END_SRC Don't prompt for an identifier for these xref commands: #+BEGIN_SRC emacs-lisp (setq xref-prompt-for-identifier '(not xref-find-definitions xref-find-definitions-other-window xref-find-definitions-other-frame xref-find-references)) #+END_SRC Some keybindings: #+BEGIN_SRC emacs-lisp (general-def "M-r" #'xref-find-references) #+END_SRC * IBuffer #+BEGIN_SRC emacs-lisp (use-package ibuffer :straight (:type built-in) :init (defhydra hydra-ibuffer-main (:color pink :hint nil) " ^Navigation^ | ^Mark^ | ^Actions^ | ^View^ -^----------^-+-^----^--------+-^-------^--------+-^----^------- _k_: ʌ | _m_: mark | _D_: delete | _g_: refresh _RET_: visit | _u_: unmark | _S_: save | _s_: sort _j_: v | _*_: specific | _a_: all actions | _/_: filter -^----------^-+-^----^--------+-^-------^--------+-^----^------- " ("j" ibuffer-forward-line) ("RET" ibuffer-visit-buffer :color blue) ("k" ibuffer-backward-line) ("m" ibuffer-mark-forward) ("u" ibuffer-unmark-forward) ("*" hydra-ibuffer-mark/body :color blue) ("D" ibuffer-do-delete) ("S" ibuffer-do-save) ("a" hydra-ibuffer-action/body :color blue) ("g" ibuffer-update) ("s" hydra-ibuffer-sort/body :color blue) ("/" hydra-ibuffer-filter/body :color blue) ("o" ibuffer-visit-buffer-other-window "other window" :color blue) ("q" quit-window "quit ibuffer" :color blue) ("." nil "toggle hydra" :color blue)) (defhydra hydra-ibuffer-mark (:color teal :columns 5 :after-exit (hydra-ibuffer-main/body)) "Mark" ("*" ibuffer-unmark-all "unmark all") ("M" ibuffer-mark-by-mode "mode") ("m" ibuffer-mark-modified-buffers "modified") ("u" ibuffer-mark-unsaved-buffers "unsaved") ("s" ibuffer-mark-special-buffers "special") ("r" ibuffer-mark-read-only-buffers "read-only") ("/" ibuffer-mark-dired-buffers "dired") ("e" ibuffer-mark-dissociated-buffers "dissociated") ("h" ibuffer-mark-help-buffers "help") ("z" ibuffer-mark-compressed-file-buffers "compressed") ("b" hydra-ibuffer-main/body "back" :color blue)) (defhydra hydra-ibuffer-action (:color teal :columns 4 :after-exit (if (eq major-mode 'ibuffer-mode) (hydra-ibuffer-main/body))) "Action" ("A" ibuffer-do-view "view") ("E" ibuffer-do-eval "eval") ("F" ibuffer-do-shell-command-file "shell-command-file") ("I" ibuffer-do-query-replace-regexp "query-replace-regexp") ("H" ibuffer-do-view-other-frame "view-other-frame") ("N" ibuffer-do-shell-command-pipe-replace "shell-cmd-pipe-replace") ("M" ibuffer-do-toggle-modified "toggle-modified") ("O" ibuffer-do-occur "occur") ("P" ibuffer-do-print "print") ("Q" ibuffer-do-query-replace "query-replace") ("R" ibuffer-do-rename-uniquely "rename-uniquely") ("T" ibuffer-do-toggle-read-only "toggle-read-only") ("U" ibuffer-do-replace-regexp "replace-regexp") ("V" ibuffer-do-revert "revert") ("W" ibuffer-do-view-and-eval "view-and-eval") ("X" ibuffer-do-shell-command-pipe "shell-command-pipe") ("b" nil "back")) (defhydra hydra-ibuffer-sort (:color amaranth :columns 3) "Sort" ("i" ibuffer-invert-sorting "invert") ("a" ibuffer-do-sort-by-alphabetic "alphabetic") ("v" ibuffer-do-sort-by-recency "recently used") ("s" ibuffer-do-sort-by-size "size") ("f" ibuffer-do-sort-by-filename/process "filename") ("m" ibuffer-do-sort-by-major-mode "mode") ("b" hydra-ibuffer-main/body "back" :color blue)) (defhydra hydra-ibuffer-filter (:color amaranth :columns 4) "Filter" ("m" ibuffer-filter-by-used-mode "mode") ("M" ibuffer-filter-by-derived-mode "derived mode") ("n" ibuffer-filter-by-name "name") ("c" ibuffer-filter-by-content "content") ("e" ibuffer-filter-by-predicate "predicate") ("f" ibuffer-filter-by-filename "filename") (">" ibuffer-filter-by-size-gt "size") ("<" ibuffer-filter-by-size-lt "size") ("/" ibuffer-filter-disable "disable") ("b" hydra-ibuffer-main/body "back" :color blue)) :general ((normal motion visual insert emacs) ibuffer-mode-map "." 'hydra-ibuffer-main/body)) #+END_SRC * Speedbar Speedbar is cool but having it open in a separate frame is annoying. This makes it open in a side window in the same frame: #+BEGIN_SRC emacs-lisp (use-package sr-speedbar :commands (sr-speedbar-toggle sr-speedbar-open sr-speedbar-select-window sr-speedbar-exist-p) :general (speedbar-mode-map "q" #'sr-speedbar-close)) (defun switch-to-speedbar () (interactive) (unless (sr-speedbar-exist-p) (sr-speedbar-open)) (sr-speedbar-select-window)) (leader-def-key "S" #'switch-to-speedbar) #+END_SRC * Whitespace Visualation #+BEGIN_SRC emacs-lisp (setq whitespace-line-column 80 whitespace-style '(face lines-tail)) (leader-def-key "tw" #'whitespace-mode) #+END_SRC * Line Numbers Toggle line numbers: #+BEGIN_SRC emacs-lisp (setq display-line-numbers-type 'visual) (leader-def-key "tn" 'display-line-numbers-mode) #+END_SRC Toggle line numbering mode (normal or relative): #+BEGIN_SRC emacs-lisp (defun toggle-line-number-mode () (interactive) (when display-line-numbers (if (eq display-line-numbers 'visual) (progn (setq display-line-numbers t) (setq display-line-numbers-type t)) (progn (setq display-line-numbers 'visual) (setq display-line-numbers-type 'visual))))) (leader-def-key "tr" #'toggle-line-number-mode) #+END_SRC Display line numbers by default in code and org-mode buffers: #+BEGIN_SRC emacs-lisp (add-hook 'prog-mode-hook #'display-line-numbers-mode) (add-hook 'org-mode-hook #'display-line-numbers-mode) #+END_SRC * Amx A better M-x. #+BEGIN_SRC emacs-lisp (use-package amx :config (amx-mode)) #+END_SRC * Olivetti Mode Olivetti is a minor mode for a nice writing environment. #+BEGIN_SRC emacs-lisp (use-package olivetti :config (setq-default olivetti-body-width 100) (setq olivetti-body-width 100) :commands olivetti-mode) (leader-def-key "to" 'olivetti-mode) #+END_SRC * Winum This package includes functions to switch windows by number. #+BEGIN_SRC emacs-lisp (defun winum-assign-0-to-dired-sidebar () (when (equal major-mode 'dired-sidebar-mode) 10)) (use-package winum :config (winum-mode) (add-to-list 'winum-assign-functions #'winum-assign-0-to-dired-sidebar) (leader-def-key "0" 'winum-select-window-0-or-10) (leader-def-key "1" 'winum-select-window-1) (leader-def-key "2" 'winum-select-window-2) (leader-def-key "3" 'winum-select-window-3) (leader-def-key "4" 'winum-select-window-4) (leader-def-key "5" 'winum-select-window-5) (leader-def-key "6" 'winum-select-window-6) (leader-def-key "7" 'winum-select-window-7) (leader-def-key "8" 'winum-select-window-8) (leader-def-key "9" 'winum-select-window-9)) #+END_SRC I don't want which-key display "lambda" for the descriptions of these, so set a custom display function. This is [[https://github.com/syl20bnr/spacemacs/blob/master/layers/+distributions/spacemacs-bootstrap/packages.el#L312][stolen from Spacemacs]]. #+BEGIN_SRC emacs-lisp (push '(("\\(.*\\) 0" . "select-window-0") . ("\\1 0..9" . "window 0..9")) which-key-replacement-alist) (push '((nil . "select-window-[1-9]") . t) which-key-replacement-alist) #+END_SRC * Backups and Autosaves Store backups and autosaves in a centralized place. This should really be the default... #+BEGIN_SRC emacs-lisp (make-directory (expand-file-name "~/.emacs.d/autosaves") t) (setq auto-save-file-name-transforms '((".*" "~/.emacs.d/autosaves" t))) (setq backup-directory-alist '(("." . "~/.emacs.d/backups"))) #+END_SRC * Smartparens/Parinfer Smartparens enables structured editing of s-expressions and other pairs: #+BEGIN_SRC emacs-lisp (use-package smartparens :hook ((prog-mode . smartparens-strict-mode) (eshell-mode . smartparens-strict-mode) (inferior-python-mode . smartparens-strict-mode)) :init (defhydra hydra-smartparens (:hint nil) " Moving^^^^ Slurp & Barf^^ Wrapping^^ Sexp juggling^^^^ Destructive ------------------------------------------------------------------------------------------------------------------------ [_a_] beginning [_n_] down [_h_] bw slurp [_R_] rewrap [_S_] split [_t_] transpose [_c_] change inner [_w_] copy [_e_] end [_N_] bw down [_H_] bw barf [_u_] unwrap [_s_] splice [_A_] absorb [_C_] change outer [_f_] forward [_p_] up [_l_] slurp [_U_] bw unwrap [_r_] raise [_E_] emit [_k_] kill [_g_] quit [_b_] backward [_P_] bw up [_L_] barf [_(__{__[_] wrap (){}[] [_j_] join [_o_] convolute [_K_] bw kill [_q_] quit" ;; Moving ("a" sp-beginning-of-sexp) ("e" sp-end-of-sexp) ("f" sp-forward-sexp) ("b" sp-backward-sexp) ("n" sp-down-sexp) ("N" sp-backward-down-sexp) ("p" sp-up-sexp) ("P" sp-backward-up-sexp) ;; Slurping & barfing ("h" sp-backward-slurp-sexp) ("H" sp-backward-barf-sexp) ("l" sp-forward-slurp-sexp) ("L" sp-forward-barf-sexp) ;; Wrapping ("R" sp-rewrap-sexp) ("u" sp-unwrap-sexp) ("U" sp-backward-unwrap-sexp) ("(" sp-wrap-round) ("{" sp-wrap-curly) ("[" sp-wrap-square) ;; Sexp juggling ("S" sp-split-sexp) ("s" sp-splice-sexp) ("r" sp-raise-sexp) ("j" sp-join-sexp) ("t" sp-transpose-sexp) ("A" sp-absorb-sexp) ("E" sp-emit-sexp) ("o" sp-convolute-sexp) ;; Destructive editing ("c" sp-change-inner :exit t) ("C" sp-change-enclosing :exit t) ("k" sp-kill-sexp) ("K" sp-backward-kill-sexp) ("w" sp-copy-sexp) ("q" nil) ("g" nil)) :config (require 'smartparens-config) (show-smartparens-global-mode t) :general (prog-mode-map "C-c p" 'hydra-smartparens/body) (normal prog-mode-map "g p" 'hydra-smartparens/body) (normal "g[" 'sp-wrap-square) (normal "g(" 'sp-wrap-round) (normal "g{" 'sp-wrap-curly)) (use-package evil-smartparens :after (evil smartparens) :hook ((smartparens-enabled . evil-smartparens-mode))) (jdormit/define-prefix "l" "lisp") (jdormit/define-prefix "lw" "wrap") (leader-def-key "lwr" 'sp-wrap-round) (leader-def-key "lws" 'sp-wrap-square) (leader-def-key "lwc" 'sp-wrap-curly) (leader-def-key "ls" 'sp-forward-slurp-sexp) (leader-def-key "lb" 'sp-forward-barf-sexp) #+END_SRC Enable ES6 arrow functions in web-mode ("borrowed" from [[https://github.com/Fuco1/smartparens/issues/823#issuecomment-403019519][this GitHub comment]]): #+BEGIN_SRC emacs-lisp (with-eval-after-load 'smartparens (defun sp-after-equals-p (_id action _context) (when (memq action '(insert navigate)) (sp--looking-back-p "=>" 2))) (defun sp-after-equals-skip (ms mb _me) (when (eq ms ">") (save-excursion (goto-char mb) (sp--looking-back-p "=" 1)))) (sp-local-pair '(web-mode) "<" nil :unless '(:add sp-after-equals-p) :skip-match 'sp-after-equals-skip-p)) #+END_SRC Parinfer infers parens from indentation and vice-versa. Currently disabled since it turned out to be more annoying than good... #+BEGIN_SRC emacs-lisp (use-package parinfer :disabled :init (leader-def-key "lt" 'parinfer-toggle-mode) (setq parinfer-extensions '(defaults pretty-parens evil smart-tab smart-yank)) :hook ((clojure-mode . parinfer-mode) (emacs-lisp-mode . parinfer-mode) (common-lisp-mode . parinfer-mode) (scheme-mode . parinfer-mode) (lisp-mode . parinfer-mode))) #+END_SRC * jq The JSON multitool. #+BEGIN_SRC emacs-lisp (use-package jq-mode :commands (jq-mode jq-interactively)) #+END_SRC * Org Mode Notes, agenda, calendar, blogging, journaling, etc. #+BEGIN_SRC emacs-lisp (jdormit/define-prefix "o" "org") (leader-def-key "oa" 'org-agenda) (leader-def-key "oc" 'org-capture) (setq org-src-fontify-natively t org-ellipsis " ▼" org-directory (concat (get-dropbox-directory) "/org") org-link-elisp-confirm-function 'y-or-n-p org-startup-with-inline-images t) (add-hook 'org-mode-hook #'auto-fill-mode) #+END_SRC Use RET to follow links: #+BEGIN_SRC emacs-lisp (setq org-return-follows-link t) #+END_SRC Always show inline images: #+BEGIN_SRC emacs-lisp (add-hook 'org-mode-hook (lambda () (org-display-inline-images nil t) (org-redisplay-inline-images))) #+END_SRC Include a timestamp when TODO entries are closed: #+BEGIN_SRC emacs-lisp (setq org-log-done 'time) #+END_SRC Tell Emacs how to open file links of various types: #+BEGIN_SRC emacs-lisp (with-eval-after-load 'org (add-to-list 'org-file-apps '(directory . emacs)) (add-to-list 'org-file-apps '("log" . emacs))) #+END_SRC A function to add ids to every heading in an Org file: #+BEGIN_SRC emacs-lisp (defun org-get-create-ids-all () (interactive) (save-excursion (goto-char (point-max)) (while (outline-previous-heading) (org-id-get-create)))) #+END_SRC ** Agenda files #+BEGIN_SRC emacs-lisp (defun agenda-files (&optional file) (let ((agenda-dir (concat (file-name-as-directory (get-dropbox-directory)) "org"))) (if file (concat (file-name-as-directory agenda-dir) file) agenda-dir))) (setq org-agenda-files `(,(agenda-files))) #+END_SRC ** Capture templates #+BEGIN_SRC emacs-lisp (setq org-capture-templates `(("L" "Lola task" entry (file+headline ,(agenda-files "todo.org") "Lola") "* TODO %i%?") ("p" "Personal task" entry (file+headline ,(agenda-files "todo.org") "Personal") "* TODO %i%?") ("n" "Note" entry (file ,(agenda-files "notes.org")) "* %^{Description}\n%i%?") ("l" "Log" entry (file ,(agenda-files "log.org")) "* %<%Y-%m-%d %H:%M:%S>%?"))) #+END_SRC ** Refile targets #+BEGIN_SRC emacs-lisp (setq org-refile-use-outline-path 'file org-refile-targets `((org-agenda-files :level . 0) (,(agenda-files "notes.org") :level . 1) (,(agenda-files "todo.org") :level . 1))) #+END_SRC ** Todo keywords #+BEGIN_SRC emacs-lisp (setq org-todo-keywords '((sequence "TODO(t)" "IN PROGRESS(i)" "BLOCKED(b)" "|" "DONE(d)" "CANCELLED(c)"))) #+END_SRC ** Agenda views #+BEGIN_SRC emacs-lisp (setq org-agenda-todo-ignore-scheduled 'future org-agenda-tags-todo-honor-ignore-options t org-agenda-span 'day org-agenda-custom-commands '(("L" "Lola" ((tags-todo "@lola"))) ("t" "TODOs" ((agenda) (alltodo))))) #+END_SRC ** Keybindings #+BEGIN_SRC emacs-lisp (general-def 'normal org-mode-map "T" #'org-insert-todo-heading) (general-def 'normal org-mode-map "K" #'org-move-subtree-up) (general-def 'normal org-mode-map "J" #'org-move-subtree-down) (general-def 'normal org-mode-map "" #'org-return) (general-def 'normal org-mode-map "TAB" #'org-cycle) (general-def 'normal org-mode-map "SPC" leader-map) (general-def '(normal motion visual) org-mode-map "gn" #'org-next-link) (general-def '(normal motion visual) org-mode-map "gp" #'org-previous-link) (general-def org-mode-map "C-c e" #'org-preview-latex-fragment) (general-def "C-c l" #'org-store-link) #+END_SRC Set up evil keybindings: #+BEGIN_SRC emacs-lisp (use-package evil-org :after (evil org) :hook (org-mode . evil-org-mode) :config (add-hook 'evil-org-mode-hook (lambda () (evil-org-set-key-theme '(textobjects insert navigation additional shift todo)) (general-def 'insert org-mode-map [backspace] 'org-delete-backward-char))) (require 'evil-org-agenda) (evil-org-agenda-set-keys) (general-def 'motion org-agenda-mode-map "SPC" leader-map) (general-def 'motion org-agenda-mode-map "gs" 'org-save-all-org-buffers) (general-def '(normal motion) evil-org-mode-map "C-S-j" nil "C-S-k" nil "C-S-h" nil "C-S-l" nil)) #+END_SRC And a global keybinding to open an org file: #+BEGIN_SRC emacs-lisp (defun find-org-file (file) (interactive (list (completing-read "Find org file: " (directory-files (agenda-files) t)))) (find-file file)) (leader-def-key "fo" #'find-org-file) #+END_SRC Finally, add a helpful agenda-mode hydra: #+BEGIN_SRC emacs-lisp (with-eval-after-load 'org-agenda (defhydra hydra-org-agenda (:pre (setq which-key-inhibit t) :post (setq which-key-inhibit nil) :hint none) " Org agenda (_q_uit) ^Clock^ ^Visit entry^ ^Date^ ^Other^ ^-----^---- ^-----------^------------ ^----^----------- ^-----^--------- _ci_ in _SPC_ in other window _ds_ schedule _gr_ reload _co_ out _TAB_ & go to location _dd_ set deadline _._ go to today _cq_ cancel _RET_ & del other windows _dt_ timestamp _gd_ go to date _cj_ jump _o_ link _+_ do later ^^ ^^ ^^ _-_ do earlier ^^ ^^ ^^ ^^ ^^ ^View^ ^Filter^ ^Headline^ ^Toggle mode^ ^----^-------- ^------^--------------- ^--------^------- ^-----------^---- _vd_ day _ft_ by tag _ht_ set status _tf_ follow _vw_ week _fr_ refine by tag _hk_ kill _tl_ log _vt_ fortnight _fc_ by category _hr_ refile _ta_ archive trees _vm_ month _fh_ by top headline _hA_ archive _tA_ archive files _vy_ year _fx_ by regexp _h:_ set tags _tr_ clock report _vn_ next span _fd_ delete all filters _hp_ set priority _td_ diaries _vp_ prev span ^^ ^^ ^^ _vr_ reset ^^ ^^ ^^ ^^ ^^ ^^ ^^ " ;; Entry ("hA" org-agenda-archive-default) ("hk" org-agenda-kill) ("hp" org-agenda-priority) ("hr" org-agenda-refile) ("h:" org-agenda-set-tags) ("ht" org-agenda-todo) ;; Visit entry ("o" link-hint-open-link :exit t) ("" org-agenda-goto :exit t) ("TAB" org-agenda-goto :exit t) ("SPC" org-agenda-show-and-scroll-up) ("RET" org-agenda-switch-to :exit t) ;; Date ("dt" org-agenda-date-prompt) ("dd" org-agenda-deadline) ("+" org-agenda-do-date-later) ("-" org-agenda-do-date-earlier) ("ds" org-agenda-schedule) ;; View ("vd" org-agenda-day-view) ("vw" org-agenda-week-view) ("vt" org-agenda-fortnight-view) ("vm" org-agenda-month-view) ("vy" org-agenda-year-view) ("vn" org-agenda-later) ("vp" org-agenda-earlier) ("vr" org-agenda-reset-view) ;; Toggle mode ("ta" org-agenda-archives-mode) ("tA" (org-agenda-archives-mode 'files)) ("tr" org-agenda-clockreport-mode) ("tf" org-agenda-follow-mode) ("tl" org-agenda-log-mode) ("td" org-agenda-toggle-diary) ;; Filter ("fc" org-agenda-filter-by-category) ("fx" org-agenda-filter-by-regexp) ("ft" org-agenda-filter-by-tag) ("fr" org-agenda-filter-by-tag-refine) ("fh" org-agenda-filter-by-top-headline) ("fd" org-agenda-filter-remove-all) ;; Clock ("cq" org-agenda-clock-cancel) ("cj" org-agenda-clock-goto :exit t) ("ci" org-agenda-clock-in :exit t) ("co" org-agenda-clock-out) ;; Other ("q" nil :exit t) ("gd" org-agenda-goto-date) ("." org-agenda-goto-today) ("gr" org-agenda-redo)) (general-def '(normal visual motion insert emacs) org-agenda-mode-map "." 'hydra-org-agenda/body)) #+END_SRC ** Exporting *** HTML Export to HTML: #+BEGIN_SRC emacs-lisp (use-package htmlize :commands htmlize-buffer) #+END_SRC Don't put section numbers in front of headers: #+BEGIN_SRC emacs-lisp (setq org-export-with-section-numbers nil) #+END_SRC Disable the preamble and postamble: #+BEGIN_SRC emacs-lisp (setq org-html-preamble nil org-html-postamble nil) #+END_SRC Redefine org-html-src-block to wrap code blocks in 
 and language class for use by highlight.js:
#+BEGIN_SRC emacs-lisp
  (defun org-html-src-block (src-block _contents info)
    "Transcode a SRC-BLOCK element from Org to HTML.
  CONTENTS holds the contents of the item.  INFO is a plist holding
  contextual information."
    (if (org-export-read-attribute :attr_html src-block :textarea)
	(org-html--textarea-block src-block)
      (let* ((lang (org-element-property :language src-block))
	     (code (org-html-format-code src-block info))
	     (label (let ((lbl (and (org-element-property :name src-block)
				    (org-export-get-reference src-block info))))
		      (if lbl (format " id=\"%s\"" lbl) "")))
	     (klipsify  (and  (plist-get info :html-klipsify-src)
			      (member lang '("javascript" "js"
					     "ruby" "scheme" "clojure" "php" "html")))))
	(if (not lang) (format "
\n%s
" label code)
	  (format "
\n%s%s\n
"
		  ;; Build caption.
		  (let ((caption (org-export-get-caption src-block)))
		    (if (not caption) ""
		      (let ((listing-number
			     (format
			      "%s "
			      (format
			       (org-html--translate "Listing %d:" info)
			       (org-export-get-ordinal
				src-block info nil #'org-html--has-caption-p)))))
			(format ""
				listing-number
				(org-trim (org-export-data caption info))))))
		  ;; Contents.
		  (if klipsify
		      (format "
%s
"
			      lang
			      label
			      (if (string= lang "html")
				  " data-editor-type=\"html\""
				"")
			      code)
		    (format "
%s
"
			    lang lang label code)))))))
#+END_SRC

*** Github-flavored markdown
#+BEGIN_SRC emacs-lisp
  (use-package ox-gfm
    :defer t
    :init
    (with-eval-after-load 'org
      (require 'ox-gfm)))
#+END_SRC

*** Jira
#+BEGIN_SRC emacs-lisp
  (use-package ox-jira
    :defer t
    :straight (:host github :repo "stig/ox-jira.el")
    :init
    (with-eval-after-load 'org
      (require 'ox-jira)))
#+END_SRC

** org-babel
Literate programming!
#+BEGIN_SRC emacs-lisp
  (add-hook 'org-mode-hook
    (lambda ()
      (org-babel-do-load-languages
       'org-babel-load-languages
       '((emacs-lisp . t)
	 (python . t)
	 (shell . t)
	 (clojure . t)
	 (lisp . t)
	 (scheme . t)
	 (java . t)
	 (js . t)
	 (dot . t)
	 (ditaa . t)
	 (ledger . t)
	 (sql . t)
	 (jq . t)
         (restclient . t)))))
#+END_SRC

Get rid of the confirmation prompt:
#+BEGIN_SRC emacs-lisp
  (setq org-confirm-babel-evaluate nil)
#+END_SRC

Display inline images after executing a source block:
#+BEGIN_SRC emacs-lisp
  (add-hook 'org-babel-after-execute-hook
      (lambda ()
	(org-display-inline-images nil t)
	(org-redisplay-inline-images)))
#+END_SRC

Enable async source block execution. Note: this execute the contents of the source block in a separate Emacs process, so blocks that rely on anything defined in init.org or the current Emacs process won't work as expected.
#+BEGIN_SRC emacs-lisp
  (use-package ob-async
    :straight (ob-async :host github :repo "astahlman/ob-async")
    :defer t
    :hook (org-mode . (lambda () (require 'ob-async))))
#+END_SRC

Filter out the "u" from unicode results in org tabels returned from Python source blocks:
#+BEGIN_SRC emacs-lisp
  (with-eval-after-load 'ob-python
    (defun org-babel-python-table-or-string (results)
      "Convert RESULTS into an appropriate elisp value.
  If the results look like a list or tuple, then convert them into an
  Emacs-lisp table, otherwise return the results as a string."
      (let ((res (org-babel-script-escape results)))
	(if (listp res)
	    (mapcar (lambda (el)
		      (cond
		       ((eq el 'None) org-babel-python-None-to)
		       ((listp el) (-filter (lambda (m) (not (eq m 'u))) el))
		       (t el)))
		    res)
	  res))))
#+END_SRC

** Images
#+BEGIN_SRC emacs-lisp
  (setq org-image-actual-width nil)
#+END_SRC

** org-scratch
It's very useful to open a new org buffer for a quick org-babel exploration.
#+BEGIN_SRC emacs-lisp
  (defun org-scratch (&optional make-new)
    "Switches to an org-mode buffer not associated with any file.
  If called with a prefix argument, always creates a new buffer;
  otherwise, switches to the existing *org-scratch* buffer if it exists."
    (interactive "P")
    (let ((org-scratch-buffer-name
	   (generate-new-buffer-name
	    "*org-scratch*"
	    (unless make-new "*org-scratch*"))))
      (switch-to-buffer org-scratch-buffer-name)
      (org-mode)))

  (leader-def-key "os" #'org-scratch)
#+END_SRC

** org-gcal
Integrate Google calendar with org-mode:
#+BEGIN_SRC emacs-lisp
  (defun get-calendar-file (name)
    (concat (file-name-as-directory (get-dropbox-directory))
	    "org/" name))

  (use-package org-gcal
    :after (org)
    :commands (org-gcal-sync
	       org-gcal-fetch
	       org-gcal-post-at-point
	       org-gcal-delete-at-point
	       org-gcal-refresh-token)
    :config
    (setq org-gcal-client-id (password-store-get "lola-org-gcal-client-id")
	  org-gcal-client-secret (password-store-get "lola-org-gcal-client-secret")
	  org-gcal-file-alist `(("jeremydormitzer@lola.com" . ,(get-calendar-file "lola-gcal.org"))
				("jeremy.dormitzer@gmail.com" . ,(get-calendar-file "personal-gcal.org"))
				("lut2o2moohg6qkdsto1qfq7th4@group.calendar.google.com" . ,(get-calendar-file "j-n-gcal.org")))
	  org-gcal-notify-p nil))

  (defun org-gcal-fetch-and-save ()
    (interactive)
    (deferred:$
      (org-gcal-fetch)
      (deferred:nextc it
	(lambda ()
	  (dolist (entry org-gcal-file-alist)
	    (with-current-buffer (cdr entry)
	      (save-buffer)))))))

  (add-hook 'emacs-startup-hook #'org-gcal-fetch-and-save)

  (defun org-agenda-redo-and-fetch-gcal (&optional all)
    (interactive "P")
    (let ((cb (if all #'org-agenda-redo-all #'org-agenda-redo)))
      (deferred:nextc (org-gcal-fetch-and-save) cb)))

  (with-eval-after-load 'org-agenda
   (general-def '(normal motion) org-agenda-mode-map "gR" #'org-agenda-redo-and-fetch-gcal))
#+END_SRC

** Utilities
A function to get the TITLE property of the current org buffer:
#+BEGIN_SRC emacs-lisp
  (defun org-get-title (&optional contents)
    (let ((raw (or contents
		   (buffer-substring (point-min) (point-max)))))
      (with-temp-buffer
	(insert raw)
	(car
	 (org-element-map
	     (org-element-parse-buffer)
	     'keyword
	   (lambda (el)
	     (when (string-match-p "TITLE"
				   (org-element-property :key el))
	       (org-element-property :value el))))))))
#+END_SRC

* org-present
An ultra-minimalist presentation mode for Org:
#+BEGIN_SRC emacs-lisp
  (use-package org-present
    :commands (org-present)
    :config
    (defun org-present-on ()
      (org-present-big)
      (org-display-inline-images)
      (org-present-hide-cursor)
      (display-line-numbers-mode -1)
      (org-present-read-only))
    (defun org-present-off ()
      (org-present-small)
      (org-present-show-cursor)
      (unless org-startup-with-inline-images
       (org-remove-inline-images))
      (display-line-numbers-mode)
      (org-present-read-write))
    (add-hook 'org-present-mode-hook #'org-present-on)
    (add-hook 'org-present-mode-quit-hook #'org-present-off)
    ;; Redefine org-present to call org-present-narrow after running hooks
    (defun org-present ()
      "init."
      (interactive)
      (setq org-present-mode t)
      (org-present-add-overlays)
      (run-hooks 'org-present-mode-hook)
      (org-present-narrow)
      (org-present-run-after-navigate-functions))
    :init
    (general-def '(normal visual motion emacs) org-present-mode-keymap
     "" #'org-present-prev
     "" #'org-present-next
     "C-k" #'org-present-prev
     "C-j" #'org-present-next
     "q" #'org-present-quit))
#+END_SRC

* link-hint
A very helpful package that provides jump-to-link functionality:
#+BEGIN_SRC emacs-lisp
  (use-package link-hint
    :commands (link-hint-open-link
	       link-hint-copy-link)
    :init
    (jdormit/define-prefix "ol" "link-hint")
    (leader-def-key "oll" #'link-hint-open-link)
    (leader-def-key "olc" #'link-hint-copy-link))
#+END_SRC

* org-cliplink
Intelligently inserts an org-mode link from the clipboard.
#+BEGIN_SRC emacs-lisp
  (use-package org-cliplink
    :commands (org-cliplink
	       org-cliplink-clipboard-content)
    :general
    (org-mode-map "C-c C-S-l" #'org-cliplink))
#+END_SRC

* org-board
[[https://github.com/scallywag/org-board][Org-board]] is a bookmarking/archiving system built on Org mode:
#+BEGIN_SRC emacs-lisp
  (use-package org-board
    :defer t
    :after org
    :init

    ;; Org-capture setup

    (defvar org-capture-bookmark-last-url nil)
    (defvar org-capture-bookmark-last-title nil)

    (defun org-capture-bookmark-get-url ()
      (let* ((clip (org-cliplink-clipboard-content))
	     (parsed (url-generic-parse-url clip)))
	(if (url-type parsed)
	    clip
	  (read-string "Bookmark URL: "))))

    (defun org-capture-bookmark-get-title (url)
      (or (org-cliplink-retrieve-title-synchronously url)
	  (read-string "Bookmark title: ")))

    (defun bookmark-file (title)
      (concat (get-dropbox-directory)
	      (format "/org/%s.org" (org-roam--get-new-id title))))

    (defun org-capture-bookmark-file ()
      (let* ((url (org-capture-bookmark-get-url))
	     (title (org-capture-bookmark-get-title url)))
	(setq org-capture-bookmark-last-url url)
	(setq org-capture-bookmark-last-title title)
	(bookmark-file title)))

    (defun org-capture-bookmark-link ()
      (format "[[%s][%s]]"
	      org-capture-bookmark-last-url
	      org-capture-bookmark-last-title))

    (defun org-capture-bookmark-title ()
      org-capture-bookmark-last-title)

    (defun save-bookmark (url)
      (save-excursion
	(goto-char (point-min))
	(when (search-forward "* Bookmark" nil t)
	  (org-board-new url)
	  (wallabag-add-entry url
			      (cl-function
			       (lambda (&key data &allow-other-keys)
				 (let ((entry-url (format "%s/view/%s"
							  wallabag-base-url
							  (alist-get 'id data))))
				   (message "Added bookmark to Wallabag: %s" entry-url))))))))

    (defun org-capture-bookmark-after-finalize ()
      "Runs `org-board-new' on the captured entry.
    Also saves to Wallabag."
      (let ((success (not org-note-abort))
	    (key (plist-get org-capture-plist :key))
	    (desc (plist-get org-capture-plist :description)))
	(when (and success
		   (equal key "b")
		   (equal desc "Bookmark")
		   org-capture-bookmark-last-url)
	  (save-bookmark org-capture-bookmark-last-url)
	  (setq org-capture-bookmark-last-url nil)
	  (setq org-capture-bookmark-last-title nil))))

    (add-hook 'org-capture-prepare-finalize-hook
	      #'org-capture-bookmark-after-finalize)

    (add-to-list 'org-capture-templates
		 '("b" "Bookmark" plain
		   (file org-capture-bookmark-file)
		   "#+TITLE: %(org-capture-bookmark-title)\n\n- tags :: [[file:deft/bookmarks.org][Bookmarks]]\n- source :: %(org-capture-bookmark-link)\n%?\n* Bookmark"))

    ;; Org-protocol setup
    (defun make-org-protocol-bookmark (url title)
      (with-temp-buffer
	(let ((filename (bookmark-file title)))
	  (save-excursion
	    (insert (concat (format "#+TITLE: %s\n\n" title)
			    "- tags :: [[file:deft/bookmarks.org][Bookmarks]]\n"
			    (format "- source :: [[%s][%s]]\n\n" url title)
			    "* Bookmark"))
	    (write-file filename)
	    (save-bookmark url)
	    (save-buffer)))))

    (defun bookmark-via-org-protocol (url)
      (org-cliplink-retrieve-title (url-unhex-string url) #'make-org-protocol-bookmark))

    (add-to-list 'org-protocol-protocol-alist
		 '("Bookmark"
		   :protocol "bookmark"
		   :function bookmark-via-org-protocol
		   :kill-client t))

    :config
    (add-to-list 'org-board-wget-switches "--recursive")
    (add-to-list 'org-board-wget-switches "--level=1")
    (add-to-list 'org-board-wget-switches "--span-hosts")
    ;; Use w3m instead of eww to open org-board archived links
    (advice-add 'org-board-open-with :around
		(lambda (oldfn filename-string arg &rest args)
		  (cond
		   ((not (file-exists-p filename-string)) 1)
		   ((and filename-string
			 (or (and arg (eq org-board-default-browser 'system))
			     (and (not arg) (eq org-board-default-browser 'eww))))
		    (let ((filename (concat "file://"
					    (s-chop-prefix "file://"
							   filename-string))))
		      (w3m filename t)
		      0))
		   (:else (apply oldfn filename-string arg args)))))
    :general
    (org-mode-map "C-c b" org-board-keymap))
#+END_SRC

* org-rifle
Quickly find stuff in Org files:
#+BEGIN_SRC emacs-lisp
  (use-package helm-org-rifle
    :defer t
    :init
    (defvar helm-org-rifle-commands-map (make-sparse-keymap))
    (general-def helm-org-rifle-commands-map
      "r" #'helm-org-rifle
      "a" #'helm-org-rifle-agenda-files
      "b" #'helm-org-rifle-current-buffer
      "d" #'helm-org-rifle-directories
      "f" #'helm-org-rifle-files
      "o" #'helm-org-rifle-org-directory
      "R" #'helm-org-rifle-occur
      "A" #'helm-org-rifle-occur-agenda-files
      "B" #'helm-org-rifle-occur-current-buffer
      "D" #'helm-org-rifle-occur-directories
      "F" #'helm-org-rifle-occur-files
      "O" #'helm-org-rifle-occur-org-directory)
    (leader-def-key "or" helm-org-rifle-commands-map)
    (jdormit/define-prefix "or" "org-rifle"))
#+END_SRC

* Org Noter
[[https://github.com/weirdNox/org-noter][Org Noter]] lets me take org-mode notes on PDFs, epubs, and DocView files:
#+BEGIN_SRC emacs-lisp
  (use-package org-noter
    :commands org-noter
    :general
    ((normal visual motion) org-noter-doc-mode-map "i" #'org-noter-insert-note)
    ((normal visual motion) org-noter-doc-mode-map "q" #'org-noter-kill-session)
    ((normal visual motion) org-noter-doc-mode-map "C-M-n" #'org-noter-sync-next-note)
    ((normal visual motion) org-noter-doc-mode-map "C-M-p" #'org-noter-sync-prev-note)
    ((normal visual motion) org-noter-doc-mode-map "M-." #'org-noter-sync-current-page-or-chapter)
    ((normal visual motion) org-noter-doc-mode-map "M-i" #'org-noter-insert-precise-note)
    ((normal visual motion) org-noter-doc-mode-map "M-n" #'org-noter-sync-next-page-or-chapter)
    ((normal visual motion) org-noter-doc-mode-map "M-p" #'org-noter-sync-prev-page-or-chapter)
    ((normal visual motion) org-noter-doc-mode-map "C-M-." #'org-noter-sync-current-note))
#+END_SRC

* Org Roam
[[https://org-roam.readthedocs.io/en/develop/][Org-roam]] is another backlink package for org-mode:
#+BEGIN_SRC emacs-lisp
  (use-package org-roam
    :after org
    :straight (:host github :repo "jethrokuan/org-roam")
    :commands
    (org-roam
     org-roam-today
     org-roam-find-file
     org-roam-insert
     org-roam-show-graph
     org-roam--get-new-id)
    :hook
    (after-init . org-roam-mode)
    :custom
    (org-roam-directory (concat (get-dropbox-directory) "/org"))
    :init
    (leader-def-key "fo" #'org-roam-find-file)
    (leader-def-key "of" #'org-roam-find-file)
    (defvar org-roam-map (make-sparse-keymap))
    (leader-def-key "on" org-roam-map)
    (jdormit/define-prefix "on" "org-roam")
    (which-key-add-key-based-replacements "C-c n" "org-roam")
    (which-key-add-major-mode-key-based-replacements
      'org-mode "gn" "org-roam")
    :config
    (add-hook 'org-roam-backlinks-mode-hook #'olivetti-mode)
    :general
    (org-roam-map "l" #'org-roam)
    (org-roam-map "t" #'org-roam-today)
    (org-roam-map "f" #'org-roam-find-file)
    (org-roam-map "i" #'org-roam-insert)
    (org-roam-map "g" #'org-roam-show-graph)
    ((normal motion visual) org-mode-map "gr" org-roam-map)
    ((normal motion visual) org-roam-backlinks-mode-map "" #'org-open-at-point)
    ((normal motion visual emacs) org-roam-backlinks-mode-map "q" #'quit-window)
    ("C-c n" org-roam-map))
#+END_SRC

* org-journal
[[https://github.com/bastibe/org-journal][org-journal]] is a package that provides some convenience functions
around keeping a daily Org-mode journal. I also set it up so it plays
nice with Org-roam:
#+BEGIN_SRC emacs-lisp
  (use-package org-journal
    :defer t
    :init
    (defun org-journal-file-header-func ()
      (let ()
	(format "#+TITLE: %s"
		(format-time-string "%Y-%m-%d"))))
    (defun org-journal-today ()
      (interactive)
      (org-journal-new-entry t))
    (defun org-journal-capture-func ()
      (org-journal-new-entry t)
      (goto-char (point-min))
      ;; Account for the #+TITLE
      (forward-line))
    (add-to-list 'org-capture-templates
		 '("j" "Journal entry" entry (function org-journal-capture-func)
		   "* %(format-time-string org-journal-time-format)\n%?"))
    (jdormit/define-prefix "oj" "org-journal")
    (leader-def-key "ojn" #'org-journal-new-entry)
    (leader-def-key "ojt" #'org-journal-today)
    :custom
    (org-journal-file-type 'daily)
    (org-journal-dir (concat (get-dropbox-directory) "/org"))
    (org-journal-file-format "%Y-%m-%d.org")
    (org-journal-file-header 'org-journal-file-header-func)
    (org-journal-carryover-items "")
    :general
    (org-roam-map "t" 'org-journal-today))
#+END_SRC

* org-super-agenda
#+BEGIN_SRC emacs-lisp
  (use-package org-super-agenda
    :init
    (setq org-super-agenda-groups
          '((:name "In progress"
                   :todo "IN PROGRESS")
            (:name "Lola"
                   :tag "@lola")
            (:name "unifyDB"
                   :tag "@unifydb")
            (:name "Personal"
                   :tag "@personal")))
    (org-super-agenda-mode)
    :config
    (setq org-super-agenda-header-map (make-sparse-keymap)))
#+END_SRC

* Projectile
#+BEGIN_SRC emacs-lisp
  (use-package projectile
    :commands (projectile-find-file
	       projectile-grep
	       projectile-switch-project
	       projectile-project-root)
    :init
    (defhydra hydra-projectile (:color teal :hint nil) "
    PROJECTILE: %(projectile-project-root)

       Find File Search/Tags Buffers Cache
  ------------------------------------------------------------------------------------------
  _s-f_: file _a_: ag _i_: Ibuffer _c_: cache clear _ff_: file dwim
   _g_: update gtags _b_: switch to buffer _x_: remove known project
   _fd_: file curr dir _o_: multi-occur _s-k_: Kill all buffers _X_:
   cleanup non-existing _r_: recent file ^^^^_z_: cache current _d_:
   dir

  "
      ("a" projectile-ag)
      ("b" projectile-switch-to-buffer)
      ("c" projectile-invalidate-cache)
      ("d" projectile-find-dir)
      ("s-f" projectile-find-file)
      ("ff" projectile-find-file-dwim)
      ("fd" projectile-find-file-in-directory)
      ("g" ggtags-update-tags)
      ("s-g" ggtags-update-tags)
      ("i" projectile-ibuffer)
      ("K" projectile-kill-buffers)
      ("s-k" projectile-kill-buffers)
      ("m" projectile-multi-occur)
      ("o" projectile-multi-occur)
      ("s-p" projectile-switch-project "switch project")
      ("p" projectile-switch-project)
      ("s" projectile-switch-project)
      ("r" projectile-recentf)
      ("x" projectile-remove-known-project)
      ("X" projectile-cleanup-known-projects)
      ("z" projectile-cache-current-file)
      ("`" hydra-projectile-other-window/body "other window")
      ("q" nil "cancel" :color blue))
    :config
    (projectile-mode)
    (jdormit/define-prefix "p" "projectile")
    (leader-def-key "p" projectile-command-map))

  (defmacro with-projectile-root (&rest body)
    `(with-temp-buffer
       (when (projectile-project-root)
	 (cd (projectile-project-root)))
       ,@body))
      #+END_SRC

* Mode line
* UI
Get rid of the janky buttons:
#+BEGIN_SRC emacs-lisp
  (tool-bar-mode -1)
#+END_SRC

And the menu bar:
#+BEGIN_SRC emacs-lisp
  (menu-bar-mode -1)
#+END_SRC

And the ugly scroll bars:
#+BEGIN_SRC emacs-lisp
  (set-scroll-bar-mode nil)
#+END_SRC

Use =variable-pitch-mode= in text modes:
#+BEGIN_SRC emacs-lisp
  (add-hook 'text-mode-hook (lambda () (variable-pitch-mode)))
  (add-hook 'w3m-mode-hook (lambda () (variable-pitch-mode)))
#+END_SRC

Always use =buffer-face-mode= in code and text buffers:
#+BEGIN_SRC emacs-lisp
  (add-hook 'prog-mode-hook #'buffer-face-mode)
  (add-hook 'text-mode-hook #'buffer-face-mode)
#+END_SRC

Display the column number in programming modes:
#+BEGIN_SRC emacs-lisp
  (add-hook 'prog-mode-hook #'column-number-mode)
#+END_SRC

Disable the bell:
#+BEGIN_SRC emacs-lisp
  (setq ring-bell-function 'ignore)
#+END_SRC


Render stuff differently based on whether or not we are graphical:
#+BEGIN_SRC emacs-lisp
  (defun graphical-setup ()
    (when (display-graphic-p (selected-frame))
      (message "Running graphically")))

  (defun non-graphical-setup ()
    (when (not (display-graphic-p (selected-frame)))
      (message "Running in terminal")
      (menu-bar-mode -1)))

  (defun do-graphical-non-graphical-setup ()
    (graphical-setup)
    (non-graphical-setup))

  (add-hook 'window-setup-hook #'do-graphical-non-graphical-setup)
#+END_SRC

Try to make the background normal colored in the terminal:
#+BEGIN_SRC emacs-lisp
  (defvar no-background-in-tty-faces '(default line-number magit-section-highlight))

  (defun on-frame-open (frame)
    (unless (display-graphic-p frame)
      (menu-bar-mode -1)
      (dolist (face no-background-in-tty-faces)
       (set-face-background face "unspecified" frame))))

  (mapc #'on-frame-open (frame-list))

  (add-hook 'after-make-frame-functions #'on-frame-open)

  (defun on-after-init ()
    (unless (display-graphic-p (selected-frame))
      (dolist (face no-background-in-tty-faces)
	(set-face-background face "unspecified" (selected-frame)))))

  (add-hook 'window-setup-hook #'on-after-init)
#+END_SRC

UI-related keybindings:
#+BEGIN_SRC emacs-lisp
  (jdormit/define-prefix "u" "UI")
  (leader-def-key "ut" #'customize-themes)
  (leader-def-key "uf" #'customize-face)
  (leader-def-key "uc" #'display-time-mode)
  (leader-def-key "ub" #'display-battery-mode)
#+END_SRC

* Centaur tabs
[[https://github.com/ema2159/centaur-tabs][Centaur tabs]] is a package that gives Emacs buffer tabs similar to those in Atom or VS Code:
#+BEGIN_SRC emacs-lisp
  (use-package centaur-tabs
    :commands (centaur-tabs-mode
               centaur-tabs-local-mode
               centaur-tabs-mode-on-p)
    :init
    (setq centaur-tabs-set-icons t
          centaur-tabs-gray-out-icons 'buffer
          centaur-tabs-height 30
          centaur-tabs-set-bar 'under
          x-underline-at-descent-line t
          centaur-tabs-set-modified-marker t
          centaur-tabs-show-navigation-buttons t
          centaur-tabs-down-tab-text " ☰ "
          centaur-tabs-backward-tab-text " ◀ "
          centaur-tabs-forward-tab-text " ▶ "
          centaur-tabs-close-button "✕"
          centaur-tabs-modified-marker "⬤"
          centaur-tabs-cycle-scope 'tabs
          centaur-tabs-label-fixed-length 20)
    (leader-def-key "uT" #'centaur-tabs-mode)
    (centaur-tabs-mode)
    :config
    (centaur-tabs-group-by-projectile-project)

    ;; Custom buffer groups
    (defun centaur-tabs-projectile-buffer-groups ()
    "Return the list of group names BUFFER belongs to."
    (if centaur-tabs-projectile-buffer-group-calc
        (symbol-value 'centaur-tabs-projectile-buffer-group-calc)
      (set (make-local-variable 'centaur-tabs-projectile-buffer-group-calc)

           (cond
            ((or (get-buffer-process (current-buffer))
                 (memq major-mode '(comint-mode compilation-mode))) '("Term"))
            ((string-equal "*" (substring (buffer-name) 0 1)) '("Misc"))
            ((condition-case _err
                 (projectile-project-root)
               (error nil)) (list (projectile-project-name)))
            ((memq major-mode '(emacs-lisp-mode python-mode emacs-lisp-mode c-mode
                                                c++-mode javascript-mode js-mode
                                                js2-mode makefile-mode
                                                lua-mode vala-mode)) '("Coding"))
            ((memq major-mode '(nxhtml-mode html-mode
                                            mhtml-mode css-mode)) '("HTML"))
            ((memq major-mode '(org-journal-mode)) '("Journal"))
            ((memq major-mode '(org-mode calendar-mode diary-mode)) '("Org"))
            ((memq major-mode '(dired-mode)) '("Dir"))
            (t '("Other"))))
      (symbol-value 'centaur-tabs-projectile-buffer-group-calc)))

    ;; Don't show tabs for certain types of buffers
    (advice-add 'centaur-tabs-hide-tab :around
                (lambda (oldfn buf &rest args)
                  (if (with-current-buffer buf
                        (or (eq major-mode 'vuiet-mode)
                            (eq major-mode 'dired-sidebar-mode)))
                      t
                    (apply oldfn buf args))))

    ;; Only show tabs in buffers visiting files
    (advice-add 'centaur-tabs-line :around
                (lambda (oldfn &rest args)
                  (if (buffer-file-name)
                      (apply oldfn args)
                    (setq header-line-format nil))))

    ;; Enable prefix argument for tab switching keybindings
    (advice-add 'centaur-tabs-forward :around
                (lambda (oldfn &rest args)
                  (if (numberp current-prefix-arg)
                      (dotimes (_ current-prefix-arg)
                        (apply oldfn args))
                    (apply oldfn args))))
    (advice-add 'centaur-tabs-backward :around
                (lambda (oldfn &rest args)
                  (if (numberp current-prefix-arg)
                      (dotimes (_ current-prefix-arg)
                        (apply oldfn args))
                    (apply oldfn args))))

    ;; Use Org-mode titles for tab names when possible
    (advice-add 'centaur-tabs-buffer-tab-label :around
                (lambda (oldfn tab &rest args)
                  (if-let ((title (or (car
                                       (org-roam-db--get-titles
                                        (buffer-file-name (car tab))))
                                   (org-get-title
                                    (with-current-buffer (car tab)
                                      (buffer-substring (point-min)
                                                        (min (point-max) 200)))))))
                      (if (> centaur-tabs-label-fixed-length 0)
                          (centaur-tabs-truncate-string centaur-tabs-label-fixed-length
                                                        (format " %s" title))
                        (format " %s" title))
                    (apply oldfn tab args))))

    ;; Add a cache to speed up icon rendering for huge groups
    (defvar centaur-tabs-icon-cache (make-hash-table :test 'equal)
      "A cache holding icons generated for centaur-tabs mode tabs.")
    (advice-add 'centaur-tabs-icon :around
                (lambda (oldfn tab face selected &rest args)
                  (let ((key (list tab face selected)))
                    (or (gethash key centaur-tabs-icon-cache)
                        (puthash key
                                 (apply oldfn tab face selected args)
                                 centaur-tabs-icon-cache)))))

    :general
    ((normal motion visual) "g t" #'centaur-tabs-forward)
    ((normal motion visual) "g T" #'centaur-tabs-backward)
    (leader-map "pt" #'centaur-tabs-counsel-switch-group)
    :hook
    (git-commit-mode . (lambda ()
                         (when (centaur-tabs-mode-on-p)
                           (centaur-tabs-local-mode)))))
#+END_SRC

* Frame parameters
Functions to change the frame size:
#+BEGIN_SRC emacs-lisp
  (defun jdormit/set-frame-size (width height)
    (interactive "nWidth: \nnHeight: ")
    (if (display-graphic-p)
	(set-frame-size (selected-frame) width height)
      (message "Not running graphically")))

  (defun jdormit/set-frame-width (width)
    (interactive "nWidth: ")
    (jdormit/set-frame-size width (frame-height)))

  (defun jdormit/set-frame-height (height)
    (interactive "nHeight: ")
    (jdormit/set-frame-size (frame-width) height))
#+END_SRC

Keybindings:
#+BEGIN_SRC emacs-lisp
  (leader-def-key "Fw" 'jdormit/set-frame-width)
  (leader-def-key "Fh" 'jdormit/set-frame-height)
  (leader-def-key "Fs" 'jdormit/set-frame-size)
#+END_SRC

* Transpose Frame
A handy utility that reverse the current frame window split (vertical to horizontal or vice-versa):
#+BEGIN_SRC emacs-lisp
  (use-package transpose-frame
    :defer t
    :init
    (leader-def-key "wt" 'transpose-frame))
#+END_SRC

* EShell
Easy keybinding to open EShell:
#+BEGIN_SRC emacs-lisp
  (defun open-eshell (&optional arg)
    (interactive "P")
    (if (and (fboundp 'projectile-project-root)
	     (projectile-project-root))
	(projectile-run-eshell arg)
      (eshell arg)))

  (leader-def-key "'" 'open-eshell)
#+END_SRC

Make EShell's tab completion work like Bash's:
#+BEGIN_SRC emacs-lisp
  (setq eshell-cmpl-cycle-completions nil)
#+END_SRC

Add additional useful modules:
#+BEGIN_SRC emacs-lisp
  (with-eval-after-load 'eshell
   (add-to-list 'eshell-modules-list 'eshell-tramp))
#+END_SRC

Prefer Lisp commands to external programs:
#+BEGIN_SRC emacs-lisp
  (setq eshell-prefer-lisp-functions t
        eshell-prefer-lisp-variables t)
#+END_SRC

Enable password caching:
#+BEGIN_SRC emacs-lisp
  (setq password-cache t
        password-cache-expiry 120)
#+END_SRC

Destroy shell buffers created by eshell when the process dies::
#+BEGIN_SRC emacs-lisp
  (setq eshell-destroy-buffer-when-process-dies t)
#+END_SRC

Visual programs:
#+BEGIN_SRC emacs-lisp
  (defun eshell-setup ()
    (add-to-list 'eshell-visual-commands "crawl")
    (add-to-list 'eshell-visual-commands "ssh"))

  (add-hook 'eshell-mode-hook #'eshell-setup)
#+END_SRC

And a function to run any program visually:
#+BEGIN_SRC emacs-lisp
  (defun eshell/v (&rest args)
    (apply #'eshell-exec-visual args))
#+END_SRC

Load .dir-locals.el when switching directories:
#+BEGIN_SRC emacs-lisp
  (add-hook 'eshell-mode-hook #'hack-dir-local-variables-non-file-buffer)
  (add-hook 'eshell-after-prompt-hook #'hack-dir-local-variables-non-file-buffer)
#+END_SRC

A function to properly clear the eshell:
#+BEGIN_SRC emacs-lisp
  (defun clear-eshell (&optional prefix)
    (interactive)
    (let ((input (eshell-get-old-input)))
      (eshell/clear-scrollback)
      (eshell-emit-prompt)
      (insert input)))

  (add-hook 'eshell-mode-hook
   (lambda () (general-def eshell-mode-map "C-c C-o" #'clear-eshell)))
#+END_SRC

Some aliases:
#+BEGIN_SRC emacs-lisp
  (setq eshell-aliases
    '(("k" . "kubectl $*")
      ("kctx" . "kubectx $*")
      ("root" . "cd (projectile-project-root)")))
  (add-hook
   'eshell-mode-hook
   (lambda ()
     (dolist (alias eshell-aliases)
       (eshell/alias (car alias) (cdr alias)))))
#+END_SRC

** Prompt
#+BEGIN_SRC emacs-lisp
  (defun jdormit-eshell-prompt ()
    (let ((branch (magit-name-local-branch "HEAD")))
     (format "%s%s"
       (if branch (format "(%s) " branch) "")
       (concat (abbreviate-file-name (eshell/pwd))
	 (if (= (user-uid) 0) " # " " $ ")))))

  (setq jdormit-eshell-prompt-regex "^[^#$\n]* [#$] ")

  (setq eshell-prompt-function 'jdormit-eshell-prompt)
  (setq eshell-prompt-regexp jdormit-eshell-prompt-regex)
#+END_SRC

* Flycheck
Syntax checking etc.:
#+BEGIN_SRC emacs-lisp
  (use-package flycheck
    :init
    (defhydra hydra-flycheck
      (:pre (flycheck-list-errors)
	    :post (quit-windows-on "*Flycheck errors*")
	    :hint nil)
      "Errors"
      ("f" flycheck-error-list-set-filter "Filter")
      ("j" flycheck-next-error "Next")
      ("k" flycheck-previous-error "Previous")
      ("gg" flycheck-first-error "First")
      ("G" (progn (goto-char (point-max)) (flycheck-previous-error)) "Last")
      ("q" nil))
    :config
    (setq-default flycheck-disabled-checkers '(emacs-lisp emacs-lisp-checkdoc))
    (global-flycheck-mode)
    :general
    ((normal motion visual) flycheck-mode-map "ze" 'hydra-flycheck/body))
#+END_SRC

* Tabs
#+BEGIN_SRC emacs-lisp
  (defun disable-tab-insert ()
    (interactive)
    (setq indent-tabs-mode nil))
#+END_SRC

* aggressive-indent-mode
Like [[help:electric-indent-mode][electric-indent-mode]] but reindents after every change:
#+BEGIN_SRC emacs-lisp
  (use-package aggressive-indent
    :hook ((clojure-mode . aggressive-indent-mode)
           (emacs-lisp-mode . aggressive-indent-mode)))
#+END_SRC

* JSON
#+BEGIN_SRC emacs-lisp
  (use-package json-mode
    :mode (("\\.json\\'" . json-mode)))

  (use-package json-navigator
    :commands (json-navigator-navigator
               json-navigator-navigate-after-point
               json-navigator-navigate-region))

  (use-package tree-mode
    :general
    (normal tree-mode-map
            "D" #'tree-mode-delete-tree
            "k" #'tree-mode-previous-node
            "j" #'tree-mode-next-node
            "l" #'tree-mode-next-sib
            "h" #'tree-mode-previous-sib
            "u" #'tree-mode-goto-parent
            "r" #'tree-mode-goto-root
            "gr" #'tree-mode-reflesh
            "E" #'tree-mode-expand-level
            "e" #'tree-mode-toggle-expand
            "s" #'tree-mode-sort-by-tag
            "/" #'tree-mode-keep-match
            "!" #'tree-mode-collapse-other-except)
    :hook
    ((json-navigator-mode . tree-minor-mode)))

  (defun json-pprint ()
    (interactive)
    (let ((begin (if (region-active-p) (region-beginning) (point-min)))
          (end (if (region-active-p) (region-end) (point-max))))
      (if (executable-find "jq")
          (shell-command-on-region begin end "jq ." nil t)
        (json-pretty-print begin end))))

  (general-def json-mode-map "C-M-\\" 'json-pprint)
#+END_SRC

* JavaScript
Some formatting stuff:
#+BEGIN_SRC emacs-lisp
  (setq js-indent-level 4)
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (use-package web-mode
    :mode (("\\.html\\'" . web-mode)
	   ("\\.js\\'" . web-mode)
	   ("\\.jsx\\'" . web-mode)
	   ("\\.mako\\'" . web-mode)
	   ("\\.jinja2\\'" . web-mode)
	   ("\\.hbs\\'" . web-mode))
    :config
    (setq web-mode-engines-alist
	  '(("django" . "\\.jinja2\\'")))
    (add-hook 'web-mode-hook
	      (lambda ()
		(when (equal web-mode-content-type "javascript")
		  (web-mode-set-content-type "jsx"))
		(when (or (equal web-mode-content-type "javascript")
			  (equal web-mode-content-type "jsx"))
		  (lsp-deferred))))
    (add-hook 'web-mode-hook #'disable-tab-insert))
#+END_SRC

Use nvm to manage node versions:
#+BEGIN_SRC emacs-lisp
  (use-package nvm
    :straight ((nvm :host github :repo "rejeep/nvm.el"))
    :commands (nvm-use nvm-use-for nvm-use-for-buffer))
#+END_SRC

A command to format JS via prettier:
#+BEGIN_SRC emacs-lisp
  (defun prettier ()
    (interactive)
    (let ((start (if (use-region-p) (region-beginning) (point-min)))
	  (end (if (use-region-p) (region-end) (point-max)))
	  (parser (cond
		   ((eq major-mode 'graphql-mode) "graphql")
		   (t "babel"))))
      (shell-command-on-region start end (concat "prettier --parser " parser) nil t)))
#+END_SRC

** NVM
Manage node version via NVM within Emacs:
#+BEGIN_SRC emacs-lisp
  (use-package nvm
    :commands (nvm-use
	       nvm-use-for
	       nvm-use-for-buffer
	       nvm--installed-versions)
    :init
    (defun nvm (version)
      (interactive (list
		    (completing-read "Node version: "
		     (mapcar #'car
			     (nvm--installed-versions)))))
      (nvm-use version)))
#+END_SRC

* Java
#+BEGIN_SRC emacs-lisp
  (use-package lsp-java
    :hook ((java-mode . lsp-deferred)))
#+END_SRC

* Kotlin
#+BEGIN_SRC emacs-lisp
  (use-package kotlin-mode
    :mode (("\\.kt\\'" . kotlin-mode))
    :config
    (with-eval-after-load 'lsp
      (when (executable-find "kotlin-language-server")
	(add-hook 'kotlin-mode-hook #'lsp-deferred))))
#+END_SRC

* Groovy
Used for Jenkins configuration scripts and probably other things.
#+BEGIN_SRC emacs-lisp
  (use-package groovy-mode
    :commands (groovy-mode)
    :mode (("\\.groovy\\'" . groovy-mode))
    :init
    (add-to-list 'interpreter-mode-alist
		 '("groovy" . groovy-mode))
    :custom
    (groovy-indent-offset 2))
#+END_SRC

* Typescript
#+BEGIN_SRC emacs-lisp
  (use-package typescript-mode
    :mode ("\\.ts\\'")
    :config
    (with-eval-after-load 'lsp
      (add-hook 'typescript-mode-hook 'lsp-deferred)))
#+END_SRC

* LSP Mode
Emacs support for the Language Server Protocol

#+BEGIN_SRC emacs-lisp
  (use-package lsp-mode
    :defer t
    :init
    (defhydra hydra-lsp (:exit t :hint nil)
      "
   Buffer^^               Server^^                   Symbol
  -------------------------------------------------------------------------------------
   [_f_] format           [_M-r_] restart            [_d_] declaration  [_i_] implementation  [_o_] documentation
   [_m_] imenu            [_S_]   shutdown           [_D_] definition   [_t_] type            [_r_] rename
   [_x_] execute action   [_M-s_] describe session   [_R_] references   [_s_] signature"
      ("d" lsp-find-declaration)
      ("D" lsp-ui-peek-find-definitions)
      ("R" lsp-ui-peek-find-references)
      ("i" lsp-ui-peek-find-implementation)
      ("t" lsp-find-type-definition)
      ("s" lsp-signature-help)
      ("o" lsp-describe-thing-at-point)
      ("r" lsp-rename)

      ("f" lsp-format-buffer)
      ("m" lsp-ui-imenu)
      ("x" lsp-execute-code-action)

      ("M-s" lsp-describe-session)
      ("M-r" lsp-restart-workspace)
      ("S" lsp-shutdown-workspace))
    :general
    (lsp-mode-map "C-c h" 'hydra-lsp/body)
    ((normal visual motion) lsp-mode-map "K" #'lsp-describe-thing-at-point)
    :hook
    ((lsp-mode . (lambda ()
                   (let ((lsp-keymap-prefix "gl"))
                     (lsp-enable-which-key-integration)))))
    :config
    (setq lsp-prefer-flymake nil)
    (general-def '(normal visual motion) "gl" lsp-command-map)
    :commands lsp-mode lsp lsp-deferred
    :custom
    (lsp-enable-snippet nil)
    (lsp-eldoc-render-all nil))

  (use-package lsp-ui
    :after (lsp-mode)
    :custom
    (lsp-ui-sideline-enable t)
    (lsp-ui-sideline-show-symbol t)
    (lsp-ui-sideline-show-hover t)
    (lsp-ui-sideline-show-code-actions t)
    (lsp-ui-sideline-update-mode 'point)
    (lsp-ui-doc-alignment 'window)
    (lsp-ui-doc-header t)
    (lsp-ui-doc-position 'top)
    (lsp-ui-doc-background '((t (:inherit region))))
    (lsp-ui-doc-header '((t (:inherit lsp-face-highlight-write))))
    (lsp-ui-sideline-current-symbol '((t (:inherit font-lock-constant-face
                                                   :weight ultra-bold)))))

  (with-eval-after-load 'lsp-clients
    (defun lsp-typescript-javascript-tsx-jsx-activate-p (filename major-mode)
      "Checks if the javascript-typescript language server should be enabled
    based on FILE-NAME and MAJOR-MODE"
      (or (member major-mode '(typescript-mode typescript-tsx-mode js-mode js2-mode rjsx-mode))
          (and (eq major-mode 'web-mode)
               (or (string-suffix-p ".tsx" filename t)
                   (string-suffix-p ".jsx" filename t)
                   (string-suffix-p ".js" filename t))))))
#+END_SRC

* Python
** General
#+BEGIN_SRC emacs-lisp
  (leader-def-key "sp" #'run-python)
  (add-hook 'python-mode-hook #'disable-tab-insert)
#+END_SRC

ISort is a Python utility to sort imports:
#+BEGIN_SRC emacs-lisp
  (use-package py-isort
    :commands (py-isort-buffer py-isort-region)
    :config
    (setq py-isort-options '("-m=3"))
    :general
    (python-mode-map "C-c C-i" #'py-isort-buffer))
#+END_SRC

Run black on the current buffer:
#+BEGIN_SRC emacs-lisp
  (general-def 'normal python-mode-map "C-M-\\" #'format-all-buffer)
#+END_SRC

[[https://github.com/naiquevin/sphinx-doc.el][sphinx-doc.el]] automatically generates doc strings for Python functions (and updates existing ones!):
#+BEGIN_SRC emacs-lisp
  (use-package sphinx-doc
    :hook ((python-mode . sphinx-doc-mode)))
#+END_SRC

** Dev environment/IDE stuff
Support pyvenv within Emacs:
#+BEGIN_SRC emacs-lisp
  (use-package pyvenv
    :defer 0
    :commands (pyvenv-mode
               pyvenv-tracking-mode
               pyvenv-workon
               pyvenv-activate
               pyvenv-track-virtualenv)
    :config
    (pyvenv-mode)
    (pyvenv-tracking-mode))

  (defun eshell/workon (name)
    (pyvenv-workon name))

  (defun eshell/activate (dir)
    (pyvenv-activate dir))

  (defun eshell/deactivate ()
    (pyvenv-deactivate))
#+END_SRC

And support pyenv (NOT pyvenv) to change Python versions:
#+BEGIN_SRC emacs-lisp
  (use-package pyenv-mode
    :defer t)
#+END_SRC

Use the LSP python client:
#+BEGIN_SRC emacs-lisp
  (use-package lsp-python-ms
    :init
    (setq lsp-python-ms-auto-install-server t)
    (defun python-lsp ()
      (require 'lsp-python-ms)
      (lsp-deferred))
    :hook
    (python-mode . python-lsp)
    :general
    (python-mode-map "C-c C-d" #'lsp-describe-thing-at-point))

  (general-def 'normal python-mode-map "C-c C-d" #'lsp-describe-thing-at-point)
#+END_SRC

Override the flycheck python-mypy checker to run in the right
directory:
#+BEGIN_SRC emacs-lisp
  (flycheck-define-checker python-mypy
    "Mypy syntax and type checker.  Requires mypy>=0.580.

  See URL `http://mypy-lang.org/'."
    :command ("mypy"
              "--show-column-numbers"
              (config-file "--config-file" flycheck-python-mypy-config)
              (option "--cache-dir" flycheck-python-mypy-cache-dir)
              source-original)
    :error-patterns
    ((error line-start (file-name) ":" line (optional ":" column)
            ": error:" (message) line-end)
     (warning line-start (file-name) ":" line (optional ":" column)
              ": warning:" (message) line-end)
     (info line-start (file-name) ":" line (optional ":" column)
           ": note:" (message) line-end))
    :modes python-mode
    ;; Ensure the file is saved, to work around
    ;; https://github.com/python/mypy/issues/4746.
    :predicate flycheck-buffer-saved-p
    :working-directory (lambda (checker)
                         (projectile-compilation-dir)))
#+END_SRC


** Autoflake
[[https://pypi.org/project/autoflake/][Autoflake]] is a tool that removes unused imports and variables from Python code:
#+BEGIN_SRC emacs-lisp
  (defvar autoflake-args '()
    "Arguments to pass to the autoflake command.

  See URL `https://pypi.org/project/autoflake' for options.")

  (defun autoflake (arg)
    (interactive "P")
    (let ((autoflake-cmd (or (executable-find "autoflake")
			     (error "Autoflake executable not found")))
	  (file (cond
		 ((or arg (not buffer-file-name))
		  (read-file-name "Run autoflake on file: "))
		 (buffer-file-name buffer-file-name)
		 (:else (error "Invalid file for autoflake")))))
      (apply #'call-process autoflake-cmd nil nil nil
	     (append autoflake-args (list "--in-place" file)))))
#+END_SRC

** Testing
[[https://github.com/wbolster/emacs-python-pytest][python-pytest.el]] integrates Pytest with Emacs:
#+BEGIN_SRC emacs-lisp
  (use-package  python-pytest
    :commands (python-pytest-popup
	       python-pytest--current-defun)
    :general
    (python-mode-map "C-c t p" #'python-pytest-popup)
    ((normal motion visual) python-pytest-mode-map "g r" #'python-pytest-repeat)
    ((normal motion visual) python-pytest-mode-map "q" #'quit-window))
#+END_SRC

And borrowing some functions from python-pytest, we can get some nosetests support as well:
#+BEGIN_SRC emacs-lisp
  (defvar nosetests-args ""
    "Additional args to pass to nosetests")

  (defun run-nose (args &optional debug)
    "Runs nosetests with `args'

  If `debug' is non-nil, run in a GUD PDB session."
    (let* ((nosetests-cmd (executable-find "nosetests"))
	   (cmdline (format "%s %s" nosetests-cmd args)))
      (when (not nosetests-cmd)
	(user-error "Nosetests command not found"))
      (if debug
	  (realgud:pdb cmdline)
	(compile cmdline))))

  (defun run-nose-reading-args (arg nose-args &optional debug)
    "Runs nosetests with default args or prompts for args with prefix

  If `debug' is non-nil, run in a GUD PDB session."
    (let ((args (if arg
		    (read-string "Nosetests arguments: "
				 nil nil nosetests-args)
		  nosetests-args)))
      (run-nose (format "%s %s" args nose-args) debug)))

  (defun run-nose-in-project (arg nose-args &optional debug)
    "Runs nosetests from the project root

  If `debug' is non-nil, run in a GUD PDB session."
    (let ((dir (or (projectile-project-root)
		   default-directory)))
      (with-temp-buffer
	(cd dir)
	(run-nose-reading-args arg nose-args debug))))

  (defun nosetests-all (arg)
    "Runs nosetests on all project tests, prompting for the tests directory"
    (interactive "P")
    (let ((test-dir (read-file-name "Test directory: "
				    (or (projectile-project-root)
					default-directory)
				    nil t "tests" #'directory-name-p)))
      (run-nose-in-project arg (directory-file-name test-dir))))

  (defun nosetests-debug-all (arg)
    "Runs nosetests in a GUD session on all project tests"
    (interactive "P")
    (let ((test-dir (read-file-name "Test directory: "
				    (or (projectile-project-root)
					default-directory)
				    nil t "tests" #'directory-name-p)))
      (run-nose-in-project arg (directory-file-name test-dir) t)))

  (defun nosetests-module (arg module)
    "Runs nosetests in the module of the current file"
    (interactive (list current-prefix-arg
		       (read-file-name "Run nosetests on module: "
				       nil nil t
				       (file-name-directory
					(buffer-file-name))
				       #'directory-name-p)))
    (run-nose-in-project arg (directory-file-name module)))

  (defun nosetests-debug-module (arg module)
    "Runs nosetests in a GUD session in the module of the current file"
    (interactive (list current-prefix-arg
		       (read-file-name "Run nosetests on module: "
				       nil nil t
				       (file-name-directory
					(buffer-file-name))
				       #'directory-name-p)))
    (run-nose-in-project arg (directory-file-name module) t))

  (defun nosetests-file (arg file)
    "Runs nosetests on the current file"
    (interactive (list current-prefix-arg
		       (read-file-name "Run nosetests on file: "
				       nil nil t (buffer-file-name))))
    (run-nose-in-project arg file))

  (defun nosetests-debug-file (arg file)
    "Runs nosetests in a GUD session on the current file"
    (interactive (list current-prefix-arg
		       (read-file-name "Run nosetests on file: "
				       nil nil t (buffer-file-name))))
    (run-nose-in-project arg file t))

  (defun nosetests-def (arg def)
    "Runs nosetests on the enclosing function at point"
    (interactive (list current-prefix-arg
		       (python-pytest--current-defun)))
    (run-nose-in-project arg (format "%s:%s"
				     (buffer-file-name)
				     def)))

  (defun nosetests-debug-def (arg def)
    "Runs nosetests in a GUD session on the enclosing function at point"
    (interactive (list current-prefix-arg
		       (python-pytest--current-defun)))
    (run-nose-in-project arg
			 (format "%s:%s"
				 (buffer-file-name)
				 def)
			 t))

  (defvar nosetests-map (make-sparse-keymap)
    "Keymap for nosetests")

  (defvar nosetests-debug-map (make-sparse-keymap)
    "Keymap for debugging nosetests")

  (general-def python-mode-map "C-c t n" nosetests-map)
  (general-def nosetests-map "a" #'nosetests-all)
  (general-def nosetests-map "m" #'nosetests-module)
  (general-def nosetests-map "f" #'nosetests-file)
  (general-def nosetests-map "d" #'nosetests-def)
  (general-def nosetests-map "b" nosetests-debug-map)

  (general-def nosetests-debug-map "a" #'nosetests-debug-all)
  (general-def nosetests-debug-map "m" #'nosetests-debug-module)
  (general-def nosetests-debug-map "f" #'nosetests-debug-file)
  (general-def nosetests-debug-map "d" #'nosetests-debug-def)

  (which-key-add-major-mode-key-based-replacements
    'python-mode "C-c t n" "nosetests")
  (which-key-add-major-mode-key-based-replacements
    'python-mode "C-c t n b" "debug")
#+END_SRC

* Hy
Python but Lispy!

#+BEGIN_SRC emacs-lisp
  (defun run-hy ()
    (interactive)
    (run-lisp (expand-file-name "~/.virtualenvs/hy/bin/hy")))
#+END_SRC

* Go
Basic support:
#+BEGIN_SRC emacs-lisp
  (use-package go-mode
    :mode (("\\.go\\'" . go-mode)))
#+END_SRC

LSP support - requires [[https://github.com/sourcegraph/go-langserver][go-langserver]].
#+BEGIN_SRC emacs-lisp
  (add-hook 'go-mode-hook #'lsp-deferred)
#+END_SRC

* Clojure
Start with clojure-mode:
#+BEGIN_SRC emacs-lisp
  (use-package clojure-mode
    :mode (("\\.clj\\'" . clojure-mode)
           ("\\.cljs\\'" . clojurescript-mode)
           ("\\.cljc\\'" . clojurec-mode)
           ("\\.edn\\'" . clojure-mode))
    :config
    (define-clojure-indent
      (defroutes 'defun)
      (GET 2)
      (POST 2)
      (PUT 2)
      (DELETE 2)
      (HEAD 2)
      (ANY 2)
      (OPTIONS 2)
      (PATCH 2)
      (rfn 2)
      (let-routes 1)
      (context 2)
      (:= 3)
      (:+ 3)
      (match 1)))
#+END_SRC

Add flycheck support:
#+BEGIN_SRC emacs-lisp
  (use-package flycheck-clj-kondo
    :after (clojure-mode)
    :if (executable-find "clj-kondo")
    :ensure t)
#+END_SRC

Sprinkle in some CIDER:
#+BEGIN_SRC emacs-lisp
  (use-package cider
    :commands (cider-mode cider-jack-in cider-jack-in-clojurescript)
    :config
    (setq cider-known-endpoints
	  '(("local" "localhost" "4005"))
	  cider-prompt-for-symbol nil)
    (general-def cider-mode-map "C-c t" cider-test-commands-map)
    (add-hook 'cider-repl-mode-hook 'smartparens-strict-mode)
    :hook ((clojure-mode . cider-mode)
	   (clojurescript-mode . cider-mode)
	   (clojurec-mode . cider-mode))
    :general
    (cider-stacktrace-mode-map "SPC" leader-map)
    ('normal cider-mode-map "M-." #'cider-find-var))

  (defun jdormit/cider-setup ()
    (local-set-key (kbd "C-c M-b") 'cider-debug-defun-at-point))

  (add-hook 'cider-mode-hook 'jdormit/cider-setup)
#+END_SRC

Add some handy hydras:
#+BEGIN_SRC emacs-lisp
  (use-package cider-hydra
    :after (cider)
    :hook ((cider-mode . cider-hydra-mode)))
#+END_SRC

Clj-refactor adds magical refactoring abilities:
#+BEGIN_SRC emacs-lisp
  (use-package clj-refactor
    :init
    (defun clj-refactor-setup ()
      (interactive)
      (clj-refactor-mode 1)
      (cljr-add-keybindings-with-prefix "C-c r"))
    :config
    (setq cljr-auto-sort-ns t)
    :hook ((clojure-mode . clj-refactor-setup)))
#+END_SRC

Add support for running Org-mode Clojure source blocks with [[https://github.com/borkdude/babashka][Babashka]]:
#+BEGIN_SRC emacs-lisp
  (with-eval-after-load 'ob-clojure
    (defcustom org-babel-clojure-backend nil
      "Backend used to evaluate Clojure code blocks."
      :group 'org-babel
      :type '(choice
              (const :tag "inf-clojure" inf-clojure)
              (const :tag "cider" cider)
              (const :tag "slime" slime)
              (const :tag "bb" bb)
              (const :tag "Not configured yet" nil)))

    (defun elisp->clj (in)
      (cond
       ((listp in) (concat "[" (s-join " " (mapcar #'elisp->clj in)) "]"))
       (t (format "%s" in))))

    (defun ob-clojure-eval-with-bb (expanded params)
      "Evaluate EXPANDED code block with PARAMS using babashka."
      (unless (executable-find "bb")
        (user-error "Babashka not installed"))
      (let* ((stdin (let ((stdin (cdr (assq :stdin params))))
                      (when stdin
                        (elisp->clj
                         (org-babel-ref-resolve stdin)))))
             (input (cdr (assq :input params)))
             (file (make-temp-file "ob-clojure-bb" nil nil expanded))
             (command (concat (when stdin (format "echo %s | " (shell-quote-argument stdin)))
                              (format "bb %s -f %s"
                                      (cond
                                       ((equal input "edn") "")
                                       ((equal input "text") "-i")
                                       (t ""))
                                      (shell-quote-argument file))))
             (result (shell-command-to-string command)))
        (s-trim result)))

    (defun org-babel-execute:clojure (body params)
      "Execute a block of Clojure code with Babel."
      (unless org-babel-clojure-backend
        (user-error "You need to customize org-babel-clojure-backend"))
      (let* ((expanded (org-babel-expand-body:clojure body params))
             (result-params (cdr (assq :result-params params)))
             result)
        (setq result
              (cond
               ((eq org-babel-clojure-backend 'inf-clojure)
                (ob-clojure-eval-with-inf-clojure expanded params))
               ((eq org-babel-clojure-backend 'cider)
                (ob-clojure-eval-with-cider expanded params))
               ((eq org-babel-clojure-backend 'slime)
                (ob-clojure-eval-with-slime expanded params))
               ((eq org-babel-clojure-backend 'bb)
                (ob-clojure-eval-with-bb expanded params))))
        (org-babel-result-cond result-params
          result
          (condition-case nil (org-babel-script-escape result)
            (error result)))))

    (customize-set-variable 'org-babel-clojure-backend 'bb))

  (add-hook 'org-mode-hook (lambda () (require 'ob-clojure)))
#+END_SRC

* Scheme
Tell emacs about file extensions which should activate scheme-mode:
#+BEGIN_SRC emacs-lisp
  (add-to-list 'auto-mode-alist '("\\.guile\\'" . scheme-mode))
  (add-to-list 'auto-mode-alist '("\\.rkt\\'" . scheme-mode))
#+END_SRC
[[http://www.nongnu.org/geiser/geiser_1.html][Geiser]] is a Scheme IDE for Emacs that supports a bunch of common Scheme implementations.
#+BEGIN_SRC emacs-lisp
  (use-package geiser
    :commands (run-geiser)
    :general
    (geiser-debug-mode-map "SPC" leader-map))
#+END_SRC

And a handy shortcut to hop into a Geiser REPL:
#+BEGIN_SRC emacs-lisp
  (leader-def-key "sg" 'run-geiser)
#+END_SRC

* Common Lisp
[[https://common-lisp.net/project/slime/][SLIME]] is a set of modes and utilities for writing Common Lisp in Emacs. [[https://www.quicklisp.org/beta/][Quicklisp]] is the de-facto Common Lisp package manager. It comes with some Emacs bindings.
#+BEGIN_SRC emacs-lisp
  (use-package slime-company
    :after (slime))

  (use-package slime
    :commands (slime)
    :config
    (setq inferior-lisp-program
	  (executable-find "sbcl")
	  slime-contribs '(slime-repl
			   slime-fancy
			   slime-company))
    (when (file-exists-p
	   (expand-file-name "~/quicklisp/slime-helper.el"))
      (load (expand-file-name "~/quicklisp/slime-helper.el")))
    (add-hook 'slime-repl-mode-hook 'smartparens-strict-mode)
    :general
    ((normal motion visual insert emacs) slime-mode-map "M-." #'slime-edit-definition))

    (add-to-list 'auto-mode-alist '("\\.cl\\'" . lisp-mode))
#+END_SRC

Keyboard shortcut to start a SLIME REPL:
#+BEGIN_SRC emacs-lisp
  (leader-def-key "sc" 'slime)
#+END_SRC

* Haskell
#+BEGIN_SRC emacs-lisp
  (defun jdormit/haskell-setup ()
    (local-set-key (kbd "C-c M-j") 'interactive-haskell-mode))
  (use-package haskell-mode
    :mode (("\\.hs\\'" . haskell-mode)))
  (add-hook 'haskell-mode-hook 'jdormit/haskell-setup)
#+END_SRC

* PHP
#+BEGIN_SRC emacs-lisp
  (use-package php-mode
    :mode "\\.php\\'")

  (use-package mmm-mode
    :after php-mode)
#+END_SRC

Geben is an interface to XDebug allowing debugging PHP in Emacs:
#+BEGIN_SRC emacs-lisp
  (use-package geben
    :commands (geben))
#+END_SRC

Some keybindings to start and end Geben:
#+BEGIN_SRC emacs-lisp
  (general-def php-mode-map "C-c C-d" #'geben)
  (general-def php-mode-map "C-c C-q" #'geben-end)
#+END_SRC

An Eshell alias to start PHP using XDebug:
#+BEGIN_SRC emacs-lisp
  (add-hook 'eshell-mode-hook
	    (lambda ()
	      (eshell/alias "php-debug"
			    "php -d xdebug.remote_enable=on -d xdebug.remote_host=127.0.0.1 -d xdebug.remote_port=9000 -d xdebug.remote_handler=dbgp -d xdebug.idekey=geben -d xdebug.remote_autostart=On $*")))
#+END_SRC

LSP for PHP requires [[https://github.com/felixfbecker/php-language-server][php-language-server]] to be installed in ~/.composer:
#+BEGIN_SRC emacs-lisp
  (add-hook 'php-mode-hook #'lsp-deferred)
#+END_SRC

* YAML
#+BEGIN_SRC emacs-lisp
  (use-package yaml-mode
    :mode ("//.yml//'"))
#+END_SRC

* Pharen
[[https://pharen.org][Pharen]] is a Lisp that compiles to PHP. It looks a lot like Clojure.
#+BEGIN_SRC emacs-lisp
  (add-to-list 'auto-mode-alist '("\\.phn\\'" . clojure-mode))
#+END_SRC

* Bash
Use LSP if [[https://github.com/mads-hartmann/bash-language-server][bash-language-server]] is installed.
#+BEGIN_SRC emacs-lisp
  (when (executable-find "bash-language-server")
    (add-hook 'sh-mode-hook #'lsp-deferred))
#+END_SRC

* Ruby
#+BEGIN_SRC emacs-lisp
  (add-hook 'ruby-mode-hook #'lsp-deferred)
#+END_SRC

* Rust
#+BEGIN_SRC emacs-lisp
  (use-package rust-mode
    :mode "\\.rs\\'"
    :general
    (rust-mode-map "C-c " #'rust-format-buffer)
    :config
    (add-hook 'rust-mode-hook #'lsp-deferred))


  (use-package cargo
    :after (rust-mode)
    :config
    (add-hook 'rust-mode-hook #'cargo-minor-mode))
#+END_SRC

* XML
Set up hideshow for nXML mode:
#+BEGIN_SRC emacs-lisp
  (add-hook 'nxml-mode-hook #'hs-minor-mode)

  (add-to-list 'hs-special-modes-alist
	       '(nxml-mode
		 "\\|]*[^/]>" ;; regexp for end block
		 "