all repos — archive/dotfiles @ c15bd0732c9530d739d05b77ca80979ffd33494d

Superseded by nixfiles

Emacs: Reformat code in init file
Alan Pearce alan@alanpearce.uk
Mon, 05 Dec 2016 12:54:16 +0100
commit

c15bd0732c9530d739d05b77ca80979ffd33494d

parent

7ac31a866b7698826817e742d1db5126fcf57ae0

1 files changed, 1015 insertions(+), 1015 deletions(-)

jump to
M tag-emacs/emacs.d/init.orgtag-emacs/emacs.d/init.org
@@ -22,13 +22,13 @@ programming mode in one, then I’ll just call it manually.  I also like the buffer to be empty.
 #+BEGIN_SRC emacs-lisp
   (setq initial-scratch-message ""
-    initial-major-mode 'text-mode)
+        initial-major-mode 'text-mode)
 #+END_SRC
 
 ** Personal Information
 #+BEGIN_SRC emacs-lisp
   (setq user-mail-address "alan@alanpearce.co.uk"
-    user-full-name "Alan Pearce")
+        user-full-name "Alan Pearce")
 #+end_src
 
 * Packaging
@@ -37,34 +37,34 @@ ** Use-package 
 #+BEGIN_SRC emacs-lisp
   (eval-and-compile
-  (setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
-               ("marmalade" . "http://marmalade-repo.org/packages/")
-               ("melpa-stable" . "http://stable.melpa.org/packages/")
-               ("melpa" . "http://melpa.org/packages/"))
-      package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa")
-      package-pinned-packages '(("use-package" . melpa-stable)
-                  ("diminish" . melpa-stable)
-                  ("bind-key" . melpa-stable))
-      package-archive-priorities '(("melpa-stable" . 10)
-                     ("gnu" . 10)
-                     ("marmalade" . 5)
-                     ("melpa" . 0))
-      package-menu-async t
-      package-menu-hide-low-priority t)
-  (package-initialize)
-  (unless (package-installed-p 'use-package)
-    (package-refresh-contents)
-    (package-install 'use-package)))
+    (setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
+                             ("marmalade" . "http://marmalade-repo.org/packages/")
+                             ("melpa-stable" . "http://stable.melpa.org/packages/")
+                             ("melpa" . "http://melpa.org/packages/"))
+          package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa")
+          package-pinned-packages '(("use-package" . melpa-stable)
+                                    ("diminish" . melpa-stable)
+                                    ("bind-key" . melpa-stable))
+          package-archive-priorities '(("melpa-stable" . 10)
+                                       ("gnu" . 10)
+                                       ("marmalade" . 5)
+                                       ("melpa" . 0))
+          package-menu-async t
+          package-menu-hide-low-priority t)
+    (package-initialize)
+    (unless (package-installed-p 'use-package)
+      (package-refresh-contents)
+      (package-install 'use-package)))
   (eval-when-compile (require 'use-package))
   (unless (featurep 'use-package)
-  (require 'diminish)
-  (require 'bind-key)
-  (use-package use-package
-    :commands (use-package-autoload-keymap)
-    :defer 5))
+    (require 'diminish)
+    (require 'bind-key)
+    (use-package use-package
+      :commands (use-package-autoload-keymap)
+      :defer 5))
   (setq use-package-verbose t
-    use-package-always-ensure t
-    package-enable-at-startup nil)
+        use-package-always-ensure t
+        package-enable-at-startup nil)
 #+END_SRC
 
 * Customize
@@ -83,30 +83,30 @@ * Styles 
 I prefer an always-visible cursor.  Feels less distracting.
 #+BEGIN_SRC emacs-lisp
-(when (fboundp #'blink-cursor-mode)
-  (blink-cursor-mode -1))
+  (when (fboundp #'blink-cursor-mode)
+    (blink-cursor-mode -1))
 #+END_SRC
 
 Disable all the bars, unless on OSX, in which case, keep the menu bar.
 
 #+BEGIN_SRC emacs-lisp
   (when (and menu-bar-mode (not (eq window-system 'ns)))
-  (menu-bar-mode -1))
+    (menu-bar-mode -1))
   (with-eval-after-load 'scroll-bar
-  (set-scroll-bar-mode nil))
+    (set-scroll-bar-mode nil))
   (with-eval-after-load 'tooltip
-  (tooltip-mode -1))
+    (tooltip-mode -1))
   (with-eval-after-load 'tool-bar
-  (tool-bar-mode -1))
+    (tool-bar-mode -1))
 #+END_SRC
 
 Ring the bell sometimes, but not so often
 #+BEGIN_SRC emacs-lisp
-(setq ring-bell-function
-    (lambda ()
-    (unless (memq this-command
-            '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit undo-tree-undo))
-      (ding))))
+  (setq ring-bell-function
+        (lambda ()
+          (unless (memq this-command
+                        '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit undo-tree-undo))
+            (ding))))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
@@ -119,27 +119,27 @@ I quite like solarized.  I don’t think it’s perfect, but it supports a lot of modes.
 #+BEGIN_SRC emacs-lisp
   (use-package solarized-theme
-  :disabled t
-  :config (progn
-        (setq solarized-distinct-fringe-background t)
-        (setq solarized-high-contrast-mode-line t)
-        (load-theme 'solarized-light t)))
+    :disabled t
+    :config (progn
+              (setq solarized-distinct-fringe-background t)
+              (setq solarized-high-contrast-mode-line t)
+              (load-theme 'solarized-light t)))
 #+END_SRC
 
 Let’s try a more minimal theme.
 
 #+BEGIN_SRC emacs-lisp
   (use-package minimal-theme
-  :config (progn
-        (load-theme 'minimal-light t)))
+    :config (progn
+              (load-theme 'minimal-light t)))
 #+END_SRC
 
 Highlighting quasi-quoted expressions in lisps is quite useful.
 #+BEGIN_SRC emacs-lisp
   (use-package highlight-stages
-  :diminish highlight-stages-mode
-  :config (progn
-        (add-hook 'lisp-mode-common-hook #'highlight-stages-mode)))
+    :diminish highlight-stages-mode
+    :config (progn
+              (add-hook 'lisp-mode-common-hook #'highlight-stages-mode)))
 #+END_SRC
 
 ** Fonts
@@ -185,7 +185,7 @@ Reduce font decoration.  I’m trying to see whether this helps me focus on the right things.
 #+BEGIN_SRC emacs-lisp
   (setq font-lock-maximum-decoration '((dired-mode . 1)
-                     (t . 1)))
+                                       (t . 1)))
 #+END_SRC
 
 ** Page Breaks
@@ -197,14 +197,14 @@ correct, at least for Liberation Mono. 
 #+BEGIN_SRC emacs-lisp
   (use-package page-break-lines
-  :defer 5
-  :diminish page-break-lines-mode
-  :config (progn
-        (global-page-break-lines-mode)
-        (unless (eq (char-displayable-p ?─) (char-displayable-p ?a))
-        (set-fontset-font "fontset-default"
-                  (cons page-break-lines-char page-break-lines-char)
-                  (face-attribute 'default :family)))))
+    :defer 5
+    :diminish page-break-lines-mode
+    :config (progn
+              (global-page-break-lines-mode)
+              (unless (eq (char-displayable-p ?─) (char-displayable-p ?a))
+                (set-fontset-font "fontset-default"
+                                  (cons page-break-lines-char page-break-lines-char)
+                                  (face-attribute 'default :family)))))
 #+END_SRC
 ** Modeline
 
@@ -212,8 +212,7 @@ #+BEGIN_SRC emacs-lisp   (column-number-mode t)
   (size-indication-mode t)
 
-  (setq frame-title-format
-      '("%f" (dired-directory dired-directory)))
+  (setq frame-title-format '("%f" (dired-directory dired-directory)))
 #+END_SRC
 
 ** Highlight Changes
@@ -222,9 +221,9 @@ Highlight what just changed when I undo, yank, and so on. 
 #+BEGIN_SRC emacs-lisp
   (use-package volatile-highlights
-  :diminish volatile-highlights-mode
-  :config (progn
-        (volatile-highlights-mode t)))
+    :diminish volatile-highlights-mode
+    :config (progn
+              (volatile-highlights-mode t)))
 #+END_SRC
 
 ** Renaming major modes
@@ -234,20 +233,20 @@ modes. 
 #+BEGIN_SRC emacs-lisp
   (use-package cyphejor
-  :defer 2
-  :config (progn
-        (setq cyphejor-rules `(("emacs"       "ε")
-                   ("diff"        "Δ")
-                   ("js2"         "js")
-                   ("magit-status" ,(char-to-string (-find #'char-displayable-p '(11942 5848 177))))
-                   ("inferior"    "i" :prefix)
-                   ("interaction" "i" :prefix)
-                   ("interactive" "i" :prefix)
-                   ("menu"        "▤" :postfix)
-                   ("ledger"      "Ledger")
-                   ("mode"        "")
-                   ("shell"       "sh" :postfix)))
-        (cyphejor-mode 1)))
+    :defer 2
+    :config (progn
+              (setq cyphejor-rules `(("emacs"       "ε")
+                                     ("diff"        "Δ")
+                                     ("js2"         "js")
+                                     ("magit-status" ,(char-to-string (-find #'char-displayable-p '(11942 5848 177))))
+                                     ("inferior"    "i" :prefix)
+                                     ("interaction" "i" :prefix)
+                                     ("interactive" "i" :prefix)
+                                     ("menu"        "▤" :postfix)
+                                     ("ledger"      "Ledger")
+                                     ("mode"        "")
+                                     ("shell"       "sh" :postfix)))
+              (cyphejor-mode 1)))
 #+END_SRC
 
 
@@ -260,16 +259,16 @@ Option/alt, then Control. 
 #+BEGIN_SRC emacs-lisp
   (when (eq system-type 'darwin)
-  (set-keyboard-coding-system nil)
-  (custom-set-variables
-   '(mac-option-modifier 'meta)
-   '(mac-right-option-modifier 'none)
-   '(mac-control-modifier 'control)
-   '(mac-right-control-modifier 'left)
-   '(mac-command-modifier 'super)
-   '(mac-right-command-modifier 'left)
-   '(mac-function-modifier 'hyper))
-  (unbind-key "s-x"))
+    (set-keyboard-coding-system nil)
+    (custom-set-variables
+     '(mac-option-modifier 'meta)
+     '(mac-right-option-modifier 'none)
+     '(mac-control-modifier 'control)
+     '(mac-right-control-modifier 'left)
+     '(mac-command-modifier 'super)
+     '(mac-right-command-modifier 'left)
+     '(mac-function-modifier 'hyper))
+    (unbind-key "s-x"))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
@@ -312,37 +311,37 @@ configuration with crux.el 
 #+BEGIN_SRC emacs-lisp
   (use-package crux
-  :bind (("M-o" . crux-smart-open-line-above)
-       ("C-o" . crux-smart-open-line)
+    :bind (("M-o" . crux-smart-open-line-above)
+           ("C-o" . crux-smart-open-line)
 
-       ("C-x 4 t" . crux-transpose-windows)
-       ("C-c e" . crux-eval-and-replace)
-       ("C-c D" . crux-delete-file-and-buffer)
-       ("C-c R" . crux-rename-file-and-buffer))
-  :init (progn
-      (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer)
-      (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer)))
+           ("C-x 4 t" . crux-transpose-windows)
+           ("C-c e" . crux-eval-and-replace)
+           ("C-c D" . crux-delete-file-and-buffer)
+           ("C-c R" . crux-rename-file-and-buffer))
+    :init (progn
+            (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer)
+            (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer)))
 #+END_SRC
 
 * Projects
 
-   #+BEGIN_SRC emacs-lisp
-   (defvar work-project-directory "~/work")
-   (defvar home-project-directory "~/projects")
-   #+END_SRC
+#+BEGIN_SRC emacs-lisp
+  (defvar work-project-directory "~/work")
+  (defvar home-project-directory "~/projects")
+#+END_SRC
 
 #+BEGIN_SRC emacs-lisp
-(defun switch-to-dotfiles ()
-  (interactive)
-  (projectile-persp-switch-project (expand-file-name "dotfiles" home-project-directory)))
+  (defun switch-to-dotfiles ()
+    (interactive)
+    (projectile-persp-switch-project (expand-file-name "dotfiles" home-project-directory)))
 #+END_SRC
 
 ** The Silver Searcher
 
 #+BEGIN_SRC emacs-lisp
   (use-package ag
-  :defer 30
-  :config (setq ag-project-root-function #'projectile-project-root))
+    :defer 30
+    :config (setq ag-project-root-function #'projectile-project-root))
 #+END_SRC
 
 ** Ripgrep
@@ -366,38 +365,39 @@ based upon some folder conventions I use. 
 #+BEGIN_SRC emacs-lisp
   (use-package projectile
-  :bind (("C-c C-f" . projectile-find-file)
-       ("s-x s-f" . projectile-find-file)
-       ("C-x g" . projectile-vc)
-       ("s-G"   . projectile-vc))
-  :demand t
-  :diminish projectile-mode
-  :config (progn
-        (projectile-global-mode)
-        (add-to-list 'projectile-globally-ignored-directories ".stversions")
-        (defun ap/subfolder-projects (dir)
-        (--map (file-relative-name it dir)
-             (-filter (lambda (subdir)
-                  (--reduce-from (or acc (funcall it subdir)) nil
-                         projectile-project-root-files-functions))
-                (-filter #'file-directory-p (directory-files dir t "\\<")))))
+    :bind (("C-c C-f" . projectile-find-file)
+           ("s-x s-f" . projectile-find-file)
+           ("C-x g" . projectile-vc)
+           ("s-G"   . projectile-vc))
+    :demand t
+    :diminish projectile-mode
+    :config (progn
+              (projectile-global-mode)
+              (add-to-list 'projectile-globally-ignored-directories ".stversions")
+              (defun ap/subfolder-projects (dir)
+                (--map (file-relative-name it dir)
+                       (-filter (lambda (subdir)
+                                  (--reduce-from (or acc (funcall it subdir)) nil
+                                                 projectile-project-root-files-functions))
+                                (-filter #'file-directory-p (directory-files dir t "\\<")))))
 
-         (defun ap/open-subfolder-project (from-dir &optional arg)
-        (let ((project-dir (projectile-completing-read "Open project: "
-                                 (ap/subfolder-projects from-dir))))
-          (projectile-switch-project-by-name (expand-file-name project-dir from-dir) arg)))
+              (defun ap/open-subfolder-project (from-dir &optional arg)
+                (let ((project-dir (projectile-completing-read "Open project: "
+                                                               (ap/subfolder-projects from-dir))))
+                  (projectile-switch-project-by-name (expand-file-name project-dir from-dir) arg)))
 
-        (defun ap/open-work-project (&optional arg)
-        (interactive "P")
-        (ap/open-subfolder-project work-project-directory arg))
 
-        (defun ap/open-home-project (&optional arg)
-        (interactive "P")
-        (ap/open-subfolder-project home-project-directory arg))
+              (defun ap/open-work-project (&optional arg)
+                (interactive "P")
+                (ap/open-subfolder-project work-project-directory arg))
 
-        (setq projectile-switch-project-action #'projectile-dired
-          projectile-remember-window-configs t
-          projectile-completion-system 'ivy)))
+              (defun ap/open-home-project (&optional arg)
+                (interactive "P")
+                (ap/open-subfolder-project home-project-directory arg))
+
+              (setq projectile-switch-project-action #'projectile-dired
+                    projectile-remember-window-configs t
+                    projectile-completion-system 'ivy)))
 #+END_SRC
 
 *** projectile-git-autofetch
@@ -419,14 +419,14 @@ it needs hooking into projectile and a key bound to switch between projects. 
 #+BEGIN_SRC emacs-lisp
   (use-package perspective
-  :bind* ("s-p" . projectile-persp-switch-project)
-  :demand t
-  :config (progn
-        (setq persp-show-modestring t)
-        (persp-mode)))
+    :bind* ("s-p" . projectile-persp-switch-project)
+    :demand t
+    :config (progn
+              (setq persp-show-modestring t)
+              (persp-mode)))
 
   (use-package persp-projectile
-  :ensure t)
+    :ensure t)
 #+END_SRC
 
 ** vc
@@ -435,11 +435,11 @@ This is nice for some things that magit doesn’t do, and for those rare occasions that I’m working with something other than git.
 
 #+BEGIN_SRC emacs-lisp
-(use-package vc
-  :defer t
-  :bind (("C-x v C" . vc-resolve-conflicts))
-  :config (progn
-      (setq vc-follow-symlinks t)))
+  (use-package vc
+    :defer t
+    :bind (("C-x v C" . vc-resolve-conflicts))
+    :config (progn
+              (setq vc-follow-symlinks t)))
 #+END_SRC
 
 ** diff-hl
@@ -449,12 +449,12 @@ changed.  This package colours the fringe 
 #+BEGIN_SRC emacs-lisp
   (use-package diff-hl
-  :defer 2
-  :config (progn
-        (global-diff-hl-mode 1)
-        (add-hook 'dired-mode-hook (lambda ()
-                       (diff-hl-dired-mode 1)))
-        (add-hook 'magit-post-refresh-hook #'diff-hl-magit-post-refresh)))
+    :defer 2
+    :config (progn
+              (global-diff-hl-mode 1)
+              (add-hook 'dired-mode-hook (lambda ()
+                                           (diff-hl-dired-mode 1)))
+              (add-hook 'magit-post-refresh-hook #'diff-hl-magit-post-refresh)))
 #+END_SRC
 
 ** magit
@@ -464,16 +464,16 @@ time.  Make sure to set it up with a nice =completing-read-function= 
 #+BEGIN_SRC emacs-lisp
   (use-package magit
-  :defer 5
-  :commands (magit-status)
-  :config (progn (setq magit-last-seen-setup-instructions "1.4.0"
-             magit-completing-read-function #'magit-builtin-completing-read
-             magit-popup-use-prefix-argument 'default
-             magit-push-always-verify nil
-             magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1
-             global-magit-file-mode nil)
-           (add-to-list 'magit-no-confirm 'safe-with-wip))
-  :init (add-hook 'magit-mode-hook #'magit-load-config-extensions))
+    :defer 5
+    :commands (magit-status)
+    :config (progn (setq magit-last-seen-setup-instructions "1.4.0"
+                         magit-completing-read-function #'magit-builtin-completing-read
+                         magit-popup-use-prefix-argument 'default
+                         magit-push-always-verify nil
+                         magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1
+                         global-magit-file-mode nil)
+                   (add-to-list 'magit-no-confirm 'safe-with-wip))
+    :init (add-hook 'magit-mode-hook #'magit-load-config-extensions))
 #+END_SRC
 
 ** git-timemachine
@@ -485,7 +485,7 @@ a particular way, but it changed later. 
 #+BEGIN_SRC emacs-lisp
   (use-package git-timemachine
-  :commands git-timemachine)
+    :commands git-timemachine)
 #+END_SRC
 
 * Files
@@ -497,7 +497,7 @@ the filesystem.  I don’t want emacs-specific lockfiles, either. 
 #+BEGIN_SRC emacs-lisp
   (setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
-    create-lockfiles nil)
+        create-lockfiles nil)
 #+END_SRC
 ** Backups
 
@@ -506,29 +506,29 @@ a subfolder of its configuration directory for that.  Also, use the trash for deleting on OS X.
 #+BEGIN_SRC emacs-lisp
   (let ((backup-dir (expand-file-name "~/.emacs.d/backups/")))
-  (unless (file-directory-p backup-dir)
-    (make-directory backup-dir))
-  (setq backup-directory-alist `((".*" . ,backup-dir))
-      backup-by-copying-when-linked t
-      backup-by-copying-when-mismatch t))
+    (unless (file-directory-p backup-dir)
+      (make-directory backup-dir))
+    (setq backup-directory-alist `((".*" . ,backup-dir))
+          backup-by-copying-when-linked t
+          backup-by-copying-when-mismatch t))
   (if (eq system-type 'darwin)
-    (setq delete-by-moving-to-trash t)
-  (if (and (executable-find "trash") (not (fboundp #'system-move-file-to-trash)))
-    (defun system-move-file-to-trash (file)
-      (call-process (executable-find "trash")
-            nil 0 nil
-            file))))
+      (setq delete-by-moving-to-trash t)
+    (if (and (executable-find "trash") (not (fboundp #'system-move-file-to-trash)))
+        (defun system-move-file-to-trash (file)
+          (call-process (executable-find "trash")
+                        nil 0 nil
+                        file))))
 #+END_SRC
 
 ** autorevert
 
 #+BEGIN_SRC emacs-lisp
   (use-package autorevert
-  :diminish auto-revert-mode
-  :init (progn
-      (global-auto-revert-mode 1)
-      (setq auto-revert-verbose nil
-          auto-revert-use-notify (not (eq system-type 'darwin)))))
+    :diminish auto-revert-mode
+    :init (progn
+            (global-auto-revert-mode 1)
+            (setq auto-revert-verbose nil
+                  auto-revert-use-notify (not (eq system-type 'darwin)))))
 #+END_SRC
 
 ** Encoding
@@ -537,8 +537,8 @@ UTF-8 is usually appropriate.  Note that =prefer-coding-system= expects only a coding system, not a coding system and line ending combination.
 
 #+BEGIN_SRC emacs-lisp
-(prefer-coding-system 'utf-8)
-(setq-default buffer-file-coding-system 'utf-8-auto-unix)
+  (prefer-coding-system 'utf-8)
+  (setq-default buffer-file-coding-system 'utf-8-auto-unix)
 #+END_SRC
 
 ** Buffer-file management
@@ -547,12 +547,12 @@ Ask if I want to create a directory when it doesn’t exist.  This is especially nice when starting new projects.
 
 #+BEGIN_SRC emacs-lisp
-(defun my-create-non-existent-directory ()
-  (let ((parent-directory (file-name-directory buffer-file-name)))
-  (when (and (not (file-exists-p parent-directory))
-         (y-or-n-p (format "Directory `%s' does not exist!  Create it?" parent-directory)))
-    (make-directory parent-directory t))))
-(add-to-list 'find-file-not-found-functions #'my-create-non-existent-directory)
+  (defun my-create-non-existent-directory ()
+    (let ((parent-directory (file-name-directory buffer-file-name)))
+      (when (and (not (file-exists-p parent-directory))
+                 (y-or-n-p (format "Directory `%s' does not exist!  Create it?" parent-directory)))
+        (make-directory parent-directory t))))
+  (add-to-list 'find-file-not-found-functions #'my-create-non-existent-directory)
 #+END_SRC
 
 I often want to rename or delete the file that I’m currently visiting
@@ -560,16 +560,16 @@ with a buffer. 
 #+BEGIN_SRC emacs-lisp
   (defun kill-or-delete-this-buffer-dwim (&optional arg)
-  "Kills current buffer.  With prefix arg, delete it."
-  (interactive "P")
-  (if (equal arg '(4))
-    (delete-current-buffer-file)
-    (if server-buffer-clients
-      (server-edit)
-    (let ((buf (buffer-name)))
-      (when (equal buf "*HTTP Response*")
-      (other-window 1))
-      (kill-buffer buf)))))
+    "Kills current buffer.  With prefix arg, delete it."
+    (interactive "P")
+    (if (equal arg '(4))
+        (delete-current-buffer-file)
+      (if server-buffer-clients
+          (server-edit)
+        (let ((buf (buffer-name)))
+          (when (equal buf "*HTTP Response*")
+            (other-window 1))
+          (kill-buffer buf)))))
 #+END_SRC
 
 ** Whitespace Butler
@@ -579,13 +579,13 @@ open it.  Whitespace butler fixes whitespace only for lines that I’m editing. 
 #+BEGIN_SRC emacs-lisp
   (use-package ws-butler
-  :if window-system
-  :diminish ws-butler-mode
-  :config (ws-butler-global-mode 1))
+    :if window-system
+    :diminish ws-butler-mode
+    :config (ws-butler-global-mode 1))
   (if (daemonp)
-    (add-hook 'before-make-frame-hook (lambda ()
-                      (use-package ws-butler
-                      :config (ws-butler-global-mode 1)))))
+      (add-hook 'before-make-frame-hook (lambda ()
+                                          (use-package ws-butler
+                                            :config (ws-butler-global-mode 1)))))
 #+END_SRC
 
 ** shrink-whitespace
@@ -595,7 +595,7 @@ for similar things any more. 
 #+BEGIN_SRC emacs-lisp
   (use-package shrink-whitespace
-  :bind ("M-SPC" . shrink-whitespace))
+    :bind ("M-SPC" . shrink-whitespace))
 #+END_SRC
 
 ** Tramp
@@ -605,30 +605,30 @@ that I can sudo on remote machines 
 #+BEGIN_SRC emacs-lisp
   (use-package tramp
-  :defer 7
-  :config (progn
-        (unless (getenv "SSH_AUTH_SOCK")
-        (setenv "SSH_AUTH_SOCK" "/run/user/1000/ssh-agent.socket"))
-        (setq tramp-default-method "ssh"
-          tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
-          tramp-backup-directory-alist backup-directory-alist
-          backup-enable-predicate (lambda (name)
-                        (and (normal-backup-enable-predicate name)
-                           (not (let ((method (file-remote-p name 'method)))
-                              (when (stringp method)
-                              (member method '("su" "sudo")))))))
-          tramp-shell-prompt-pattern "\\(?:^\\|
\\)[^]#$%>\n]*#?[]#$%>❯›] *\\(\\[\\??[0-9;]*[a-zA-Z] *\\)*")
-        (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" (concat "/" tramp-default-method ":%h:")))
-        (add-to-list 'tramp-default-proxies-alist `(,(regexp-quote (system-name)) nil nil))
-        (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil))
-        (add-to-list 'tramp-default-proxies-alist '("router" nil nil))))
+    :defer 7
+    :config (progn
+              (unless (getenv "SSH_AUTH_SOCK")
+                (setenv "SSH_AUTH_SOCK" "/run/user/1000/ssh-agent.socket"))
+              (setq tramp-default-method "ssh"
+                    tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
+                    tramp-backup-directory-alist backup-directory-alist
+                    backup-enable-predicate (lambda (name)
+                                              (and (normal-backup-enable-predicate name)
+                                                   (not (let ((method (file-remote-p name 'method)))
+                                                          (when (stringp method)
+                                                            (member method '("su" "sudo")))))))
+                    tramp-shell-prompt-pattern "\\(?:^\\|
\\)[^]#$%>\n]*#?[]#$%>❯›] *\\(\\[\\??[0-9;]*[a-zA-Z] *\\)*")
+              (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" (concat "/" tramp-default-method ":%h:")))
+              (add-to-list 'tramp-default-proxies-alist `(,(regexp-quote (system-name)) nil nil))
+              (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil))
+              (add-to-list 'tramp-default-proxies-alist '("router" nil nil))))
 
   (use-package tramp-sh
-  :ensure nil
-  :defer t
-  :config (progn
-        (add-to-list 'tramp-remote-path "/usr/local/sbin")
-        (add-to-list 'tramp-remote-path "~/bin")))
+    :ensure nil
+    :defer t
+    :config (progn
+              (add-to-list 'tramp-remote-path "/usr/local/sbin")
+              (add-to-list 'tramp-remote-path "~/bin")))
 #+END_SRC
 
 ** ediff
@@ -636,11 +636,11 @@ I like a horizonal diff setup, with everything in one frame.
 
 #+BEGIN_SRC emacs-lisp
-(use-package ediff
-  :defer t
-  :config (progn
-      (setq ediff-split-window-function 'split-window-horizontally
-          ediff-window-setup-function 'ediff-setup-windows-plain)))
+  (use-package ediff
+    :defer t
+    :config (progn
+              (setq ediff-split-window-function 'split-window-horizontally
+                    ediff-window-setup-function 'ediff-setup-windows-plain)))
 #+END_SRC
 
 * Indentation
@@ -651,7 +651,7 @@ tabstops is probably never going to happen. 
 #+BEGIN_SRC emacs-lisp
   (setq-default tab-width 2
-        indent-tabs-mode nil)
+                indent-tabs-mode nil)
 #+END_SRC
 
 ** auto-indent-mode
@@ -661,25 +661,25 @@ whitespace-sensitive language, of course. 
 #+BEGIN_SRC emacs-lisp
   (use-package auto-indent-mode
-  :config (progn
-        (setq auto-indent-key-for-end-of-line-then-newline "<C-return>"
-          auto-indent-key-for-end-of-line-insert-char-then-newline "<C-S-return>"
-          auto-indent-blank-lines-on-move nil
-          auto-indent-assign-indent-level 2
-          auto-indent-backward-delete-char-behavior nil
-          auto-indent-delete-trailing-whitespace-on-save-file t
-          auto-indent-mode-untabify-on-yank-or-paste nil
-          auto-indent-start-org-indent nil
-          auto-indent-known-indent-level-variables
-          (remq 'lisp-body-indent auto-indent-known-indent-level-variables))
-        (add-to-list 'auto-indent-disabled-modes-list 'jinja2-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'yaml-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'saltstack-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'nix-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'coffee-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'yaml-mode)
-        (add-to-list 'auto-indent-disabled-modes-list 'ansible-mode)
-        (auto-indent-global-mode)))
+    :config (progn
+              (setq auto-indent-key-for-end-of-line-then-newline "<C-return>"
+                    auto-indent-key-for-end-of-line-insert-char-then-newline "<C-S-return>"
+                    auto-indent-blank-lines-on-move nil
+                    auto-indent-assign-indent-level 2
+                    auto-indent-backward-delete-char-behavior nil
+                    auto-indent-delete-trailing-whitespace-on-save-file t
+                    auto-indent-mode-untabify-on-yank-or-paste nil
+                    auto-indent-start-org-indent nil
+                    auto-indent-known-indent-level-variables
+                    (remq 'lisp-body-indent auto-indent-known-indent-level-variables))
+              (add-to-list 'auto-indent-disabled-modes-list 'jinja2-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'yaml-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'saltstack-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'nix-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'coffee-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'yaml-mode)
+              (add-to-list 'auto-indent-disabled-modes-list 'ansible-mode)
+              (auto-indent-global-mode)))
 #+END_SRC
 
 ** smart-tabs-mode
@@ -689,39 +689,39 @@ with spaces.  Perfect! 
 #+BEGIN_SRC emacs-lisp
   (use-package smart-tabs-mode
-  :defer 1
-  :config (progn
-        (smart-tabs-insinuate 'c 'cperl 'python)
-        (add-hook 'php-mode-hook (lambda ()
-                     (smart-tabs-mode indent-tabs-mode)))
-        (with-eval-after-load "align.el"
-        (smart-tabs-mode/no-tabs-mode-advice align)
-        (smart-tabs-mode/no-tabs-mode-advice align-regexp))
-        (eval-after-load "indent.el"
-        '(smart-tabs-mode/no-tabs-mode-advice indent-relative))
-        (eval-after-load "newcomment.el"
-        '(progn (smart-tabs-mode/no-tabs-mode-advice comment-dwim)
-            (smart-tabs-mode/no-tabs-mode-advice comment-box)
-            (smart-tabs-mode/no-tabs-mode-advice comment-indent)))
+    :defer 1
+    :config (progn
+              (smart-tabs-insinuate 'c 'cperl 'python)
+              (add-hook 'php-mode-hook (lambda ()
+                                         (smart-tabs-mode indent-tabs-mode)))
+              (with-eval-after-load "align.el"
+                (smart-tabs-mode/no-tabs-mode-advice align)
+                (smart-tabs-mode/no-tabs-mode-advice align-regexp))
+              (eval-after-load "indent.el"
+                '(smart-tabs-mode/no-tabs-mode-advice indent-relative))
+              (eval-after-load "newcomment.el"
+                '(progn (smart-tabs-mode/no-tabs-mode-advice comment-dwim)
+                        (smart-tabs-mode/no-tabs-mode-advice comment-box)
+                        (smart-tabs-mode/no-tabs-mode-advice comment-indent)))
 
-        (unless
-          (ad-find-advice 'indent-according-to-mode 'around 'smart-tabs)
-        (defadvice indent-according-to-mode (around smart-tabs activate)
-          (if smart-tabs-mode
-            (let ((indent-tabs-mode indent-tabs-mode))
-            (if (memq indent-line-function
-                  '(indent-relative
-                  indent-relative-maybe))
-              (setq indent-tabs-mode nil))
-            ad-do-it)
-          ad-do-it)))))
+              (unless
+                  (ad-find-advice 'indent-according-to-mode 'around 'smart-tabs)
+                (defadvice indent-according-to-mode (around smart-tabs activate)
+                  (if smart-tabs-mode
+                      (let ((indent-tabs-mode indent-tabs-mode))
+                        (if (memq indent-line-function
+                                  '(indent-relative
+                                    indent-relative-maybe))
+                            (setq indent-tabs-mode nil))
+                        ad-do-it)
+                    ad-do-it)))))
 #+END_SRC
 
 ** editorconfig
 
 #+BEGIN_SRC emacs-lisp
   (use-package editorconfig
-  :config (editorconfig-mode 1))
+    :config (editorconfig-mode 1))
 #+END_SRC
 
 ** dtrt-indent-mode
@@ -731,15 +731,15 @@ guesses the correct settings for me. 
 #+BEGIN_SRC emacs-lisp
   (use-package dtrt-indent
-  :config (progn
-        (defun ap/dtrt-adapt-if-needed ()
-        (unless editorconfig-mode
-          (dtrt-indent-adapt)))
-        (if (fboundp #'editorconfig-mode)
-          (add-hook 'after-change-major-mode-hook #'ap/dtrt-adapt-if-needed)
-        (add-hook 'after-change-major-mode-hook #'dtrt-indent-adapt))
-        (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate)
-        (smart-tabs-mode (or indent-tabs-mode -1)))))
+    :config (progn
+              (defun ap/dtrt-adapt-if-needed ()
+                (unless editorconfig-mode
+                  (dtrt-indent-adapt)))
+              (if (fboundp #'editorconfig-mode)
+                  (add-hook 'after-change-major-mode-hook #'ap/dtrt-adapt-if-needed)
+                (add-hook 'after-change-major-mode-hook #'dtrt-indent-adapt))
+              (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate)
+                (smart-tabs-mode (or indent-tabs-mode -1)))))
 #+END_SRC
 
 * Security
@@ -749,9 +749,9 @@ This is a frontend to the GPG-powered =pass= program.
 #+BEGIN_SRC emacs-lisp
   (use-package password-store
-  :defer 15
-  :config (progn
-        (setq password-store-password-length 16)))
+    :defer 15
+    :config (progn
+              (setq password-store-password-length 16)))
 #+END_SRC
 * Buffers
 
@@ -760,54 +760,54 @@ Ibuffer is quite nice for listing all buffers.  I don’t use it very often though, as it doesn’t really work with perspectives.
 
 #+BEGIN_SRC emacs-lisp
-(use-package ibuffer
-  :bind (("C-x C-b" . ibuffer))
-  :config (progn
-      (setq ibuffer-saved-filter-groups
-          (quote (("default"
-               ("org" (mode . org-mode))
-               ("emacs" (mode . emacs-lisp-mode))
-               ("zsh" (filename . "/zsh"))
-               ("server" (filename . "/su:root@server"))))))
+  (use-package ibuffer
+    :bind (("C-x C-b" . ibuffer))
+    :config (progn
+              (setq ibuffer-saved-filter-groups
+                    (quote (("default"
+                             ("org" (mode . org-mode))
+                             ("emacs" (mode . emacs-lisp-mode))
+                             ("zsh" (filename . "/zsh"))
+                             ("server" (filename . "/su:root@server"))))))
 
-      ;; Human-readable base-2 size column
-      (define-ibuffer-column size-h
-        (:name "Size" :inline t)
-        (cond
-         ((> (buffer-size) 1024)
-        (format "%7.2fK" (/ (buffer-size) 1024.0)))
-         ((> (buffer-size) 1048576)
-        (format "%7.2fM" (/ (buffer-size) 1048576.0)))
-         (t
-        (format "%8d" (buffer-size)))))
+              ;; Human-readable base-2 size column
+              (define-ibuffer-column size-h
+                (:name "Size" :inline t)
+                (cond
+                 ((> (buffer-size) 1024)
+                  (format "%7.2fK" (/ (buffer-size) 1024.0)))
+                 ((> (buffer-size) 1048576)
+                  (format "%7.2fM" (/ (buffer-size) 1048576.0)))
+                 (t
+                  (format "%8d" (buffer-size)))))
 
-      (setq ibuffer-formats
-          '((mark modified read-only " "
-              (name 18 18 :left :elide)
-              " "
-              (size-h 9 -1 :right)
-              " "
-              (mode 16 16 :left :elide)
-              " "
-              filename-and-process)))))
+              (setq ibuffer-formats
+                    '((mark modified read-only " "
+                            (name 18 18 :left :elide)
+                            " "
+                            (size-h 9 -1 :right)
+                            " "
+                            (mode 16 16 :left :elide)
+                            " "
+                            filename-and-process)))))
 #+END_SRC
 
 ** Relative Buffer names
 
 #+BEGIN_SRC emacs-lisp
   (use-package relative-buffers
-  :defer 15
-  :config (progn
-        (global-relative-buffers-mode)))
+    :defer 15
+    :config (progn
+              (global-relative-buffers-mode)))
 #+END_SRC
 ** Narrowing
 
 Enable it without prompting
 
 #+BEGIN_SRC emacs-lisp
-(put 'narrow-to-defun  'disabled nil)
-(put 'narrow-to-page   'disabled nil)
-(put 'narrow-to-region 'disabled nil)
+  (put 'narrow-to-defun  'disabled nil)
+  (put 'narrow-to-page   'disabled nil)
+  (put 'narrow-to-region 'disabled nil)
 #+END_SRC
 
 ** ace-window
@@ -816,21 +816,21 @@ I don’t often have many windows open at once, but when I do, =ace-window= is really nice to jump around them in the same way that
 =ace-jump= or =avy= work.
 #+BEGIN_SRC emacs-lisp
-(use-package ace-window
-  :bind (("s-s" . ace-window))
-  :config (progn
-      (setq aw-dispatch-always t
-          aw-dispatch-alist '((?k aw-delete-window " Ace - Delete Window")
-                    (?K aw-delete-window)
-                    (?m aw-swap-window " Ace - Swap Window")
-                    (?f aw-flip-window)
-                    (?v aw-split-window-vert " Ace - Split Vert Window")
-                    (?b aw-split-window-horz " Ace - Split Horz Window")
-                    (?m delete-other-windows " Ace - Maximize Window")
-                    (?l delete-other-windows)
-                    (?, winner-undo)
-                    (?. winner-redo))
-          aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o))))
+  (use-package ace-window
+    :bind (("s-s" . ace-window))
+    :config (progn
+              (setq aw-dispatch-always t
+                    aw-dispatch-alist '((?k aw-delete-window " Ace - Delete Window")
+                                        (?K aw-delete-window)
+                                        (?m aw-swap-window " Ace - Swap Window")
+                                        (?f aw-flip-window)
+                                        (?v aw-split-window-vert " Ace - Split Vert Window")
+                                        (?b aw-split-window-horz " Ace - Split Horz Window")
+                                        (?m delete-other-windows " Ace - Maximize Window")
+                                        (?l delete-other-windows)
+                                        (?, winner-undo)
+                                        (?. winner-redo))
+                    aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o))))
 #+END_SRC
 
 * Windows
@@ -840,14 +840,14 @@ point whilst I’m moving about. 
 #+BEGIN_SRC emacs-lisp
   (setq scroll-conservatively 100
-    scroll-margin 1
-    scroll-preserve-screen-position t
-    mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control)))
-    split-height-threshold 80
-    split-width-threshold 160
-    frame-resize-pixelwise nil)
+        scroll-margin 1
+        scroll-preserve-screen-position t
+        mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control)))
+        split-height-threshold 80
+        split-width-threshold 160
+        frame-resize-pixelwise nil)
   (if (boundp 'ns-pop-up-frames)
-    (setq ns-pop-up-frames nil))
+      (setq ns-pop-up-frames nil))
 #+END_SRC
 
 ** winner
@@ -855,10 +855,10 @@ Undo, for window-based commands.
 
 #+BEGIN_SRC emacs-lisp
-(use-package winner
-  :init (progn
-      (winner-mode 1)
-      (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))))
+  (use-package winner
+    :init (progn
+            (winner-mode 1)
+            (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))))
 #+END_SRC
 
 ** windmove
@@ -866,11 +866,11 @@ Directional window movement
 
 #+BEGIN_SRC emacs-lisp
-(use-package windmove
-  :bind (("S-<left>"  . windmove-left)
-     ("S-<right>" . windmove-right)
-     ("S-<up>"    . windmove-up)
-     ("S-<down>"  . windmove-down)))
+  (use-package windmove
+    :bind (("S-<left>"  . windmove-left)
+           ("S-<right>" . windmove-right)
+           ("S-<up>"    . windmove-up)
+           ("S-<down>"  . windmove-down)))
 #+END_SRC
 * Completion
 
@@ -879,8 +879,8 @@ and initial-based completion and ignoring case. 
 #+BEGIN_SRC emacs-lisp
   (setq completion-styles '(basic initials partial-completion substring)
-    completion-ignore-case t
-    tab-always-indent 'complete)
+        completion-ignore-case t
+        tab-always-indent 'complete)
 #+END_SRC
 
 ** Company
@@ -891,35 +891,35 @@ seems to work perfectly well for me. 
 #+BEGIN_SRC emacs-lisp
   (use-package company
-  :commands (company-mode)
-  :diminish "Cmpl"
-  :bind (("C-<tab>" . company-complete)
-       ("TAB" . company-indent-or-complete-common))
-  :init (progn
-      (add-hook 'prog-mode-hook #'company-mode)
-      (setq company-backends '(company-bbdb company-web-html company-tern company-nxml company-css company-eclim company-semantic company-elisp
-                          company-clang company-xcode company-cmake company-capf
-                          company-files (company-dabbrev-code company-gtags
-                                            company-etags company-keywords) company-oddmuse
-                                            company-dabbrev)
-          company-idle-delay .3
-          company-begin-commands '(self-insert-command)
-          company-auto-complete #'company-explicit-action-p
-          company-auto-complete-chars '(?\ ?\( ?\) ?.)
-          company-tooltip-align-annotations t
-          company-dabbrev-downcase nil)))
+    :commands (company-mode)
+    :diminish "Cmpl"
+    :bind (("C-<tab>" . company-complete)
+           ("TAB" . company-indent-or-complete-common))
+    :init (progn
+            (add-hook 'prog-mode-hook #'company-mode)
+            (setq company-backends '(company-bbdb company-web-html company-tern company-nxml company-css company-eclim company-semantic company-elisp
+                                                  company-clang company-xcode company-cmake company-capf
+                                                  company-files (company-dabbrev-code company-gtags
+                                                                                      company-etags company-keywords) company-oddmuse
+                                                                                      company-dabbrev)
+                  company-idle-delay .3
+                  company-begin-commands '(self-insert-command)
+                  company-auto-complete #'company-explicit-action-p
+                  company-auto-complete-chars '(?\ ?\( ?\) ?.)
+                  company-tooltip-align-annotations t
+                  company-dabbrev-downcase nil)))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
   (use-package company-web
-  :after company)
+    :after company)
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
   (use-package company-nixos-options
-  :if (eq system-type 'gnu/linux)
-  :config (progn
-        (add-to-list 'company-backends 'company-nixos-options)))
+    :if (eq system-type 'gnu/linux)
+    :config (progn
+              (add-to-list 'company-backends 'company-nixos-options)))
 #+END_SRC
 
 * Dates & Times
@@ -929,39 +929,39 @@ Weeks start on Monday for me and I prefer ISO-style dates.
 #+BEGIN_SRC emacs-lisp
   (use-package calendar
-  :defer 1
-  :config (progn
-        (setq calendar-week-start-day 1)
-        (calendar-set-date-style 'iso)
-        (setq calendar-latitude 52.52
-          calendar-longitude 13.40)))
+    :defer 1
+    :config (progn
+              (setq calendar-week-start-day 1)
+              (calendar-set-date-style 'iso)
+              (setq calendar-latitude 52.52
+                    calendar-longitude 13.40)))
 #+END_SRC
 
 Sometimes I want to insert a date or time into a buffer.
 #+BEGIN_SRC emacs-lisp
-(defun insert-date (prefix)
-  "Insert the current date.  With prefix-argument, use British format.  With
-   two prefix arguments, write out the day and month name."
-  (interactive "P")
-  (let ((format (cond
-         ((not prefix) "%Y-%m-%d")
-         ((equal prefix '(4)) "%d/%m/%Y")
-         ((equal prefix '(16)) "%A, %d %B %Y"))))
-  (insert (format-time-string format))))
+  (defun insert-date (prefix)
+    "Insert the current date.  With prefix-argument, use British format.  With
+     two prefix arguments, write out the day and month name."
+    (interactive "P")
+    (let ((format (cond
+                   ((not prefix) "%Y-%m-%d")
+                   ((equal prefix '(4)) "%d/%m/%Y")
+                   ((equal prefix '(16)) "%A, %d %B %Y"))))
+      (insert (format-time-string format))))
 
-(defun insert-datetime (prefix)
-  "Insert the current date and time."
-  (interactive "P")
-  (let ((format (cond
-         ((not prefix) "%Y-%m-%d %H:%M:%S")
-         ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ"))))
-  (insert (format-time-string format))))
+  (defun insert-datetime (prefix)
+    "Insert the current date and time."
+    (interactive "P")
+    (let ((format (cond
+                   ((not prefix) "%Y-%m-%d %H:%M:%S")
+                   ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ"))))
+      (insert (format-time-string format))))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
   (defun yesterday-time ()
-  "Provide the date/time 24 hours before the time now in the format of current-time."
-  (timer-relative-time (current-time) -86400))
+    "Provide the date/time 24 hours before the time now in the format of current-time."
+    (timer-relative-time (current-time) -86400))
 #+END_SRC
 
 * Directories
@@ -972,68 +972,68 @@ have two dired windows open, assume that I’m going to be copying/moving files between them.
 
 #+BEGIN_SRC emacs-lisp
-(use-package dired
-  :defer 3
-  :ensure nil
-  :config (progn
-      (bind-key "<return>" #'dired-find-file dired-mode-map)
-      (bind-key "^" (lambda () (interactive) (find-alternate-file "..")) dired-mode-map)
-      (setq dired-dwim-target t
-          dired-recursive-copies 'top
-          dired-recursive-deletes 'top
-          dired-listing-switches "-alh"
-          dired-bind-jump nil)
-      (when (and (eq system-type 'darwin) (executable-find "gls"))
-        (setq insert-directory-program (executable-find "gls")))
-      (put 'dired-find-alternate-file 'disabled nil)))
+  (use-package dired
+    :defer 3
+    :ensure nil
+    :config (progn
+              (bind-key "<return>" #'dired-find-file dired-mode-map)
+              (bind-key "^" (lambda () (interactive) (find-alternate-file "..")) dired-mode-map)
+              (setq dired-dwim-target t
+                    dired-recursive-copies 'top
+                    dired-recursive-deletes 'top
+                    dired-listing-switches "-alh"
+                    dired-bind-jump nil)
+              (when (and (eq system-type 'darwin) (executable-find "gls"))
+                (setq insert-directory-program (executable-find "gls")))
+              (put 'dired-find-alternate-file 'disabled nil)))
 #+END_SRC
 
 Don’t show uninteresting files in dired listings.
 
 #+BEGIN_SRC emacs-lisp
   (defun turn-on-dired-omit-mode ()
-  (interactive)
-  (dired-omit-mode 1))
+    (interactive)
+    (dired-omit-mode 1))
 
   (use-package dired-x
-  :commands (dired-omit-mode
-         dired-expunge)
-  :ensure nil
-  :config (progn
-        (setq dired-omit-files "#\\|\\.$"
-          dired-omit-verbose nil
-          dired-find-subdir t))
-  :init (progn
-        (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode)))
+    :commands (dired-omit-mode
+               dired-expunge)
+    :ensure nil
+    :config (progn
+              (setq dired-omit-files "#\\|\\.$"
+                    dired-omit-verbose nil
+                    dired-find-subdir t))
+    :init (progn
+            (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode)))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
   (use-package dired+
-  :defer 5
-  :config (progn
-        (diredp-toggle-find-file-reuse-dir 1)
-        (unbind-key "C-h C-m" dired-mode-map)))
+    :defer 5
+    :config (progn
+              (diredp-toggle-find-file-reuse-dir 1)
+              (unbind-key "C-h C-m" dired-mode-map)))
 #+END_SRC
 
 Expand subfolders like a tree inside the parent
 
 #+BEGIN_SRC emacs-lisp
   (with-eval-after-load 'dired
-  (use-package dired-subtree
-    :functions (dired-subtree--get-ov
-          dired-subtree-maybe-up)
-    :init (progn
-        (setq dired-subtree-use-backgrounds nil)
-        (defun dired-subtree-maybe-up ()
-        "Jump up one subtree or directory"
-        (interactive)
-        (let ((ov (dired-subtree--get-ov)))
-          (if ov
-            (progn (goto-char (overlay-start ov))
-               (dired-previous-line 1))
-          (dired-up-directory))))
-        (bind-key "^" #'dired-subtree-maybe-up dired-mode-map)
-        (bind-key "i" #'dired-subtree-toggle dired-mode-map))))
+    (use-package dired-subtree
+      :functions (dired-subtree--get-ov
+                  dired-subtree-maybe-up)
+      :init (progn
+              (setq dired-subtree-use-backgrounds nil)
+              (defun dired-subtree-maybe-up ()
+                "Jump up one subtree or directory"
+                (interactive)
+                (let ((ov (dired-subtree--get-ov)))
+                  (if ov
+                      (progn (goto-char (overlay-start ov))
+                             (dired-previous-line 1))
+                    (dired-up-directory))))
+              (bind-key "^" #'dired-subtree-maybe-up dired-mode-map)
+              (bind-key "i" #'dired-subtree-toggle dired-mode-map))))
 #+END_SRC
 
 ** Dired-narrow
@@ -1045,9 +1045,9 @@ the buffer, removing the filter. 
 #+BEGIN_SRC emacs-lisp
   (with-eval-after-load 'dired
-  (use-package dired-narrow
-    :bind (:map dired-mode-map
-          ("/" . dired-narrow))))
+    (use-package dired-narrow
+      :bind (:map dired-mode-map
+                  ("/" . dired-narrow))))
 #+END_SRC
 
 * Documentation
@@ -1059,7 +1059,7 @@ improves the normal help commands, mostly by making quitting them easier. 
 #+BEGIN_SRC emacs-lisp
   (use-package ehelp
-  :bind-keymap ("C-h" . ehelp-map))
+    :bind-keymap ("C-h" . ehelp-map))
 #+END_SRC
 ** counsel-dash
 
@@ -1068,32 +1068,32 @@ helps to make documentation for other languages easier to access 
 #+BEGIN_SRC emacs-lisp
   (defmacro ap/create-counsel-dash-hook (mode docsets)
-  (let* ((mode-s (symbol-name mode))
-       (fun (intern (concat "counsel-dash-hook-" mode-s)))
-       (hook (intern (concat mode-s "-mode-hook"))))
-    `(progn
-     (defun ,fun ()
-       (when (require 'counsel-dash nil :noerror)
-       (-each (-difference ',docsets
-                 (helm-dash-installed-docsets))
-         #'counsel-dash-install-docset)
-       (setq-local counsel-dash-docsets ',docsets)))
-     (add-hook (quote ,hook) (function ,fun)))))
+    (let* ((mode-s (symbol-name mode))
+           (fun (intern (concat "counsel-dash-hook-" mode-s)))
+           (hook (intern (concat mode-s "-mode-hook"))))
+      `(progn
+         (defun ,fun ()
+           (when (require 'counsel-dash nil :noerror)
+             (-each (-difference ',docsets
+                                 (helm-dash-installed-docsets))
+               #'counsel-dash-install-docset)
+             (setq-local counsel-dash-docsets ',docsets)))
+         (add-hook (quote ,hook) (function ,fun)))))
 
   (use-package counsel-dash
-  :defer 20
-  :defines counsel-dash-docsets
-  :config (progn
-        (setq counsel-dash-browser-func #'eww)
-        (ap/create-counsel-dash-hook nginx ("Nginx"))
-        (ap/create-counsel-dash-hook ansible ("Ansible"))
-        (ap/create-counsel-dash-hook php ("PHP" "Symfony"))
-        (ap/create-counsel-dash-hook twig ("Twig"))
-        (ap/create-counsel-dash-hook js2 ("JavaScript" "NodeJS" "jQuery" "Express" "SailsJS" "Lo-Dash"))
-        (ap/create-counsel-dash-hook markdown ("Markdown"))
-        (ap/create-counsel-dash-hook saltstack ("SaltStack"))
-        (ap/create-counsel-dash-hook clojure ("Clojure"))
-        (ap/create-counsel-dash-hook sql ("PostgreSQL" "MySQL"))))
+    :defer 20
+    :defines counsel-dash-docsets
+    :config (progn
+              (setq counsel-dash-browser-func #'eww)
+              (ap/create-counsel-dash-hook nginx ("Nginx"))
+              (ap/create-counsel-dash-hook ansible ("Ansible"))
+              (ap/create-counsel-dash-hook php ("PHP" "Symfony"))
+              (ap/create-counsel-dash-hook twig ("Twig"))
+              (ap/create-counsel-dash-hook js2 ("JavaScript" "NodeJS" "jQuery" "Express" "SailsJS" "Lo-Dash"))
+              (ap/create-counsel-dash-hook markdown ("Markdown"))
+              (ap/create-counsel-dash-hook saltstack ("SaltStack"))
+              (ap/create-counsel-dash-hook clojure ("Clojure"))
+              (ap/create-counsel-dash-hook sql ("PostgreSQL" "MySQL"))))
 #+END_SRC
 
 ** discover-my-major
@@ -1102,7 +1102,7 @@ A nicer way to browse keybindings for major modes. 
 #+BEGIN_SRC emacs-lisp
   (use-package discover-my-major
-  :bind ("<f1>" . discover-my-major))
+    :bind ("<f1>" . discover-my-major))
 #+END_SRC
 
 ** which-key
@@ -1111,10 +1111,10 @@ Popup keybindings following a prefix automatically. 
 #+BEGIN_SRC emacs-lisp
   (use-package which-key
-  :diminish which-key-mode
-  :config (progn
-        (which-key-mode 1)
-        (which-key-setup-side-window-right-bottom)))
+    :diminish which-key-mode
+    :config (progn
+              (which-key-mode 1)
+              (which-key-setup-side-window-right-bottom)))
 #+END_SRC
 
 ** eldoc
@@ -1123,56 +1123,56 @@ Documentation in the echo-area (where the minibuffer is displayed) is rather useful.
 
 #+BEGIN_SRC emacs-lisp
-(use-package eldoc
-  :commands (eldoc-mode)
-  :diminish eldoc-mode
-  :config (progn
-      (setq eldoc-idle-delay 0.1)
-      (eldoc-add-command 'paredit-backward-delete 'paredit-close-round)))
+  (use-package eldoc
+    :commands (eldoc-mode)
+    :diminish eldoc-mode
+    :config (progn
+              (setq eldoc-idle-delay 0.1)
+              (eldoc-add-command 'paredit-backward-delete 'paredit-close-round)))
 #+END_SRC
 * Misc
 
 #+BEGIN_SRC emacs-lisp
   (defvar *init-file*
-  (let ((init-file (or user-init-file
-             (expand-file-name "init.el" user-emacs-directory))))
-    (expand-file-name "init.el"
-            (file-name-directory (file-truename init-file))))
-  "Where the emacs init file really is, passing through symlinks.")
+    (let ((init-file (or user-init-file
+                         (expand-file-name "init.el" user-emacs-directory))))
+      (expand-file-name "init.el"
+                        (file-name-directory (file-truename init-file))))
+    "Where the emacs init file really is, passing through symlinks.")
   (set-register ?e `(file . ,*init-file*))
 
   (defun ap/remove-extra-cr ()
-  "Remove extraneous CR codes from a file"
-  (interactive)
-  (save-excursion
-    (goto-char (point-min))
-    (while (search-forward "
+    "Remove extraneous CR codes from a file"
+    (interactive)
+    (save-excursion
+      (goto-char (point-min))
+      (while (search-forward "
   " nil t)
-    (replace-match ""))))
+        (replace-match ""))))
 
   (use-package rect
-  :ensure nil
-  :init (defun copy-rectangle (start end)
-      "Copy the region-rectangle."
-      (interactive "r")
-      (setq killed-rectangle (extract-rectangle start end))))
+    :ensure nil
+    :init (defun copy-rectangle (start end)
+            "Copy the region-rectangle."
+            (interactive "r")
+            (setq killed-rectangle (extract-rectangle start end))))
 
   (defun shell-execute (to-current-buffer)
-  (interactive "P")
-  (let ((file-buffer (if (buffer-file-name)
-               (file-name-nondirectory (buffer-file-name))
-             ""))
-      (command (read-shell-command "Shell command: " nil nil nil)))
-    (shell-command (replace-regexp-in-string "%" file-buffer command) to-current-buffer)))
+    (interactive "P")
+    (let ((file-buffer (if (buffer-file-name)
+                           (file-name-nondirectory (buffer-file-name))
+                         ""))
+          (command (read-shell-command "Shell command: " nil nil nil)))
+      (shell-command (replace-regexp-in-string "%" file-buffer command) to-current-buffer)))
 
   (defun narrow-to-region-indirect (start end)
-  "Restrict editing in this buffer to the current region, indirectly."
-  (interactive "r")
-  (deactivate-mark)
-  (let ((buf (clone-indirect-buffer nil nil)))
-    (with-current-buffer buf
-    (narrow-to-region start end))
-    (switch-to-buffer buf)))
+    "Restrict editing in this buffer to the current region, indirectly."
+    (interactive "r")
+    (deactivate-mark)
+    (let ((buf (clone-indirect-buffer nil nil)))
+      (with-current-buffer buf
+        (narrow-to-region start end))
+      (switch-to-buffer buf)))
 
   (bind-key* "M-!" #'shell-execute)
   (bind-key* "C-x r M-w" #'copy-rectangle)
@@ -1194,14 +1194,14 @@ This avoids some issue with the minibuffer and the point being behind
 the prompt.  I don’t remember what exactly.
 #+BEGIN_SRC emacs-lisp
-(setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))
+  (setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))
 #+END_SRC
 
 Occasionally, I exit emacs.  I should probably reduce the frequency of this.
 #+BEGIN_SRC emacs-lisp
   (if (daemonp)
-    (defalias 'exit-emacs #'delete-frame)
-  (defalias 'exit-emacs #'save-buffers-kill-emacs))
+      (defalias 'exit-emacs #'delete-frame)
+    (defalias 'exit-emacs #'save-buffers-kill-emacs))
 #+END_SRC
 
 ** swiper/ivy
@@ -1211,44 +1211,44 @@ replacement for helm so far. 
 #+BEGIN_SRC emacs-lisp
   (use-package swiper
-  :bind (("C-s" . swiper)
-       ("C-r" . swiper)
-       ("C-c C-r" . ivy-resume)
-       ("C-x i" . ivy-imenu-goto)
-       ("C-=" . swiper))
-  :diminish ivy-mode
-  :demand t
-  :config (progn
-        (ivy-mode 1)
-        (setq ivy-re-builders-alist '((internal-complete-buffer . ivy--regex-fuzzy)
-                      (t . ivy--regex-plus)))
-        (defun ivy-imenu-get-candidates-from (alist  &optional prefix)
-        (cl-loop for elm in alist
-             nconc (if (imenu--subalist-p elm)
-                   (ivy-imenu-get-candidates-from
-                  (cl-loop for (e . v) in (cdr elm) collect
-                       (cons e (if (integerp v) (copy-marker v) v)))
-                  (concat prefix (if prefix ".") (car elm)))
-                 (and (cdr elm) ; bug in imenu, should not be needed.
-                    (setcdr elm (copy-marker (cdr elm))) ; Same as [1].
-                    (list (cons (concat prefix (if prefix ".") (car elm))
-                          (copy-marker (cdr elm))))))))
+    :bind (("C-s" . swiper)
+           ("C-r" . swiper)
+           ("C-c C-r" . ivy-resume)
+           ("C-x i" . ivy-imenu-goto)
+           ("C-=" . swiper))
+    :diminish ivy-mode
+    :demand t
+    :config (progn
+              (ivy-mode 1)
+              (setq ivy-re-builders-alist '((internal-complete-buffer . ivy--regex-fuzzy)
+                                            (t . ivy--regex-plus)))
+              (defun ivy-imenu-get-candidates-from (alist  &optional prefix)
+                (cl-loop for elm in alist
+                         nconc (if (imenu--subalist-p elm)
+                                   (ivy-imenu-get-candidates-from
+                                    (cl-loop for (e . v) in (cdr elm) collect
+                                             (cons e (if (integerp v) (copy-marker v) v)))
+                                    (concat prefix (if prefix ".") (car elm)))
+                                 (and (cdr elm) ; bug in imenu, should not be needed.
+                                      (setcdr elm (copy-marker (cdr elm))) ; Same as [1].
+                                      (list (cons (concat prefix (if prefix ".") (car elm))
+                                                  (copy-marker (cdr elm))))))))
 
-        (defun ivy-imenu-goto ()
-        "Go to buffer position"
-        (interactive)
-        (let ((imenu-auto-rescan t) items)
-          (unless (featurep 'imenu)
-          (require 'imenu nil t))
-          (setq items (imenu--make-index-alist t))
-          (ivy-read "imenu items:"
-              (ivy-imenu-get-candidates-from (delete (assoc "*Rescan*" items) items))
-              :action (lambda (k) (goto-char k)))))
-        (ivy-set-actions 'ivy-switch-buffer '(("k" (lambda (x)
-                               (kill-buffer x)
-                               (ivy--reset-state ivy-last))
-                           "kill")))
-        (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))))
+              (defun ivy-imenu-goto ()
+                "Go to buffer position"
+                (interactive)
+                (let ((imenu-auto-rescan t) items)
+                  (unless (featurep 'imenu)
+                    (require 'imenu nil t))
+                  (setq items (imenu--make-index-alist t))
+                  (ivy-read "imenu items:"
+                            (ivy-imenu-get-candidates-from (delete (assoc "*Rescan*" items) items))
+                            :action (lambda (k) (goto-char k)))))
+              (ivy-set-actions 'ivy-switch-buffer '(("k" (lambda (x)
+                                                           (kill-buffer x)
+                                                           (ivy--reset-state ivy-last))
+                                                     "kill")))
+              (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))))
 #+END_SRC
 
 ** counsel
@@ -1289,20 +1289,20 @@ don’t use it directly. 
 #+BEGIN_SRC emacs-lisp
   (use-package smex
-  :commands (smex
-         smex-update
-         smex-initialize)
-  :config (progn
-        (setq smex-key-advice-ignore-menu-bar t
-          smex-auto-update nil)
-        (defun smex-update-after-load (_unused)
-        (if (boundp 'smex-cache)
-          (smex-update)))
-        (add-hook 'after-load-functions 'smex-update-after-load))
-  :init (progn
-      (setq smex-history-length 100
-          smex-save-file (concat user-emacs-directory
-                     "smex-items"))))
+    :commands (smex
+               smex-update
+               smex-initialize)
+    :config (progn
+              (setq smex-key-advice-ignore-menu-bar t
+                    smex-auto-update nil)
+              (defun smex-update-after-load (_unused)
+                (if (boundp 'smex-cache)
+                    (smex-update)))
+              (add-hook 'after-load-functions 'smex-update-after-load))
+    :init (progn
+            (setq smex-history-length 100
+                  smex-save-file (concat user-emacs-directory
+                                         "smex-items"))))
 #+END_SRC
 
 ** cmd-to-echo
@@ -1335,50 +1335,50 @@ Some modes that I don’t really customise much, mostly for configuration files.
 #+BEGIN_SRC emacs-lisp
   (use-package xrdb-mode
-  :ensure nil
-  :mode (("\\.Xdefaults\\'" . xrdb-mode)
-       ("\\.Xresources\\'" . xrdb-mode)))
+    :ensure nil
+    :mode (("\\.Xdefaults\\'" . xrdb-mode)
+           ("\\.Xresources\\'" . xrdb-mode)))
 
   (use-package haskell-mode
-  :mode (("\\.hs\\'" . haskell-mode)))
+    :mode (("\\.hs\\'" . haskell-mode)))
 
   (use-package dockerfile-mode
-  :mode (("Dockerfile\\'" . dockerfile-mode)))
+    :mode (("Dockerfile\\'" . dockerfile-mode)))
 
   (use-package nix-mode
-  :mode (("\\.nix\\'" . nix-mode)))
+    :mode (("\\.nix\\'" . nix-mode)))
 
   (define-derived-mode xmonad-mode haskell-mode "XM")
   (add-to-list 'auto-mode-alist '("xmobarrc\\'" . xmonad-mode))
   (add-to-list 'auto-mode-alist '("xmonad.hs\\'" . xmonad-mode))
 
   (use-package nginx-mode
-  :defer t
-  :mode (("/nginx/servers/" . nginx-mode)
-       ("/nginx/.*\\.d/" . nginx-mode)))
+    :defer t
+    :mode (("/nginx/servers/" . nginx-mode)
+           ("/nginx/.*\\.d/" . nginx-mode)))
 
   (use-package lua-mode
-  :defer t)
+    :defer t)
 
   (use-package ruby-mode
-  :mode (("\\.rb\\'" . ruby-mode)
-       ("\\.cap\\'" . ruby-mode)))
+    :mode (("\\.rb\\'" . ruby-mode)
+           ("\\.cap\\'" . ruby-mode)))
 
   (use-package go-mode
-  :mode (("\\.go\\'" . go-mode)))
+    :mode (("\\.go\\'" . go-mode)))
 
   (use-package jinja2-mode
-  :mode (("\\.j2\\'" . jinja2-mode)
-       ("\\.jinja\\'" . jinja2-mode)))
+    :mode (("\\.j2\\'" . jinja2-mode)
+           ("\\.jinja\\'" . jinja2-mode)))
 
   (use-package scss-mode
-  :defer t
-  :config (progn
-        (setq scss-compile-at-save nil)))
+    :defer t
+    :config (progn
+              (setq scss-compile-at-save nil)))
 
   (use-package yaml-mode
-  :mode (("/group_vars/.*" . yaml-mode)
-       ("/host_vars/.*" . yaml-mode)))
+    :mode (("/group_vars/.*" . yaml-mode)
+           ("/host_vars/.*" . yaml-mode)))
 
   (define-derived-mode ansible-mode yaml-mode "Ansible")
   (add-to-list 'auto-mode-alist '("\\(?:ansible.+\\|roles/.+/\\(?:tasks\\|handlers\\)\\)/.+\\.yml\\'" . ansible-mode))
@@ -1394,44 +1394,44 @@ works really nicely. 
 #+BEGIN_SRC emacs-lisp
   (use-package ledger-mode
-  :mode ("\\.ledger\\'" . ledger-mode)
-  :init (progn
-      (defun open-budget ()
-        (interactive)
-        (projectile-persp-switch-project "~/Sync")
-        (find-file (expand-file-name "ledger/my.ledger" (projectile-project-root)))
-        (ledger-report "Budget (Cumulative)" nil)))
-  :config (progn
-        (setq ledger-use-iso-dates t
-          ledger-post-use-completion-engine :built-in
-          ledger-reconcile-default-commodity "€"
-          ledger-clear-whole-transactions t
-          ledger-narrow-on-reconcile t
-          ledger-default-date-format "%Y-%m-%d"
-          ledger-reports '(("Monthly Expenses" "ledger -f %(ledger-file) reg -M Expenses --real -l \"payee != 'Opening Balances'\"")
-                   ("Expenses:This Month" "ledger -f %(ledger-file) bal \\^Expenses -p \"this month\"")
-                   ("On-budget Balances" "ledger -f %(ledger-file) bal --current -R :Budget: Assets:Receivable Liabilities:Personal")
-                   ("All Account Balances" "ledger -f %(ledger-file) bal --current -R \\^Assets \\^Liabilities")
-                   ("Budget Values (Current Month)" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds")
-                   ("Budget (Cumulative)" "ledger -f %(ledger-file) bal -E \\^Funds \\^Assets:Budget$")
-                   ("Budget Allocation" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds --format \"\\
+    :mode ("\\.ledger\\'" . ledger-mode)
+    :init (progn
+            (defun open-budget ()
+              (interactive)
+              (projectile-persp-switch-project "~/Sync")
+              (find-file (expand-file-name "ledger/my.ledger" (projectile-project-root)))
+              (ledger-report "Budget (Cumulative)" nil)))
+    :config (progn
+              (setq ledger-use-iso-dates t
+                    ledger-post-use-completion-engine :built-in
+                    ledger-reconcile-default-commodity "€"
+                    ledger-clear-whole-transactions t
+                    ledger-narrow-on-reconcile t
+                    ledger-default-date-format "%Y-%m-%d"
+                    ledger-reports '(("Monthly Expenses" "ledger -f %(ledger-file) reg -M Expenses --real -l \"payee != 'Opening Balances'\"")
+                                     ("Expenses:This Month" "ledger -f %(ledger-file) bal \\^Expenses -p \"this month\"")
+                                     ("On-budget Balances" "ledger -f %(ledger-file) bal --current -R :Budget: Assets:Receivable Liabilities:Personal")
+                                     ("All Account Balances" "ledger -f %(ledger-file) bal --current -R \\^Assets \\^Liabilities")
+                                     ("Budget Values (Current Month)" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds")
+                                     ("Budget (Cumulative)" "ledger -f %(ledger-file) bal -E \\^Funds \\^Assets:Budget$")
+                                     ("Budget Allocation" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds --format \"\\
                     %-17((depth_spacer)+(partial_account))\\
                     %10(percent(market(display_total), market(parent.total)))\\
                     %16(market(display_total))\n%/\"")
-                   ("bal" "ledger -f %(ledger-file) bal")
-                   ("reg" "ledger -f %(ledger-file) reg")
-                   ("equity" "ledger -f %(ledger-file) equity")
-                   ("payee" "ledger -f %(ledger-file) reg @%(payee)")
-                   ("account" "ledger -f %(ledger-file) reg %(account)")))))
+                                     ("bal" "ledger -f %(ledger-file) bal")
+                                     ("reg" "ledger -f %(ledger-file) reg")
+                                     ("equity" "ledger -f %(ledger-file) equity")
+                                     ("payee" "ledger -f %(ledger-file) reg @%(payee)")
+                                     ("account" "ledger -f %(ledger-file) reg %(account)")))))
 #+END_SRC
 
 ** Markdown
 
 #+BEGIN_SRC emacs-lisp
   (use-package markdown-mode
-  :defer t
-  :config (progn
-        (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
+    :defer t
+    :config (progn
+              (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
 #+END_SRC
 
 ** Org
@@ -1440,48 +1440,48 @@ Org is wünderbar. 
 #+BEGIN_SRC emacs-lisp
   (use-package org
-  :bind (("C-c C-a" . org-agenda-list)
-       ("C-c a" . org-agenda)
-       ("C-c l" . org-store-link))
-  :defer 8
-  :init (setq org-replace-disputed-keys t
-        org-ellipsis "…")
-  :config (progn
-        (setq org-directory "~/Sync/org"
-          org-agenda-files `(,(concat org-directory "/agenda"))
+    :bind (("C-c C-a" . org-agenda-list)
+           ("C-c a" . org-agenda)
+           ("C-c l" . org-store-link))
+    :defer 8
+    :init (setq org-replace-disputed-keys t
+                org-ellipsis "…")
+    :config (progn
+              (setq org-directory "~/Sync/org"
+                    org-agenda-files `(,(concat org-directory "/agenda"))
 
-          org-default-notes-file (concat org-directory "/notes")
+                    org-default-notes-file (concat org-directory "/notes")
 
-          ;; ‘Remember’: new items at top
-          org-reverse-note-order t
+                    ;; ‘Remember’: new items at top
+                    org-reverse-note-order t
 
-          org-modules '(org-protocol)
+                    org-modules '(org-protocol)
 
-          ;; Add time done to ‘done’ tasks
-          org-log-done 'time
+                    ;; Add time done to ‘done’ tasks
+                    org-log-done 'time
 
-          org-list-allow-alphabetical t
+                    org-list-allow-alphabetical t
 
-          org-adapt-indentation nil
+                    org-adapt-indentation nil
 
-          org-pretty-entities t
+                    org-pretty-entities t
 
-          org-table-duration-custom-format 'seconds
+                    org-table-duration-custom-format 'seconds
 
-          org-src-fontify-natively nil
+                    org-src-fontify-natively nil
 
-          org-export-have-math t
+                    org-export-have-math t
 
-          org-blank-before-new-entry '((heading . t)
-                         (plain-list-item . auto))
-          org-fontify-done-headline t
+                    org-blank-before-new-entry '((heading . t)
+                                                 (plain-list-item . auto))
+                    org-fontify-done-headline t
 
-          org-todo-keywords '((sequence "BACKLOG(b)" "TODO(t)" "WAIT(w@/!)" "STARTED(s!)" "|" "DONE(d!)")
-                    (sequence "|" "CANCELLED(c@)"))
-          org-log-into-drawer "LOGBOOK")
-        (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory)))
-        (add-hook 'org-mode-hook #'turn-on-auto-fill)
-        (org-load-modules-maybe t)))
+                    org-todo-keywords '((sequence "BACKLOG(b)" "TODO(t)" "WAIT(w@/!)" "STARTED(s!)" "|" "DONE(d!)")
+                                        (sequence "|" "CANCELLED(c@)"))
+                    org-log-into-drawer "LOGBOOK")
+              (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory)))
+              (add-hook 'org-mode-hook #'turn-on-auto-fill)
+              (org-load-modules-maybe t)))
 #+END_SRC
 
 **** org-babel
@@ -1493,12 +1493,12 @@ with R or something. 
 #+BEGIN_SRC emacs-lisp
   (use-package ob-core
-  :defer t
-  :ensure nil
-  :config (org-babel-do-load-languages
-       'org-babel-load-languages
-       '((ledger . t)
-         (sh . t))))
+    :defer t
+    :ensure nil
+    :config (org-babel-do-load-languages
+             'org-babel-load-languages
+             '((ledger . t)
+               (sh . t))))
 #+END_SRC
 
 **** org-journal
@@ -1507,57 +1507,57 @@ I can use this to keep a journal.  I should use it. 
 #+BEGIN_SRC emacs-lisp
   (use-package org-journal
-  :bind ("s-j" . org-journal-new-entry)
-  :defer 20
-  :config (progn
-        (setq org-journal-date-format "%A, %d %B %Y")
-        (defun org-journal-display-entry-yesterday ()
-        "Show org-journal entry for yesterday"
-        (interactive)
-        (org-journal-read-or-display-entry (yesterday-time)))))
+    :bind ("s-j" . org-journal-new-entry)
+    :defer 20
+    :config (progn
+              (setq org-journal-date-format "%A, %d %B %Y")
+              (defun org-journal-display-entry-yesterday ()
+                "Show org-journal entry for yesterday"
+                (interactive)
+                (org-journal-read-or-display-entry (yesterday-time)))))
 #+END_SRC
 
 **** org-mobile
 
 #+BEGIN_SRC emacs-lisp
   (defun ap/org-mobile-pull (descriptor action file)
-  (org-mobile-pull))
+    (org-mobile-pull))
   (use-package org-mobile
-  :defer 30
-  :ensure nil
-  :disabled t
-  :config (progn
-        (setq org-mobile-directory "~/Mobile/Org"
-          org-mobile-inbox-for-pull "~/Mobile/Org/from-mobile.org")
-        (defvar org-mobile-push-timer nil
-        "Timer that `org-mobile-push-timer' used to reschedule itself, or nil.")
+    :defer 30
+    :ensure nil
+    :disabled t
+    :config (progn
+              (setq org-mobile-directory "~/Mobile/Org"
+                    org-mobile-inbox-for-pull "~/Mobile/Org/from-mobile.org")
+              (defvar org-mobile-push-timer nil
+                "Timer that `org-mobile-push-timer' used to reschedule itself, or nil.")
 
-        (defun org-mobile-push-with-delay (secs)
-        (when org-mobile-push-timer
-          (cancel-timer org-mobile-push-timer))
-        (setq org-mobile-push-timer
-            (run-with-idle-timer
-             (* 1 secs) nil 'org-mobile-push)))
+              (defun org-mobile-push-with-delay (secs)
+                (when org-mobile-push-timer
+                  (cancel-timer org-mobile-push-timer))
+                (setq org-mobile-push-timer
+                      (run-with-idle-timer
+                       (* 1 secs) nil 'org-mobile-push)))
 
-        (add-hook 'after-save-hook
-            (lambda ()
-              (when (eq major-mode 'org-mode)
-              (dolist (file (org-mobile-files-alist))
-                (if (string= (file-truename (expand-file-name (car file)))
-                       (file-truename (buffer-file-name)))
-                  (org-mobile-push-with-delay 30))))))
+              (add-hook 'after-save-hook
+                        (lambda ()
+                          (when (eq major-mode 'org-mode)
+                            (dolist (file (org-mobile-files-alist))
+                              (if (string= (file-truename (expand-file-name (car file)))
+                                           (file-truename (buffer-file-name)))
+                                  (org-mobile-push-with-delay 30))))))
 
-        (run-at-time "00:05" 86400 '(lambda () (org-mobile-push-with-delay 1))) ;; refreshes agenda file each day
-        (org-mobile-pull) ;; run org-mobile-pull at startup
+              (run-at-time "00:05" 86400 '(lambda () (org-mobile-push-with-delay 1))) ;; refreshes agenda file each day
+              (org-mobile-pull) ;; run org-mobile-pull at startup
 
-        (defvar org-mobile-watcher nil)
-        (when file-notify--library
-        (let ((org-file (expand-file-name
-                 (concat
-                  (file-name-as-directory org-mobile-directory)
-                  org-mobile-capture-file))))
-          (setq org-mobile-watcher
-            (file-notify-add-watch org-file '(change) #'ap/org-mobile-pull))))))
+              (defvar org-mobile-watcher nil)
+              (when file-notify--library
+                (let ((org-file (expand-file-name
+                                 (concat
+                                  (file-name-as-directory org-mobile-directory)
+                                  org-mobile-capture-file))))
+                  (setq org-mobile-watcher
+                        (file-notify-add-watch org-file '(change) #'ap/org-mobile-pull))))))
 #+END_SRC
 
 **** org-caldav
@@ -1568,16 +1568,16 @@ write to the Android calendar, and then for DAVDroid to sync with the server. 
 #+BEGIN_SRC emacs-lisp
   (use-package org-caldav
-  :defer 30
-  :config (progn
-        (setq org-caldav-url "https://calendar.alanpearce.uk/alan"
-          org-caldav-calendar-id "caldav"
-          org-caldav-inbox (concat org-directory "/agenda/caldav.org")
-          org-caldav-files `(,(concat org-directory "/agenda/organiser.org"))
-          org-icalendar-timezone "Europe/Berlin"
-          org-icalendar-use-scheduled '(event-if-todo event-if-not-todo todo-start)
-          org-icalendar-use-deadline '(event-if-todo event-if-not-todo todo-due)
-          org-icalendar-alarm-time 60)))
+    :defer 30
+    :config (progn
+              (setq org-caldav-url "https://calendar.alanpearce.uk/alan"
+                    org-caldav-calendar-id "caldav"
+                    org-caldav-inbox (concat org-directory "/agenda/caldav.org")
+                    org-caldav-files `(,(concat org-directory "/agenda/organiser.org"))
+                    org-icalendar-timezone "Europe/Berlin"
+                    org-icalendar-use-scheduled '(event-if-todo event-if-not-todo todo-start)
+                    org-icalendar-use-deadline '(event-if-todo event-if-not-todo todo-due)
+                    org-icalendar-alarm-time 60)))
 #+END_SRC
 
 **** org-page
@@ -1588,10 +1588,10 @@ will do the trick. 
 #+BEGIN_SRC emacs-lisp
   (use-package org-page
-  :config (progn
-        (setq op/site-domain "https://alanpearce.uk/"
-          op/repository-directory "~/projects/alanpearce/"
-          op/personal-github-link "https://github.com/alanpearce")))
+    :config (progn
+              (setq op/site-domain "https://alanpearce.uk/"
+                    op/repository-directory "~/projects/alanpearce/"
+                    op/personal-github-link "https://github.com/alanpearce")))
 #+END_SRC
 
 * Music
@@ -1599,9 +1599,9 @@ Emacs actually supports playing music via mpd. 
 #+BEGIN_SRC emacs-lisp
   (use-package mpc
-  :defer t
-  :config (progn
-        (setq mpc-browser-tags '(Genre Albumartist|Composer|Performer Album|Playlist))))
+    :defer t
+    :config (progn
+              (setq mpc-browser-tags '(Genre Albumartist|Composer|Performer Album|Playlist))))
 #+END_SRC
 * Programming
 ** flycheck
@@ -1610,11 +1610,11 @@ On-the-fly error checking in programming modes?  Yes please. 
 #+BEGIN_SRC emacs-lisp
   (use-package flycheck
-  :diminish " ✓"
-  :defer 5
-  :config (progn
-        (global-flycheck-mode)
-        (setq flycheck-check-syntax-automatically '(save new-line mode-enabled))))
+    :diminish " ✓"
+    :defer 5
+    :config (progn
+              (global-flycheck-mode)
+              (setq flycheck-check-syntax-automatically '(save new-line mode-enabled))))
 #+END_SRC
 
 ** golang
@@ -1623,24 +1623,24 @@ Go has a few packages to inter-operate with other emacs packages. 
 #+BEGIN_SRC emacs-lisp
   (use-package company-go
-  :commands company-go
-  :config (progn
-        (setq company-go-show-annotation t))
-  :init (progn
-      (defun ap/company-go-setup ()
-        (set (make-local-variable 'company-backends)
-           '(company-go)))
-      (add-hook 'go-mode-hook #'ap/company-go-setup)))
+    :commands company-go
+    :config (progn
+              (setq company-go-show-annotation t))
+    :init (progn
+            (defun ap/company-go-setup ()
+              (set (make-local-variable 'company-backends)
+                   '(company-go)))
+            (add-hook 'go-mode-hook #'ap/company-go-setup)))
 
   (use-package go-eldoc
-  :commands go-eldoc-setup
-  :init (progn
-      (add-hook 'go-mode-hook #'go-eldoc-setup)))
+    :commands go-eldoc-setup
+    :init (progn
+            (add-hook 'go-mode-hook #'go-eldoc-setup)))
 
   (use-package go-projectile
-  :defer t
-  :config (progn
-        (setq go-projectile-switch-gopath 'maybe)))
+    :defer t
+    :config (progn
+              (setq go-projectile-switch-gopath 'maybe)))
 
 
 #+END_SRC
@@ -1651,15 +1651,15 @@ A nice completion backend for programming modes. 
 #+BEGIN_SRC emacs-lisp
   (use-package ggtags
-  :commands turn-on-ggtags-mode
-  :functions (ggtags-navigation-mode-abort)
-  :config (progn
-        (bind-key "q" #'ggtags-navigation-mode-abort ggtags-navigation-mode-map))
-  :init (progn
-      (defun turn-on-ggtags-mode ()
-        (interactive)
-        (ggtags-mode 1))
-      (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode)))
+    :commands turn-on-ggtags-mode
+    :functions (ggtags-navigation-mode-abort)
+    :config (progn
+              (bind-key "q" #'ggtags-navigation-mode-abort ggtags-navigation-mode-map))
+    :init (progn
+            (defun turn-on-ggtags-mode ()
+              (interactive)
+              (ggtags-mode 1))
+            (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode)))
 #+END_SRC
 
 ** Lisps
@@ -1671,12 +1671,12 @@ hook which I trigger in every lispy-mode. 
 #+BEGIN_SRC emacs-lisp
   (defcustom lisp-mode-common-hook nil
-  "Hook run when entering any Lisp mode."
-  :type 'hook
-  :group 'lisp)
+    "Hook run when entering any Lisp mode."
+    :type 'hook
+    :group 'lisp)
 
   (defun ap/lisp-setup ()
-  (run-hooks 'lisp-mode-common-hook))
+    (run-hooks 'lisp-mode-common-hook))
 #+END_SRC
 
 **** Redshank
@@ -1686,10 +1686,10 @@ operations that aren’t part of paredit, like extracting variables into let bindings.
 #+BEGIN_SRC emacs-lisp
   (use-package redshank
-  :diminish " Λ"
-  :after (paredit)
-  :config (progn
-        (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode)))
+    :diminish " Λ"
+    :after (paredit)
+    :config (progn
+              (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode)))
 #+END_SRC
 
 *** Emacs Lisp
@@ -1706,21 +1706,21 @@ Go-to function for elisp.  Except it works through the entire Emacs ecosystem. 
 #+BEGIN_SRC emacs-lisp
   (use-package elisp-slime-nav
-  :commands elisp-slime-nav-mode
-  :diminish elisp-slime-nav-mode
-  :init (progn
-      (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode)))
+    :commands elisp-slime-nav-mode
+    :diminish elisp-slime-nav-mode
+    :init (progn
+            (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode)))
 #+END_SRC
 
 Interactive elisp
 
 #+BEGIN_SRC emacs-lisp
   (use-package ielm
-  :defer t
-  :ensure nil
-  :config (progn
-        (add-hook 'ielm-mode-hook (lambda ()
-                      (run-hooks 'lisp-mode-common-hook)))))
+    :defer t
+    :ensure nil
+    :config (progn
+              (add-hook 'ielm-mode-hook (lambda ()
+                                          (run-hooks 'lisp-mode-common-hook)))))
 #+END_SRC
 
 *** Scheme & Lisp
@@ -1732,7 +1732,7 @@ (add-hook 'scheme-mode-hook #'ap/lisp-setup)   (add-hook 'lisp-mode-hook #'ap/lisp-setup)
   (defun set-common-lisp-indentation ()
     (set (make-local-variable 'lisp-indent-function)
-       #'common-lisp-indent-function))
+         #'common-lisp-indent-function))
   (add-hook 'lisp-mode-hook #'set-common-lisp-indentation)
 #+END_SRC
 
@@ -1743,10 +1743,10 @@ future. 
 #+BEGIN_SRC emacs-lisp
   (use-package geiser
-  :commands (geiser-mode
-         geiser
-         run-geiser
-         run-racket))
+    :commands (geiser-mode
+               geiser
+               run-geiser
+               run-racket))
 #+END_SRC
 
 **** slime
@@ -1755,33 +1755,33 @@ A REPL thing (and more) for Lisp. 
 #+BEGIN_SRC emacs-lisp
   (use-package slime
-  :commands (slime)
-  :config (progn
-        (let ((ql-slime-helper (expand-file-name "~/quicklisp/slime-helper.el")))
-        (if (file-exists-p ql-slime-helper)
-          (load ql-slime-helper))
-        (slime-setup))
-        (setq inferior-lisp-program (executable-find "sbcl"))))
+    :commands (slime)
+    :config (progn
+              (let ((ql-slime-helper (expand-file-name "~/quicklisp/slime-helper.el")))
+                (if (file-exists-p ql-slime-helper)
+                    (load ql-slime-helper))
+                (slime-setup))
+              (setq inferior-lisp-program (executable-find "sbcl"))))
 #+END_SRC
 
 *** Clojure
 
 #+BEGIN_SRC emacs-lisp
   (use-package clojure-mode
-  :defer t
-  :init (progn
-      (add-hook 'cider-repl-mode-hook (lambda () (highlight-changes-mode -1)))
-      (add-hook 'clojure-mode-hook #'ap/lisp-setup)))
+    :defer t
+    :init (progn
+            (add-hook 'cider-repl-mode-hook (lambda () (highlight-changes-mode -1)))
+            (add-hook 'clojure-mode-hook #'ap/lisp-setup)))
 
   (use-package clj-refactor
-  :defer t
-  :functions (clj-refactor-mode cljr-add-keybindings-with-prefix)
-  :config (progn
-        (cljr-add-keybindings-with-prefix "C-c C-m"))
-  :init (progn
-      (defun turn-on-clj-refactor-mode ()
-        (clj-refactor-mode 1))
-      (add-hook 'clojure-mode-hook #'turn-on-clj-refactor-mode)))
+    :defer t
+    :functions (clj-refactor-mode cljr-add-keybindings-with-prefix)
+    :config (progn
+              (cljr-add-keybindings-with-prefix "C-c C-m"))
+    :init (progn
+            (defun turn-on-clj-refactor-mode ()
+              (clj-refactor-mode 1))
+            (add-hook 'clojure-mode-hook #'turn-on-clj-refactor-mode)))
 #+END_SRC
 
 **** cider
@@ -1790,11 +1790,11 @@ A REPL thing for Clojure 
 #+BEGIN_SRC emacs-lisp
   (use-package cider
-  :defer t
-  :config (progn
-        (setq nrepl-hide-special-buffers t)
-        (unbind-key "C-c C-f" cider-mode-map)
-        (add-hook 'cider-mode-hook #'eldoc-mode)))
+    :defer t
+    :config (progn
+              (setq nrepl-hide-special-buffers t)
+              (unbind-key "C-c C-f" cider-mode-map)
+              (add-hook 'cider-mode-hook #'eldoc-mode)))
 #+END_SRC
 
 ** Auto-compile
@@ -1802,8 +1802,8 @@ Auto-compile emacs lisp when saving.
 #+BEGIN_SRC emacs-lisp
   (use-package auto-compile
-  :defer t
-  :init (add-hook 'emacs-lisp-mode-hook #'auto-compile-on-save-mode))
+    :defer t
+    :init (add-hook 'emacs-lisp-mode-hook #'auto-compile-on-save-mode))
 #+END_SRC
 
 ** cc-mode
@@ -1813,15 +1813,15 @@ quite a few other modes are derived from it. 
 #+BEGIN_SRC emacs-lisp
   (use-package cc-mode
-  :defer 5
-  :init (progn
-      (add-hook 'c-mode-common-hook #'electric-indent-mode))
-  :config (progn
-        (setq c-default-style '((java-mode . "java")
-                    (awk-mode . "awk")
-                    (other . "k&r"))
-          c-basic-offset 4)
-        (c-set-offset 'case-label '+)))
+    :defer 5
+    :init (progn
+            (add-hook 'c-mode-common-hook #'electric-indent-mode))
+    :config (progn
+              (setq c-default-style '((java-mode . "java")
+                                      (awk-mode . "awk")
+                                      (other . "k&r"))
+                    c-basic-offset 4)
+              (c-set-offset 'case-label '+)))
 #+END_SRC
 
 ** quickrun
@@ -1830,7 +1830,7 @@ It’s nice to be able to quickly evaluate some code.  Although I don’t really seem to use it.
 #+BEGIN_SRC emacs-lisp
   (use-package quickrun
-  :bind (("C-c C-e" . quickrun)))
+    :bind (("C-c C-e" . quickrun)))
 #+END_SRC
 
 ** Scala
@@ -1839,14 +1839,14 @@ Let’s try using Scala. 
 #+BEGIN_SRC emacs-lisp
   (use-package scala-mode
-  :pin melpa-stable)
+    :pin melpa-stable)
 #+END_SRC
 
 And add ensime, an IDE-style environment.
 
 #+BEGIN_SRC emacs-lisp
   (use-package ensime
-  :pin melpa-stable)
+    :pin melpa-stable)
 #+END_SRC
 
 ** Web development
@@ -1860,28 +1860,28 @@ it though 
 #+BEGIN_SRC emacs-lisp
   (use-package js2-mode
-  :mode (("\\.js\\'" . js2-mode)
-       ("\\.jsx\\'" . js2-jsx-mode))
-  :interpreter ("node" . js2-mode)
-  :functions js2-next-error
-  :config (progn
-        (define-key js2-mode-map [menu-bar Javascript] nil)
-        (defun js2--imenu-around (do-it name)
-        "Don't create a menu from js2-mode"
-        (if (and (not (string-equal name "IM-Javascript-IDE"))
-             (fboundp #'do-it))
-          (do-it name)))
-        (advice-add 'imenu-add-to-menubar :around #'js2--imenu-around)
-        (defun ap/javascript-setup ()
-        (auto-indent-mode -1))
-        (defun ap/js2-prev-error ()
-        (interactive)
-        (js2-next-error -1))
-        (bind-key "M-g M-n" #'js2-next-error js2-mode-map)
-        (bind-key "M-g M-p" #'ap/js2-prev-error js2-mode-map)
-        (add-hook 'js2-mode-hook #'ap/javascript-setup)
-        (setq js2-basic-offset 2
-          js2-include-node-externs t)))
+    :mode (("\\.js\\'" . js2-mode)
+           ("\\.jsx\\'" . js2-jsx-mode))
+    :interpreter ("node" . js2-mode)
+    :functions js2-next-error
+    :config (progn
+              (define-key js2-mode-map [menu-bar Javascript] nil)
+              (defun js2--imenu-around (do-it name)
+                "Don't create a menu from js2-mode"
+                (if (and (not (string-equal name "IM-Javascript-IDE"))
+                         (fboundp #'do-it))
+                    (do-it name)))
+              (advice-add 'imenu-add-to-menubar :around #'js2--imenu-around)
+              (defun ap/javascript-setup ()
+                (auto-indent-mode -1))
+              (defun ap/js2-prev-error ()
+                (interactive)
+                (js2-next-error -1))
+              (bind-key "M-g M-n" #'js2-next-error js2-mode-map)
+              (bind-key "M-g M-p" #'ap/js2-prev-error js2-mode-map)
+              (add-hook 'js2-mode-hook #'ap/javascript-setup)
+              (setq js2-basic-offset 2
+                    js2-include-node-externs t)))
 #+END_SRC
 
 **** jade (not pug)
@@ -1903,9 +1903,9 @@ *** coffee-mode 
 #+BEGIN_SRC emacs-lisp
   (use-package coffee-mode
-  :mode ("\\.coffee\\'" . coffee-mode)
-  :config (progn
-        (setq coffee-indent-like-python-mode t)))
+    :mode ("\\.coffee\\'" . coffee-mode)
+    :config (progn
+              (setq coffee-indent-like-python-mode t)))
 #+END_SRC
 
 *** tern
@@ -1915,28 +1915,28 @@ completions, besides other IDE-like things. 
 #+BEGIN_SRC emacs-lisp
   (use-package tern
-  :commands ap/enable-tern
-  :if (executable-find "tern")
-  :defer 5
-  :config (progn
-        (setq tern-command (list (executable-find "tern")))
-        (defun ap/enable-tern ()
-        (tern-mode 1))
-        (add-hook 'js2-mode-hook #'ap/enable-tern)
-        (add-hook 'web-mode-hook #'ap/enable-tern)))
+    :commands ap/enable-tern
+    :if (executable-find "tern")
+    :defer 5
+    :config (progn
+              (setq tern-command (list (executable-find "tern")))
+              (defun ap/enable-tern ()
+                (tern-mode 1))
+              (add-hook 'js2-mode-hook #'ap/enable-tern)
+              (add-hook 'web-mode-hook #'ap/enable-tern)))
 
   (with-eval-after-load 'tern
-  (use-package company-tern))
+    (use-package company-tern))
 #+END_SRC
 
 *** json-mode
 
 #+BEGIN_SRC emacs-lisp
   (use-package json-mode
-  :mode (("\\.json\\'" . json-mode)
-       ("\\.sailsrc\\'" . json-mode)
-       ("composer\\.lock\\'" . json-mode)
-       ("\\.tern-project\\'" . json-mode)))
+    :mode (("\\.json\\'" . json-mode)
+           ("\\.sailsrc\\'" . json-mode)
+           ("composer\\.lock\\'" . json-mode)
+           ("\\.tern-project\\'" . json-mode)))
 #+END_SRC
 
 *** restclient
@@ -1947,13 +1947,13 @@ integration between the two yet. 
 #+BEGIN_SRC emacs-lisp
   (use-package restclient
-  :mode ("\\.api\\'" . restclient-mode)
-  :config (progn
-        (defun imenu-restclient-sections ()
-        (setq imenu-prev-index-position-function nil)
-        (add-to-list 'imenu-generic-expression '("Services" "^## ?\\(.+\\)$" 1) t)
-        (add-to-list 'imenu-generic-expression '("Calls" "^# ?\\(.+\\)$" 1) t))
-        (add-hook 'restclient-mode-hook #'imenu-restclient-sections)))
+    :mode ("\\.api\\'" . restclient-mode)
+    :config (progn
+              (defun imenu-restclient-sections ()
+                (setq imenu-prev-index-position-function nil)
+                (add-to-list 'imenu-generic-expression '("Services" "^## ?\\(.+\\)$" 1) t)
+                (add-to-list 'imenu-generic-expression '("Calls" "^# ?\\(.+\\)$" 1) t))
+              (add-hook 'restclient-mode-hook #'imenu-restclient-sections)))
 #+END_SRC
 
 *** sgml-mode
@@ -1961,8 +1961,8 @@ This is for HTML, since old versions of HTML were derived from SGML.
 #+BEGIN_SRC emacs-lisp
   (use-package sgml-mode
-  :defer t
-  :config (setq sgml-basic-offset 2))
+    :defer t
+    :config (setq sgml-basic-offset 2))
 #+END_SRC
 
 *** emmet-mode
@@ -1970,11 +1970,11 @@ Emmet is really nice to write HTML quickly.  Especially with
 frameworks that require multiple nested elements to do anything useful.
 #+BEGIN_SRC emacs-lisp
-(use-package emmet-mode
-  :commands (emmet-mode)
-  :diminish (emmet-mode . " >")
-  :init (progn
-      (add-hook 'web-mode-hook #'emmet-mode)))
+  (use-package emmet-mode
+    :commands (emmet-mode)
+    :diminish (emmet-mode . " >")
+    :init (progn
+            (add-hook 'web-mode-hook #'emmet-mode)))
 #+END_SRC
 
 *** web-mode
@@ -1985,20 +1985,20 @@ of them as well. 
 #+BEGIN_SRC emacs-lisp
   (use-package web-mode
-  :mode (("/views/.*\\.php\\'" . web-mode)
-       ("\\.html\\'" . web-mode)
-       ("/templates/.*\\.php\\'" . web-mode)
-       ("\\.ejs\\'" . web-mode))
-  :config (progn
-        (setq web-mode-code-indent-offset 2
-          web-mode-css-indent-offset 2
-          web-mode-markup-indent-offset 2
-          web-mode-style-padding 0
-          web-mode-script-padding 0
-          web-mode-comment-style 2
-          web-mode-enable-auto-pairing nil
-          web-mode-enable-auto-quoting nil)
-        (sp-local-pair '(web-mode) "<%" "%>")))
+    :mode (("/views/.*\\.php\\'" . web-mode)
+           ("\\.html\\'" . web-mode)
+           ("/templates/.*\\.php\\'" . web-mode)
+           ("\\.ejs\\'" . web-mode))
+    :config (progn
+              (setq web-mode-code-indent-offset 2
+                    web-mode-css-indent-offset 2
+                    web-mode-markup-indent-offset 2
+                    web-mode-style-padding 0
+                    web-mode-script-padding 0
+                    web-mode-comment-style 2
+                    web-mode-enable-auto-pairing nil
+                    web-mode-enable-auto-quoting nil)
+              (sp-local-pair '(web-mode) "<%" "%>")))
 #+END_SRC
 
 I derived a mode for twig, in order to use its =mode-hook=.
@@ -2030,15 +2030,15 @@ Make a shell-script buffer executable after saving it, if it has a shebang. 
 #+BEGIN_SRC emacs-lisp
   (add-hook 'after-save-hook
-    #'executable-make-buffer-file-executable-if-script-p)
+            #'executable-make-buffer-file-executable-if-script-p)
 
   (use-package sh-script
-  :mode (("\\.zsh\\'" . shell-script-mode)
-       ("zshenv\\'" . shell-script-mode)
-       ("zshrc\\'"  . shell-script-mode))
-  :config (setq sh-shell-file "/usr/bin/env zsh"
-          sh-indentation 2
-          sh-basic-offset 2))
+    :mode (("\\.zsh\\'" . shell-script-mode)
+           ("zshenv\\'" . shell-script-mode)
+           ("zshrc\\'"  . shell-script-mode))
+    :config (setq sh-shell-file "/usr/bin/env zsh"
+                  sh-indentation 2
+                  sh-basic-offset 2))
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp
@@ -2052,28 +2052,28 @@ nice, when I remember to use it. 
 #+BEGIN_SRC emacs-lisp
   (use-package eshell
-  :bind ("C-c s" .  eshell)
-  :config (progn
-        (setq eshell-directory-name "~/.emacs.d/eshell")
-        (add-hook 'eshell-load-hook (lambda ()
-                      (bind-key "C-c C-l" #'counsel-esh-history eshell-mode-map)))))
+    :bind ("C-c s" .  eshell)
+    :config (progn
+              (setq eshell-directory-name "~/.emacs.d/eshell")
+              (add-hook 'eshell-load-hook (lambda ()
+                                            (bind-key "C-c C-l" #'counsel-esh-history eshell-mode-map)))))
 
   (use-package em-smart
-  :ensure nil
-  :commands eshell-smart-initialize
-  :init (progn
-      (add-hook 'eshell-load-hook #'eshell-smart-initialize))
-  :config (progn
-        (setq eshell-where-to-jump 'begin
-          eshell-review-quick-commands nil
-          eshell-smart-space-goes-to-end t)))
+    :ensure nil
+    :commands eshell-smart-initialize
+    :init (progn
+            (add-hook 'eshell-load-hook #'eshell-smart-initialize))
+    :config (progn
+              (setq eshell-where-to-jump 'begin
+                    eshell-review-quick-commands nil
+                    eshell-smart-space-goes-to-end t)))
 
   (autoload #'eshell/cd "em-dirs")
   (defun eshell-goto-current-dir (&optional arg)
-  (interactive "P")
-  (let ((dir default-directory))
-    (eshell arg)
-    (eshell/cd dir)))
+    (interactive "P")
+    (let ((dir default-directory))
+      (eshell arg)
+      (eshell/cd dir)))
   (bind-key "C-c S" #'eshell-goto-current-dir)
 
 
@@ -2083,21 +2083,21 @@ *** Shells 
 #+BEGIN_SRC emacs-lisp
   (use-package shell
-  :defer t
-  :ensure nil
-  :config (define-key shell-mode-map
-        (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer))
+    :defer t
+    :ensure nil
+    :config (define-key shell-mode-map
+              (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer))
 
   (use-package comint
-  :defer t
-  :ensure nil
-  :config (bind-key "C-c C-l" #'counsel-shell-history comint-mode-map))
+    :defer t
+    :ensure nil
+    :config (bind-key "C-c C-l" #'counsel-shell-history comint-mode-map))
 
   (defun comint-delchar-or-eof-or-kill-buffer (arg)
-  (interactive "p")
-  (if (null (get-buffer-process (current-buffer)))
-    (kill-buffer)
-    (comint-delchar-or-maybe-eof arg)))
+    (interactive "p")
+    (if (null (get-buffer-process (current-buffer)))
+        (kill-buffer)
+      (comint-delchar-or-maybe-eof arg)))
 #+END_SRC
 
 * Text editing
@@ -2108,7 +2108,7 @@ #+BEGIN_SRC emacs-lisp   (put 'upcase-region 'disabled nil)
   (put 'downcase-region 'disabled nil)
   (setq sentence-end-double-space t
-    line-move-visual nil)
+        line-move-visual nil)
 #+END_SRC
 
 ** align
@@ -2118,13 +2118,13 @@ The most important one for me is JSON property alignment. 
 #+BEGIN_SRC emacs-lisp
   (use-package align
-  :defer 10
-  :ensure nil
-  :config (progn
-        (add-to-list 'align-rules-list
-               '(colon-key-value
-               (regexp . ":\\(\\s-*\\)")
-               (modes  . '(js2-mode))))))
+    :defer 10
+    :ensure nil
+    :config (progn
+              (add-to-list 'align-rules-list
+                           '(colon-key-value
+                             (regexp . ":\\(\\s-*\\)")
+                             (modes  . '(js2-mode))))))
 #+END_SRC
 
 ** Clipboard
@@ -2153,18 +2153,18 @@ Sub-word movement is really nice for camel- and Pascal-case 
 #+BEGIN_SRC emacs-lisp
   (use-package subword
-  :diminish subword-mode
-  :init (global-subword-mode t))
+    :diminish subword-mode
+    :init (global-subword-mode t))
 #+END_SRC
 
 I find that =zap-up-to-char= normally makes more sense to me than
 =zap-to-char=.
 
 #+BEGIN_SRC emacs-lisp
-(use-package misc
-  :ensure nil
-  :bind (("M-z" . zap-up-to-char)
-     ("M-Z" . zap-to-char)))
+  (use-package misc
+    :ensure nil
+    :bind (("M-z" . zap-up-to-char)
+           ("M-Z" . zap-to-char)))
 #+END_SRC
 
 Expanding the region by semantic units was something I quite liked
@@ -2172,8 +2172,8 @@ from Sublime Text.  As always, there’s a mode for that. 
 #+BEGIN_SRC emacs-lisp
   (use-package expand-region
-  :bind ("C-M-SPC" . er/expand-region)
-  :config (setq expand-region-fast-keys-enabled nil))
+    :bind ("C-M-SPC" . er/expand-region)
+    :config (setq expand-region-fast-keys-enabled nil))
 #+END_SRC
 
 ** Typography
@@ -2192,15 +2192,15 @@ somehow I prefer it. 
 #+BEGIN_SRC emacs-lisp
   (use-package avy
-  :bind* (("M-g g" . avy-goto-line)
-      ("M-g M-g" . avy-goto-line)
-      ("C-|" . avy-goto-line)
-      ("M-r" . avy-goto-word-1)
-      ("C-c SPC" . avy-goto-char-timer))
-  :config (progn
-        (avy-setup-default)
-        (setq avy-all-windows nil
-          avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;))))
+    :bind* (("M-g g" . avy-goto-line)
+            ("M-g M-g" . avy-goto-line)
+            ("C-|" . avy-goto-line)
+            ("M-r" . avy-goto-word-1)
+            ("C-c SPC" . avy-goto-char-timer))
+    :config (progn
+              (avy-setup-default)
+              (setq avy-all-windows nil
+                    avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;))))
 #+END_SRC
 
 ** goto-chg
@@ -2209,8 +2209,8 @@ This is like popping the mark, only it filters to only change areas and doesn’t go back to the same place more than once.
 
 #+BEGIN_SRC emacs-lisp
-(use-package goto-chg
-  :bind ("C-c C-SPC" . goto-last-change))
+  (use-package goto-chg
+    :bind ("C-c C-SPC" . goto-last-change))
 #+END_SRC
 
 ** multiple-cursors
@@ -2221,13 +2221,13 @@ saw that multiple-cursors was released for Emacs. 
 #+BEGIN_SRC emacs-lisp
   (use-package multiple-cursors
-  :defer 1
-  :config (progn
-        (bind-key "C-." #'mc/mark-next-like-this)
-        (bind-key "C-," #'mc/mark-previous-like-this)
-        (bind-key "M-<f3>" #'mc/mark-all-like-this-dwim)
-        (bind-key "C-<f3>" #'mc/mark-more-like-this-extended)
-        (bind-key "C-S-L" #'mc/edit-lines)))
+    :defer 1
+    :config (progn
+              (bind-key "C-." #'mc/mark-next-like-this)
+              (bind-key "C-," #'mc/mark-previous-like-this)
+              (bind-key "M-<f3>" #'mc/mark-all-like-this-dwim)
+              (bind-key "C-<f3>" #'mc/mark-more-like-this-extended)
+              (bind-key "C-S-L" #'mc/edit-lines)))
 #+END_SRC
 
 ** paredit
@@ -2237,12 +2237,12 @@ movement commands are much more interesting. 
 #+BEGIN_SRC emacs-lisp
   (use-package paredit
-  :diminish "()"
-  :config (progn
-        (add-hook 'lisp-mode-common-hook #'enable-paredit-mode)
-        (put #'paredit-forward-delete 'delete-selection 'supersede)
-        (put #'paredit-backward-delete 'delete-selection 'supersede)
-        (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode)))
+    :diminish "()"
+    :config (progn
+              (add-hook 'lisp-mode-common-hook #'enable-paredit-mode)
+              (put #'paredit-forward-delete 'delete-selection 'supersede)
+              (put #'paredit-backward-delete 'delete-selection 'supersede)
+              (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode)))
 #+END_SRC
 
 ** smartparens
@@ -2254,31 +2254,31 @@ #+BEGIN_SRC emacs-lisp
   (eval-when-compile (require 'smartparens nil :noerror))
   (use-package smartparens-config
-  :ensure smartparens
-  :config (progn
-        (sp-use-smartparens-bindings)
-        (setq sp-highlight-pair-overlay nil)
-        (fset 'wrap-with-paren "\C-](") ;; `sp-select-next-thing-exchange'
-        (bind-key "C-(" #'wrap-with-paren smartparens-mode-map)
-        (bind-key "C-)" #'sp-forward-slurp-sexp smartparens-mode-map)
-        (bind-key "M-<backspace>" #'backward-kill-word smartparens-mode-map)
-        (bind-key "M-?" #'sp-convolute-sexp smartparens-mode-map)
-        (bind-key "C-M-t" #'sp-transpose-sexp smartparens-mode-map)
-        (bind-key "M-R" #'sp-raise-sexp smartparens-mode-map)
-        (bind-key "M-S" #'sp-splice-sexp smartparens-mode-map)
-        (bind-key "C-M-s" #'sp-split-sexp smartparens-mode-map)
-        (bind-key "M-J" #'sp-join-sexp smartparens-mode-map)
-        (bind-key "M-<up>" #'sp-splice-sexp-killing-backward smartparens-mode-map)
-        (bind-key "M-<down>" #'sp-splice-sexp-killing-forward smartparens-mode-map)
-        (bind-key "C-M-S-k" #'sp-kill-hybrid-sexp smartparens-mode-map)
-        (bind-key "C-S-<right>" #'sp-slurp-hybrid-sexp smartparens-mode-map)
-        (sp-with-modes '(twig-mode)
-        (sp-local-pair "{%" "%}")
-        (sp-local-pair "{{" "}}"))
-        (show-smartparens-global-mode t)
-        (smartparens-global-strict-mode t)
-        (add-hook 'lisp-mode-common-hook #'turn-off-smartparens-mode)
-        (add-hook 'coffee-mode-hook #'turn-off-smartparens-mode)))
+    :ensure smartparens
+    :config (progn
+              (sp-use-smartparens-bindings)
+              (setq sp-highlight-pair-overlay nil)
+              (fset 'wrap-with-paren "\C-](") ;; `sp-select-next-thing-exchange'
+              (bind-key "C-(" #'wrap-with-paren smartparens-mode-map)
+              (bind-key "C-)" #'sp-forward-slurp-sexp smartparens-mode-map)
+              (bind-key "M-<backspace>" #'backward-kill-word smartparens-mode-map)
+              (bind-key "M-?" #'sp-convolute-sexp smartparens-mode-map)
+              (bind-key "C-M-t" #'sp-transpose-sexp smartparens-mode-map)
+              (bind-key "M-R" #'sp-raise-sexp smartparens-mode-map)
+              (bind-key "M-S" #'sp-splice-sexp smartparens-mode-map)
+              (bind-key "C-M-s" #'sp-split-sexp smartparens-mode-map)
+              (bind-key "M-J" #'sp-join-sexp smartparens-mode-map)
+              (bind-key "M-<up>" #'sp-splice-sexp-killing-backward smartparens-mode-map)
+              (bind-key "M-<down>" #'sp-splice-sexp-killing-forward smartparens-mode-map)
+              (bind-key "C-M-S-k" #'sp-kill-hybrid-sexp smartparens-mode-map)
+              (bind-key "C-S-<right>" #'sp-slurp-hybrid-sexp smartparens-mode-map)
+              (sp-with-modes '(twig-mode)
+                (sp-local-pair "{%" "%}")
+                (sp-local-pair "{{" "}}"))
+              (show-smartparens-global-mode t)
+              (smartparens-global-strict-mode t)
+              (add-hook 'lisp-mode-common-hook #'turn-off-smartparens-mode)
+              (add-hook 'coffee-mode-hook #'turn-off-smartparens-mode)))
 #+END_SRC
 
 ** smart-scan
@@ -2287,8 +2287,8 @@ Move between instances of a symbol 
 #+BEGIN_SRC emacs-lisp
   (use-package smartscan
-  :config (progn
-        (smartscan-mode 1)))
+    :config (progn
+              (smartscan-mode 1)))
 #+END_SRC
 
 ** move-text
@@ -2297,7 +2297,7 @@ Transposing lines, made easier. 
 #+BEGIN_SRC emacs-lisp
   (use-package move-text
-  :config (move-text-default-bindings))
+    :config (move-text-default-bindings))
 #+END_SRC
 
 ** undo-tree
@@ -2307,20 +2307,20 @@ it much clearer.  It’s especially helpful for protoyping and refactoring. 
 #+BEGIN_SRC emacs-lisp
   (use-package undo-tree
-  :config (progn
-        (global-undo-tree-mode)
-        ;; Keep region when undoing in region
-        (defadvice undo-tree-undo (around keep-region activate)
-        (if (use-region-p)
-          (let ((m (set-marker (make-marker) (mark)))
-              (p (set-marker (make-marker) (point))))
-            ad-do-it
-            (goto-char p)
-            (set-mark m)
-            (set-marker p nil)
-            (set-marker m nil))
-          ad-do-it)))
-  :diminish undo-tree-mode)
+    :config (progn
+              (global-undo-tree-mode)
+              ;; Keep region when undoing in region
+              (defadvice undo-tree-undo (around keep-region activate)
+                (if (use-region-p)
+                    (let ((m (set-marker (make-marker) (mark)))
+                          (p (set-marker (make-marker) (point))))
+                      ad-do-it
+                      (goto-char p)
+                      (set-mark m)
+                      (set-marker p nil)
+                      (set-marker m nil))
+                  ad-do-it)))
+    :diminish undo-tree-mode)
 #+END_SRC
 
 ** visual-regexp
@@ -2331,9 +2331,9 @@ the buffer for me. 
 #+BEGIN_SRC emacs-lisp
   (use-package visual-regexp
-  :bind (("C-c r" . vr/replace)
-       ("C-c q" . vr/query-replace)
-       ("C-c m" . vc/mc-mark)))
+    :bind (("C-c r" . vr/replace)
+           ("C-c q" . vr/query-replace)
+           ("C-c m" . vc/mc-mark)))
 #+END_SRC
 * Tangling
 
@@ -2351,39 +2351,39 @@ the =org=-document after changes. 
 #+BEGIN_SRC emacs-lisp
   (use-package async
-  :commands (async-start)
-  :defer 2)
+    :commands (async-start)
+    :defer 2)
 
   (defun tangle-if-init ()
-  "If the current buffer is 'init.org' the code-blocks are
+    "If the current buffer is 'init.org' the code-blocks are
     tangled, and the tangled file is compiled."
 
-  (when (string-suffix-p "init.org" (buffer-file-name))
-    (tangle-init)))
+    (when (string-suffix-p "init.org" (buffer-file-name))
+      (tangle-init)))
 
   (defun tangle-init-sync ()
-  (interactive)
-  (message "Tangling init")
-  ;; Avoid running hooks when tangling.
-  (let ((prog-mode-hook nil)
-      (src  (expand-file-name "init.org" user-emacs-directory))
-      (dest (expand-file-name "init.el"  user-emacs-directory)))
-    (require 'ob-tangle)
-    (org-babel-tangle-file src dest)
-    (if (byte-compile-file dest)
-      (byte-compile-dest-file dest)
-    (with-current-buffer byte-compile-log-buffer
-      (buffer-string)))))
+    (interactive)
+    (message "Tangling init")
+    ;; Avoid running hooks when tangling.
+    (let ((prog-mode-hook nil)
+          (src  (expand-file-name "init.org" user-emacs-directory))
+          (dest (expand-file-name "init.el"  user-emacs-directory)))
+      (require 'ob-tangle)
+      (org-babel-tangle-file src dest)
+      (if (byte-compile-file dest)
+          (byte-compile-dest-file dest)
+        (with-current-buffer byte-compile-log-buffer
+          (buffer-string)))))
 
   (defun tangle-init ()
-  "Tangle init.org asynchronously."
+    "Tangle init.org asynchronously."
 
-  (interactive)
-  (message "Tangling init")
-  (async-start
-   (symbol-function #'tangle-init-sync)
-   (lambda (result)
-     (message "Init tangling completed: %s" result))))
+    (interactive)
+    (message "Tangling init")
+    (async-start
+     (symbol-function #'tangle-init-sync)
+     (lambda (result)
+       (message "Init tangling completed: %s" result))))
 #+END_SRC
 
 # Local Variables:
@@ -2394,14 +2394,14 @@ Start a server if possible.  A daemon is already a server.
 #+BEGIN_SRC emacs-lisp
   (run-with-idle-timer 2 nil (lambda ()
-                 (unless (daemonp)
-                 (require 'server)
-                 (unless (server-running-p server-name)
-                   (server-start)))))
+                               (unless (daemonp)
+                                 (require 'server)
+                                 (unless (server-running-p server-name)
+                                   (server-start)))))
   (setq gc-cons-threshold 800000
-    file-name-handler-alist '(("\\(?:\\.dz\\|\\.txz\\|\\.xz\\|\\.lzma\\|\\.lz\\|\\.g?z\\|\\.\\(?:tgz\\|svgz\\|sifz\\)\\|\\.tbz2?\\|\\.bz2\\|\\.Z\\)\\(?:~\\|\\.~[-[:alnum:]:#@^._]+\\(?:~[[:digit:]]+\\)?~\\)?\\'" . jka-compr-handler)
-                  ("\\.gpg\\(~\\|\\.~[0-9]+~\\)?\\'" . epa-file-handler)
-                  ("\\`/[^/]*\\'" . tramp-completion-file-name-handler)
-                  ("\\`/[^/|:][^/|]*:" . tramp-file-name-handler)
-                  ("\\`/:" . file-name-non-special)))
+        file-name-handler-alist '(("\\(?:\\.dz\\|\\.txz\\|\\.xz\\|\\.lzma\\|\\.lz\\|\\.g?z\\|\\.\\(?:tgz\\|svgz\\|sifz\\)\\|\\.tbz2?\\|\\.bz2\\|\\.Z\\)\\(?:~\\|\\.~[-[:alnum:]:#@^._]+\\(?:~[[:digit:]]+\\)?~\\)?\\'" . jka-compr-handler)
+                                  ("\\.gpg\\(~\\|\\.~[0-9]+~\\)?\\'" . epa-file-handler)
+                                  ("\\`/[^/]*\\'" . tramp-completion-file-name-handler)
+                                  ("\\`/[^/|:][^/|]*:" . tramp-file-name-handler)
+                                  ("\\`/:" . file-name-non-special)))
 #+END_SRC