summary refs log tree commit diff stats
path: root/tag-emacs
diff options
context:
space:
mode:
authorAlan Pearce2017-03-17 09:48:24 +0100
committerAlan Pearce2017-03-17 09:48:24 +0100
commit397ce671bb028802d528faf8811101e08557e527 (patch)
tree6a3b0004c7fcbe334f05a50aad483316c6577887 /tag-emacs
parentdb6903e6fab9cff359a530ca2eee6ba3c7e44525 (diff)
downloaddotfiles-397ce671bb028802d528faf8811101e08557e527.tar.lz
dotfiles-397ce671bb028802d528faf8811101e08557e527.tar.zst
dotfiles-397ce671bb028802d528faf8811101e08557e527.zip
Re-structure tags to GNU stow format
Diffstat (limited to 'tag-emacs')
-rw-r--r--tag-emacs/emacs.d/init.org2522
1 files changed, 0 insertions, 2522 deletions
diff --git a/tag-emacs/emacs.d/init.org b/tag-emacs/emacs.d/init.org
deleted file mode 100644
index 151efbf..0000000
--- a/tag-emacs/emacs.d/init.org
+++ /dev/null
@@ -1,2522 +0,0 @@
-#+TITLE: Emacs Configuration for Alan Pearce
-#+OPTIONS: ^:nil
-#+PROPERTY: results silent
-#+PROPERTY: eval no-export
-#+PROPERTY: header-args :comments link
-* Introduction
-This is a living document, detailing my Emacs configuration using org-mode
-* Basics
-** Startup
-Open Emacs with just a plain window.  No graphics or messages, please!
-#+BEGIN_SRC emacs-lisp
-(put 'inhibit-startup-echo-area-message 'saved-value
-     (setq inhibit-startup-echo-area-message (user-login-name)))
-(setq inhibit-startup-screen t)
-(setq gc-cons-threshold 100000000)
-(defvar file-name-handler-alist-backup file-name-handler-alist)
-(setq file-name-handler-alist nil)
-(remove-hook 'find-file-hooks #'vc-refresh-state)
-#+END_SRC
-
-** Scratch buffers
-I usually use scratch buffers for any sort of text.  If I need a
-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)
-#+END_SRC
-
-** Personal Information
-#+BEGIN_SRC emacs-lisp
-(setq user-mail-address "alan@alanpearce.co.uk"
-      user-full-name "Alan Pearce")
-#+end_src
-
-* Packaging
-
-** Use-package
-
-#+BEGIN_SRC emacs-lisp
-(eval-and-compile
-  (setq tls-checktrust t
-        gnutls-verify-error t
-        package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
-                           ("melpa-stable" . "https://stable.melpa.org/packages/")
-                           ("melpa" . "https://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))
-(setq use-package-verbose t
-      use-package-always-ensure t
-      package-enable-at-startup nil)
-#+END_SRC
-
-* Customize
-I don’t really like using customize for normal configuration.
-Instead, I use it for things that get saved automatically.  That’s why
-I use a different file, which is ignored by the VCS.  It also means
-that it’s not important whether the file exists or not, which is why I
-pass =:noerror= to =load=
-
-#+BEGIN_SRC emacs-lisp
-(setq custom-file "~/.emacs.d/custom.el")
-(load custom-file :noerror :nomessage)
-#+END_SRC
-
-* Styles
-
-I prefer an always-visible cursor.  Feels less distracting.
-#+BEGIN_SRC emacs-lisp
-(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))
-(with-eval-after-load 'scroll-bar
-  (set-scroll-bar-mode nil))
-(with-eval-after-load 'tooltip
-  (tooltip-mode -1))
-(with-eval-after-load 'tool-bar
-  (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))))
-#+END_SRC
-
-#+BEGIN_SRC emacs-lisp
-(use-package dash)
-#+END_SRC
-
-** Colours
-
-Let’s try a more minimal theme.
-
-#+BEGIN_SRC emacs-lisp
-(use-package minimal-theme
-  :disabled t
-  :config (progn
-            (load-theme 'minimal-light t)))
-#+END_SRC
-
-Let’s try a basic theme.
-
-#+BEGIN_SRC emacs-lisp
-(use-package basic-theme
-  :if (display-graphic-p)
-  :config (progn
-            (load-theme 'basic t)
-
-            (set-face-background 'mode-line "#a1b56c")
-            (set-face-background 'border "#a1b56c")
-            (set-face-foreground 'border "#a1b56c")
-            (set-face-background 'vertical-border "#a1b56c")
-            (set-face-foreground 'vertical-border "#a1b56c")
-            (set-face-background 'window-divider "#a1b56c")
-            (set-face-foreground 'window-divider "#a1b56c")
-
-            (defvar mode-line-default-format mode-line-format)
-            (defvar mode-line-default-hidden nil
-              "Whether to hide the mode line by default")
-
-            (defun show-mode-line ()
-              (interactive)
-              (setq mode-line-format mode-line-default-format)
-              (when (called-interactively-p 'interactive)
-                (setq-default mode-line-format mode-line-default-format)
-                (setq mode-line-default-hidden nil)))
-            (defun hide-mode-line ()
-              (interactive)
-              (setq mode-line-format nil)
-              (when (called-interactively-p 'interactive)
-                (setq-default mode-line-format nil)
-                (setq mode-line-default-hidden t)))
-
-            (setq-default cursor-type '(bar . 1))
-            (setq-default cursor-in-non-selected-windows nil)
-
-            (defun hide-clutter ()
-              (interactive)
-              (fringe-mode '(0 . 4))
-              (hide-mode-line))
-
-            (defun show-clutter ()
-              (interactive)
-              (fringe-mode '(8 . 4))
-              (show-mode-line))
-            (hide-clutter)
-
-            (when mode-line-default-hidden
-              (call-interactively #'hide-mode-line))
-
-            (defun hide-mode-line-if-default-hidden ()
-              (if mode-line-default-hidden
-                  (hide-mode-line)
-                (show-mode-line)))
-
-            (add-to-list 'default-frame-alist '(border-width . 0))
-            (add-to-list 'default-frame-alist '(internal-border-width . 0))
-            (when (eq window-system 'x)
-              (setq window-divider-default-bottom-width 1
-                    window-divider-default-right-width 1
-                    window-divider-default-places t)
-              (setq mode-line-default-hidden t)
-              (window-divider-mode +1))
-
-            (add-hook 'after-change-major-mode-hook #'hide-mode-line-if-default-hidden)
-
-            (add-hook 'minibuffer-setup-hook #'show-mode-line)
-            (add-hook 'minibuffer-exit-hook #'hide-mode-line)))
-#+END_SRC
-
-Highlighting quasi-quoted expressions in lisps is quite useful, but I
-don't need it all the time.  I'll keep it around for a while so that I
-can enable it if needed.
-#+BEGIN_SRC emacs-lisp
-(use-package highlight-stages
-  :diminish highlight-stages-mode)
-#+END_SRC
-
-** Fonts
-
-When possible, set up fonts.  I don’t have any settings here for X11,
-because I manage those in my [[file:~/projects/dotfiles/tag-xresources/xresources/main][XResources file]].
-#+BEGIN_SRC emacs-lisp
-(when (or (display-graphic-p)
-          (daemonp))
-
-  (defun use-variable-fonts ()
-    (interactive)
-    (variable-pitch-mode)
-    (setq cursor-type 'bar))
-
-  (defun ap/set-fonts (mono-face mono-font-size variable-face variable-font-size antialias)
-    (if (boundp 'ns-antialias-text)
-      (setq ns-antialias-text antialias))
-    (when mono-face
-      (let ((default-font (font-spec :family mono-face :size  mono-font-size)))
-        (add-to-list 'default-frame-alist `(font . ,(format "%s %s" mono-face mono-font-size)))
-        (set-face-font 'fixed-pitch default-font)
-        (set-frame-font default-font t t)))
-    (when variable-face
-      (set-face-font 'variable-pitch (font-spec :name variable-face :size variable-font-size))))
-
-  (defun ap/set-fonts-according-to-system ()
-    (interactive)
-    (cond
-     ((eq window-system 'w32)
-      (ap/set-fonts "Liberation Mono" 11 "Segoe UI" 11 t))
-     ((eq window-system 'ns)
-      (let ((displays (string-to-number (shell-command-to-string "system_profiler SPDisplaysDataType | grep \"Online: Yes\" | wc -l"))))
-        (if (eq displays 1)
-            (ap/set-fonts "Roboto Mono" 13 "Lucida Grande" 13 t)
-          (ap/set-fonts "Monaco" 10 "Lucida Grande" 12 nil))))
-     ((eq window-system 'x)
-      (set-fontset-font "fontset-default" 'unicode (font-spec :name "Terminus" :size 8))
-      (ap/set-fonts "Fixed" 8 "Lucida" 8 nil))))
-
-  (ap/set-fonts-according-to-system))
-#+END_SRC
-
-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)))
-#+END_SRC
-
-** Page Breaks
-
-By default, Emacs displays page breaks as ^L.  Lines look much nicer.
-On Windows, Emacs incorrectly detects that U+2500 (Box Drawings Light
-Horizontal) can only be displayed with a different font, which is not
-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)))))
-#+END_SRC
-** Modeline
-
-#+BEGIN_SRC emacs-lisp
-(column-number-mode t)
-(size-indication-mode t)
-
-(setq frame-title-format '("%f" (dired-directory dired-directory)))
-#+END_SRC
-
-** Highlight Changes
-
-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)))
-#+END_SRC
-
-** Beacon
-
-I was against the idea of having flashy animations inside Emacs, but
-this one is useful.  It highlights the cursor when scrolling or
-switching windows.
-
-#+BEGIN_SRC emacs-lisp
-(use-package beacon
-  :diminish beacon-mode
-  :config (beacon-mode +1))
-#+END_SRC
-
-** Renaming major modes
-
-Diminishing major modes does not happen in the same manner as minor
-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)))
-#+END_SRC
-
-
-* Environment Variables
-
-MacOS doesn’t have a reasonable way to set environment variables and
-read them automatically any more.  So, let’s use the
-[[https://github.com/purcell/exec-path-from-shell][exec-path-from-shell]] package to set up ~exec-path~ and similar
-variables from whatever my shell configuration is.
-
-#+BEGIN_SRC emacs-lisp
-(use-package exec-path-from-shell
-  :if (eq system-type 'darwin)
-  :config (exec-path-from-shell-initialize))
-#+END_SRC
-
-* Keybindings
-
-I think =set-keyboard-coding-system= stops OS X from doing something
-annoying to add accents.  The modifier setup is to match my
-re-arrangement of modifiers on OSX: Cmd on the outside, then
-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"))
-#+END_SRC
-
-#+BEGIN_SRC emacs-lisp
-(unbind-key "<f4>")
-(bind-key* "<f5>" #'compile)
-(bind-key* "<f6>" #'kmacro-start-macro-or-insert-counter)
-(bind-key* "<f7>" #'kmacro-end-or-call-macro)
-
-(bind-key* "<apps>" #'execute-extended-command)
-
-(unbind-key "C-z")
-(bind-key* "C-<tab>" #'other-window)
-
-(bind-key* "C-x C-r" #'revert-buffer)
-(bind-key* "C-x C-j" #'delete-indentation)
-(unbind-key "C-x C-c")
-
-(bind-key* "C-c i" #'insert-char)
-(bind-key* "M-/" #'hippie-expand)
-
-(unbind-key "s-h")
-(unbind-key "s-n")
-(unbind-key "s-p")
-(unbind-key "s-w")
-(bind-key* "s-k" #'kill-or-delete-this-buffer-dwim)
-
-(bind-key "C-M-a" #'backward-paragraph text-mode-map)
-(bind-key "C-M-e" #'forward-paragraph text-mode-map)
-
-(bind-key* "s-x" (define-prefix-command 'super-x-map))
-(bind-key* "s-," #'switch-to-dotfiles)
-(bind-key* "C-M-x" #'execute-extended-command)
-(set-register ?z `(file . ,(expand-file-name ".config/zsh/zshrc" "~")))
-#+END_SRC
-
-** Crux
-
-I can replace most of the simple helper/wrapper functions in my
-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)
-
-         ("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
-(defun switch-to-dotfiles ()
-  (interactive)
-  (projectile-switch-project-by-name (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))
-
-(use-package wgrep-ag
-  :after ag)
-#+END_SRC
-
-** Ripgrep
-
-Step over Silver Search, here comes a new challenger.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ripgrep
-  :if (executable-find "rg"))
-
-(use-package projectile-ripgrep
-  :after (ripgrep projectile)
-  :if (executable-find "rg")
-  :bind (("C-c p s r" . projectile-ripgrep)))
-#+END_SRC
-
-** Projectile
-
-Projectile is awesome for working in projects, especially VCS-backed
-ones.  I added a couple of functions to allow me to open new projects
-based upon some folder conventions I use.
-
-#+BEGIN_SRC emacs-lisp
-(use-package projectile
-  :bind (("s-p" . projectile-switch-project)
-         ("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 yarn-install (&optional arg)
-              (interactive "P")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" "install")))
-
-            (defun yarn-add-dev (package)
-              (interactive "spackage: ")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" (concat "add --dev " package))))
-
-            (defun yarn-add (package)
-              (interactive "spackage: ")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" (concat "add " package))))
-
-            (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))
-
-            (setq projectile-switch-project-action #'projectile-commander
-                  projectile-completion-system 'ivy)))
-#+END_SRC
-
-** vc
-
-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)
-            (setq vc-ignore-dir-regexp (format "\\(%s\\)\\|\\(%s\\)"
-                                               vc-ignore-dir-regexp
-                                               tramp-file-name-regexp))))
-#+END_SRC
-
-** git-gutter-fringe
-
-It’s nice to be able to see at a glance which lines of a file have
-changed.  This package colours the fringe.  I have it set to the right
-fringe so it doesn’t interfere with flycheck.
-
-#+BEGIN_SRC emacs-lisp
-(use-package git-gutter-fringe
-  :defer 2
-  :diminish git-gutter-mode
-  :config (progn
-            (global-git-gutter-mode 1)
-            (set-face-foreground 'git-gutter:modified "grey")
-            (setq git-gutter-fr:side 'right-fringe)))
-#+END_SRC
-
-** magit
-
-Magit is my favourite way to use git.  I use selective staging all the
-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-completing-read-function #'ivy-completing-read
-                       magit-popup-use-prefix-argument 'default
-                       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
-
-This package allow me to go through a file’s history with just a few
-keys.  It makes it very easy to figure what what exactly was in a file
-in the past.  I often find it useful when I remember writing something
-a particular way, but it changed later.
-
-#+BEGIN_SRC emacs-lisp
-(use-package git-timemachine
-  :commands git-timemachine)
-#+END_SRC
-
-* Files
-
-** Auto-saving
-
-Auto-save everything to a temporary directory, instead of cluttering
-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)
-#+END_SRC
-** Backups
-
-I like to keep my backups out of regular folders.  I tell emacs to use
-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))
-(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))))
-#+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)))))
-#+END_SRC
-
-** Encoding
-
-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)
-#+END_SRC
-
-** Buffer-file management
-
-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)
-#+END_SRC
-
-I often want to rename or delete the file that I’m currently visiting
-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)))))
-#+END_SRC
-
-** Whitespace Butler
-
-I don’t like it when editors change an entire file’s layout when I
-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 (daemonp)
-    (add-hook 'before-make-frame-hook (lambda ()
-                                        (use-package ws-butler
-                                          :config (ws-butler-global-mode 1)))))
-#+END_SRC
-
-** shrink-whitespace
-
-DWIM whitespace removal.  So I don’t need =M-SPC=, =M-\= and =C-x o=
-for similar things any more.
-
-#+BEGIN_SRC emacs-lisp
-(use-package shrink-whitespace
-  :bind ("M-SPC" . shrink-whitespace))
-#+END_SRC
-
-** Tramp
-
-Tramp is awesome.  It makes SSH feel Unix-y.  The proxy setup is so
-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" (format "/run/user/%s/ssh-agent" (user-uid))))
-            (setq tramp-default-method "ssh"
-                  tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
-                  tramp-backup-directory-alist backup-directory-alist
-                  tramp-completion-reread-directory-timeout 60
-                  tramp-ssh-controlmaster-options nil
-                  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))))
-
-(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")))
-#+END_SRC
-
-** ediff
-
-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)))
-#+END_SRC
-
-* Indentation
-
-Ah, a complicated topic.  One day we’ll all be using elastic
-tabstops.  I’ve recently switched to using two spaces, since elastic
-tabstops is probably never going to happen.
-
-#+BEGIN_SRC emacs-lisp
-(setq-default tab-width 2
-              indent-tabs-mode nil)
-#+END_SRC
-
-
-** smart-tabs-mode
-
-Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns
-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)))))
-#+END_SRC
-
-** editorconfig
-
-#+BEGIN_SRC emacs-lisp
-(use-package editorconfig
-  :config (editorconfig-mode 1))
-#+END_SRC
-
-** dtrt-indent-mode
-
-Sometimes people use different indentation settings.  [[https://github.com/jscheid/dtrt-indent][dtrt-indent]]
-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)))))
-#+END_SRC
-
-* Security
-
-** password-store
-
-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)))
-#+END_SRC
-* Buffers
-
-** Ibuffer
-Ibuffer is quite nice for listing all buffers.
-
-#+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"))))))
-
-            ;; 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)))))
-#+END_SRC
-
-** Relative Buffer names
-
-#+BEGIN_SRC emacs-lisp
-(use-package relative-buffers
-  :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)
-#+END_SRC
-
-** ace-window
-
-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))))
-#+END_SRC
-
-* Windows
-
-Scrolling is tricky.  I use this setup to help me keep track of the
-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)
-(if (boundp 'ns-pop-up-frames)
-    (setq ns-pop-up-frames nil))
-#+END_SRC
-
-** winner
-
-Undo, for window-based commands.
-
-#+BEGIN_SRC emacs-lisp
-(use-package winner
-  :config (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))
-  :init (progn
-          (winner-mode 1)))
-#+END_SRC
-
-** windmove
-
-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)))
-#+END_SRC
-* Completion
-
-Make built-in completion a bit more intelligent, by adding substring
-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)
-#+END_SRC
-
-** Company
-
-The main choices for automatic completion in Emacs are company and
-auto-complete-mode.  I’ve not tried auto-complete-mode as company
-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-gtags
-                                                               company-etags company-keywords) company-oddmuse)
-                company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
-                                    company-preview-frontend
-                                    company-echo-metadata-frontend)
-                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)))
-#+END_SRC
-
-#+BEGIN_SRC emacs-lisp
-(use-package company-web
-  :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)))
-#+END_SRC
-
-* Dates & Times
-
-** Calendar
-
-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)))
-#+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-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))
-#+END_SRC
-
-* Directories
-
-Dired works quite nicely, but not always in the way I want.  I don’t
-like having so many prompts for recursive operations.  Also, when I
-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")
-            (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))
-
-(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
-                  dired-bind-jump nil))
-  :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)))
-#+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))))
-#+END_SRC
-
-** Dired-narrow
-One can already use dired with wildcards to browse a filtered
-directory listing, but it opens a new buffer.  Dired-narrow is a
-slightly nicer interface: with a currently-open dired buffer, use =/=
-to start filtering, =RET= to complete the filter and =g= to refresh
-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))))
-#+END_SRC
-
-* Documentation
-
-** ehelp
-
-ehelp is a less well-known package that’s part of Emacs and slightly
-improves the normal help commands, mostly by making quitting them easier.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ehelp
-  :bind-keymap ("C-h" . ehelp-map))
-#+END_SRC
-** counsel-dash
-
-Emacs’ documentation is great to read from inside Emacs.  Counsel-dash
-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)))))
-
-(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"))))
-#+END_SRC
-
-** discover-my-major
-
-A nicer way to browse keybindings for major modes.
-
-#+BEGIN_SRC emacs-lisp
-(use-package discover-my-major
-  :bind ("<f1>" . discover-my-major))
-#+END_SRC
-
-** which-key
-
-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)))
-#+END_SRC
-
-** eldoc
-
-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)))
-#+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.")
-(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 "
-  " nil t)
-      (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))))
-
-(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)))
-
-(defun process-exit-code (program &rest args)
-  "Run PROGRAM with ARGS and return the exit code"
-  (apply 'call-process program nil nil nil args))
-
-(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)))
-
-(bind-key* "M-!" #'shell-execute)
-(bind-key* "C-x r M-w" #'copy-rectangle)
-#+END_SRC
-
-** Auxillary Configuration
-
-#+BEGIN_SRC emacs-lisp
-(require 'pinentry)
-
-(defvar have-private-key
-  (file-exists-p (expand-file-name "secring.gpg" "~/.gnupg/")))
-
-(defvar gpg-agent-ssh-sock
-  (or (getenv "GPG_AGENT_INFO")
-      (concat "/run/user/" (number-to-string (user-uid)) "/gnupg/S.gpg-agent.ssh")))
-
-(defun read-gpg-file (file)
-  (let ((file-to-decrypt (expand-file-name file user-emacs-directory))
-	(ctx (epg-make-context epa-protocol)))
-    (if (file-exists-p file-to-decrypt)
-	(epg-decrypt-file ctx file-to-decrypt nil)
-      (message "Decrypting %s...failed" file-to-decrypt)
-      (error "File %s does not exist" file-to-decrypt))))
-
-(defun load-gpg (file)
-  (if have-private-key
-      (load file)
-    (message "WARNING: Couldn't load %s (No gpg key found)" file)))
-
-; load this in a post-frame hook because gpg-agent asks for a password on first
-; startup and caches it. Don't want emacs daemon to hang because of gpg-agent.
-(defun load-private-data ()
-  (interactive)
-  (if (not have-private-key)
-      (message "ERROR: Private GPG key not found")
-    (unless (or (getenv "GPG_AGENT_INFO")
-                (getenv "SSH_AUTH_SOCK"))
-      (start-process "gpg-agent" nil "gpg-agent" "--daemon")
-      (setenv "SSH_AUTH_SOCK" gpg-agent-ssh-sock))
-    (setq password-cache-expiry nil)
-    (unless (file-exists-p (concat pinentry--socket-dir "pinentry"))
-      (pinentry-start)
-      (add-hook 'kill-emacs-hook 'pinentry-stop))
-    (add-to-list 'load-suffixes ".el.gpg")
-    (load-gpg (expand-file-name "private" user-emacs-directory))))
-
-(defun first-frame-hook (frame)
-  (remove-hook 'after-make-frame-functions #'first-frame-hook)
-  (run-at-time nil nil 'load-private-data))
-
-(if (eq 1 (length (frame-list)))
-    (add-hook 'after-init-hook #'load-private-data)
-  (add-hook 'after-make-frame-functions #'first-frame-hook))
-#+END_SRC
-
-* Minibuffer
-
-Sometimes I want to use the minibuffer, but I’m already inside it.
-Fortunately, this is possible.  Of course, I need to know how many
-minibuffers there are on the stack.
-
-#+BEGIN_SRC emacs-lisp
-(setq enable-recursive-minibuffers t)
-(minibuffer-depth-indicate-mode t)
-#+END_SRC
-
-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))
-#+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))
-#+END_SRC
-
-** swiper/ivy
-
-Ivy is the new kid on the completion block.  It seems to be a strong
-replacement for helm so far.
-
-#+BEGIN_SRC emacs-lisp
-(use-package swiper
-  :bind (("C-s" . swiper)
-         ("C-r" . swiper)
-         ("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 . ""))))
-#+END_SRC
-
-** counsel
-
-#+BEGIN_SRC emacs-lisp
-(use-package counsel
-  :config (progn
-            (bind-key "M-x" #'counsel-M-x)
-            (bind-key "<apps>" #'counsel-M-x)
-            (bind-key "<menu>" #'counsel-M-x)
-            (bind-key "C-c M-x" #'execute-extended-command)
-            (bind-key "C-x C-f" #'counsel-find-file)
-            (bind-key "M-y" #'counsel-yank-pop)
-            (bind-key "M-y" #'ivy-next-line ivy-minibuffer-map)
-            (defadvice counsel-find-file (after find-file-sudo activate)
-              "Find file as root if necessary."
-              (when (and buffer-file-name
-                         (not (file-writable-p buffer-file-name)))
-                (message "File not writable %s" buffer-file-name)
-                (find-alternate-file (concat "/sudo::" buffer-file-name))))))
-#+END_SRC
-
-
-** smex
-
-Smex is my favourite way to use =M-x=.  Counsel’s =counsel-M-x=
-function uses it internally, so I’m keeping it around, even though I
-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"))))
-#+END_SRC
-
-** cmd-to-echo
-
-I’ve been looking for some way to run programming projects (mostly
-node.js) inside emacs.  =cmd-to-echo= seems great for this, as new
-output pops up in the echo area.
-
-#+BEGIN_SRC emacs-lisp
-(use-package cmd-to-echo
-  :commands (cmd-to-echo)
-  :config (setq cmd-to-echo-add-output-to-process-buffers t))
-#+END_SRC
-* Modes
-
-Setup some modes for systemd files
-#+BEGIN_SRC emacs-lisp
-(add-to-list 'auto-mode-alist '("\\.service\\'" . conf-mode))
-(add-to-list 'auto-mode-alist '("\\.target\\'" . conf-mode))
-(add-to-list 'auto-mode-alist '("\\.socket\\'" . conf-mode))
-#+END_SRC
-
-=direnv=’s files are basically shell scripts, it’s a nice way to
-set environment variables for projects.
-#+BEGIN_SRC emacs-lisp
-(add-to-list 'auto-mode-alist '("\\.envrc\\'" . sh-mode))
-#+END_SRC
-
-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)))
-
-(use-package haskell-mode
-  :mode (("\\.hs\\'" . haskell-mode)))
-
-(use-package dockerfile-mode
-  :mode (("Dockerfile\\'" . dockerfile-mode)))
-
-(use-package 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)))
-
-(use-package lua-mode
-  :defer t)
-
-(use-package ruby-mode
-  :mode (("\\.rb\\'" . ruby-mode)
-         ("\\.cap\\'" . ruby-mode)))
-
-(use-package go-mode
-  :mode (("\\.go\\'" . go-mode)))
-
-(use-package jinja2-mode
-  :mode (("\\.j2\\'" . jinja2-mode)
-         ("\\.jinja\\'" . jinja2-mode)))
-
-(use-package scss-mode
-  :defer t
-  :config (progn
-            (setq scss-compile-at-save nil)))
-
-(use-package 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))
-
-(define-derived-mode saltstack-mode yaml-mode "Salt")
-(add-to-list 'auto-mode-alist '("\\.sls\\'" . saltstack-mode))
-#+END_SRC
-
-** ledger
-
-I use [[http://ledger-cli.org/][=ledger=]] to manage my finances.  It has an Emacs mode, which
-works really nicely.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ledger-mode
-  :mode ("\\.ledger\\'" . ledger-mode)
-  :init (progn
-          (defun open-budget ()
-            (interactive)
-            (projectile-switch-project-by-name "~/Sync/Default")
-            (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)")))))
-#+END_SRC
-
-** Markdown
-
-#+BEGIN_SRC emacs-lisp
-(use-package markdown-mode
-  :defer t
-  :config (progn
-            (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
-#+END_SRC
-
-** Org
-
-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"))
-
-                  org-default-notes-file (concat org-directory "/notes")
-
-                  ;; ‘Remember’: new items at top
-                  org-reverse-note-order t
-
-                  org-modules '(org-protocol)
-
-                  ;; Add time done to ‘done’ tasks
-                  org-log-done 'time
-
-                  org-list-allow-alphabetical t
-
-                  org-adapt-indentation nil
-
-                  org-pretty-entities t
-
-                  org-table-duration-custom-format 'seconds
-
-                  org-src-fontify-natively nil
-
-                  org-export-have-math 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)))
-#+END_SRC
-
-**** org-babel
-
-Org’s babel feature is really nice.  I use it for this file, and I can
-use it to communicate between programming languages.  Sometime I hope
-to have my =ledger= setup in an org file with some graph processing
-with R or something.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ob-core
-  :defer t
-  :ensure nil
-  :config (progn
-            (org-babel-do-load-languages 'org-babel-load-languages
-                                         '((ledger . t)
-                                           (sh . t)))
-            (setq org-src-tab-acts-natively t
-                  org-edit-src-content-indentation 0
-                  org-src-preserve-indentation t)))
-#+END_SRC
-
-**** org-journal
-
-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)))))
-#+END_SRC
-
-**** org-mobile
-
-#+BEGIN_SRC emacs-lisp
-(defun ap/org-mobile-pull (descriptor action file)
-  (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.")
-
-            (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))))))
-
-            (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))))))
-#+END_SRC
-
-**** org-caldav
-
-I’ve setup CalDAV on my server, it would be nice to use it directly
-from org-mode.  Previously I had to wait for org-mobile to sync and
-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)))
-#+END_SRC
-
-**** org-page
-
-I would like to convert my website from using hugo to something else
-that I can work with nicely from inside Emacs.  I wonder if org-page
-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")))
-#+END_SRC
-
-* Music
-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))))
-#+END_SRC
-* Programming
-** flycheck
-
-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))
-            (if (executable-find "eslint_d")
-                (setq flycheck-javascript-eslint-executable (executable-find "eslint_d")))))
-#+END_SRC
-
-** golang
-
-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)))
-
-(use-package go-eldoc
-  :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)))
-
-
-#+END_SRC
-
-** ggtags
-
-A nice completion backend for programming modes.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ggtags
-  :disabled t
-  :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
-
-*** All
-
-Lisp modes don’t seem to have a common ancestor.  So I made a custom
-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)
-
-(defun ap/lisp-setup ()
-  (run-hooks 'lisp-mode-common-hook))
-#+END_SRC
-
-**** Redshank
-
-Lisp syntax allows for really easy refactoring.  Redshank gives some
-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)))
-#+END_SRC
-
-*** Emacs Lisp
-
-Customise the modeline-display of =emacs-lisp-mode=.  Then make sure
-it runs the common lisp hooks.
-
-#+BEGIN_SRC emacs-lisp
-(add-hook 'emacs-lisp-mode-hook #'ap/lisp-setup)
-(add-hook 'emacs-lisp-mode-hook #'eldoc-mode)
-#+END_SRC
-
-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)))
-#+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)))))
-#+END_SRC
-
-*** Scheme & Lisp
-
-I don’t work with these as often as I would like
-
-#+BEGIN_SRC emacs-lisp
-(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))
-(add-hook 'lisp-mode-hook #'set-common-lisp-indentation)
-#+END_SRC
-
-**** geiser
-
-A REPL thing for Scheme.  Hopefully I’ll get to use it more in the
-future.
-
-#+BEGIN_SRC emacs-lisp
-(use-package geiser
-  :commands (geiser-mode
-             geiser
-             run-geiser
-             run-racket))
-#+END_SRC
-
-**** slime
-
-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"))))
-#+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)))
-
-(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)))
-#+END_SRC
-
-**** cider
-
-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)))
-#+END_SRC
-
-** Auto-compile
-
-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))
-#+END_SRC
-
-** cc-mode
-
-Although I don’t use C or C++, setting up the mode is helpful because
-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 '+)))
-#+END_SRC
-
-** quickrun
-
-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)))
-#+END_SRC
-
-** Scala
-
-Let’s try using Scala.
-
-#+BEGIN_SRC emacs-lisp
-(use-package scala-mode
-  :pin melpa-stable)
-#+END_SRC
-
-And add ensime, an IDE-style environment.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ensime
-  :pin melpa-stable)
-#+END_SRC
-
-** Web development
-
-*** js2-mode
-
-This mode is really great for editing Javascript.  It turns code into
-an AST internally, so it can work with it almost like a lisp.  I don’t
-think there’s anything as good as paredit/redshank for refactoring in
-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/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)
-            (setq js2-basic-offset 2
-                  js2-include-node-externs t)))
-#+END_SRC
-
-**** jade (not pug)
-
-Javascript with an inferior node.js process and a debugger?  Awesome.
-
-To debug with node, use version 6.9.1 or later of node and run it with
-~--inspect~ and, to break on the first line, ~--debug-brk~.
-
-For Chrom*, it needs to be launched with ~--remote-debugging-port=9222~
-
-#+BEGIN_SRC emacs-lisp
-(use-package jade
-  :config (progn
-            (add-hook 'js2-mode-hook #'jade-interaction-mode)))
-#+END_SRC
-
-*** coffee-mode
-
-#+BEGIN_SRC emacs-lisp
-(use-package coffee-mode
-  :mode ("\\.coffee\\'" . coffee-mode)
-  :config (progn
-            (setq coffee-indent-like-python-mode t)))
-#+END_SRC
-
-*** tern
-
-Tern understands javascript.  It adds really clever documented
-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)))
-
-(with-eval-after-load '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)))
-#+END_SRC
-
-*** restclient
-
-Restclient is really nice.  It’s like a scratchpad for HTTP api
-calls.  Feels a bit like using =org-babel=.  I wonder if there’s an
-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)))
-
-(use-package company-restclient
-  :after (company restclient)
-  :init (add-to-list 'company-backends #'company-restclient t))
-#+END_SRC
-
-*** sgml-mode
-
-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))
-#+END_SRC
-
-*** emmet-mode
-
-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
-          (setq emmet-indentation 2)
-          (add-hook 'web-mode-hook #'emmet-mode)))
-#+END_SRC
-
-*** web-mode
-
-This mode handles just about every templating language out ther, which
-is really nice, because it handles the HTML part the same way in all
-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) "<%" "%>")))
-#+END_SRC
-
-I derived a mode for twig, in order to use its =mode-hook=.
-
-#+BEGIN_SRC emacs-lisp
-(define-derived-mode twig-mode web-mode "Twig")
-(add-to-list 'auto-mode-alist '("\\.html\\.twig\\'" . twig-mode))
-#+END_SRC
-
-* Spelling
-
-#+BEGIN_SRC emacs-lisp
-(use-package ispell
-  :bind (("<f8>" . ispell-word))
-  :config (progn
-            (cond
-             ((executable-find "aspell") (setq ispell-program-name "aspell"
-                                               ispell-dictionary "british"
-                                               ispell-really-aspell t
-                                               ispell-really-hunspell nil))
-             ((executable-find "hunspell") (setq ispell-program-name "hunspell"
-                                                 ispell-really-aspell nil
-                                                 ispell-really-hunspell t)))))
-#+END_SRC
-
-* Scripting
-
-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)
-
-(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))
-#+END_SRC
-
-#+BEGIN_SRC emacs-lisp
-(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
-#+END_SRC
-
-** eshell
-
-I should try to get into the habit of using this more.  It’s really
-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"
-                  eshell-prompt-function (lambda ()
-                                           (concat
-                                            (eshell/pwd)
-                                            "\n$ ")))
-            (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)))
-
-(autoload #'eshell/cd "em-dirs")
-(defun eshell-goto-current-dir (&optional arg)
-  (interactive "P")
-  (let ((dir default-directory))
-    (eshell arg)
-    (eshell/cd dir)))
-(bind-key "C-c S" #'eshell-goto-current-dir)
-
-
-#+END_SRC
-
-*** 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))
-
-(use-package comint
-  :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)))
-#+END_SRC
-
-* Text editing
-
-Emacs has an editor within.
-
-#+BEGIN_SRC emacs-lisp
-(put 'upcase-region 'disabled nil)
-(put 'downcase-region 'disabled nil)
-(setq sentence-end-double-space t
-      line-move-visual nil)
-#+END_SRC
-
-** align
-
-=Align= is a useful command to line things up, once given some rules.
-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))))))
-#+END_SRC
-
-** Clipboard
-
-I like to use the clipboard more than the primary selection in X11.
-
-#+BEGIN_SRC emacs-lisp
-(setq x-select-enable-clipboard t
-      save-interprogram-paste-before-kill t)
-(if (functionp 'x-cut-buffer-or-selection-value)
-    (setq interprogram-paste-function 'x-cut-buffer-or-selection-value))
-(when (boundp 'x-select-request-type)
-  (setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING)))
-#+END_SRC
-
-*** Copy formatted code
-
-#+BEGIN_SRC emacs-lisp
-(bind-key* "C-c w" (define-prefix-command 'copy-as-map))
-(use-package copy-as-format
-  :bind (("C-c C-w" . copy-as-format)
-         :map copy-as-map
-         ("b" . copy-as-format-bitbucket)
-         ("g" . copy-as-format-github)
-         ("h" . copy-as-format-hipchat)
-         ("w" . copy-as-format-html)
-         ("j" . copy-as-format-jira)
-         ("m" . copy-as-format-markdown)
-         ("s" . copy-as-format-slack)))
-#+END_SRC
-
-**
-
-** Selection
-
-I’m quite used to deleting text by selecting it and typing.  Emacs has
-a mode for that.
-
-#+BEGIN_SRC emacs-lisp
-(delete-selection-mode t)
-#+END_SRC
-
-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))
-#+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)))
-#+END_SRC
-
-Expanding the region by semantic units was something I quite liked
-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))
-#+END_SRC
-
-** avy
-
-Avy is a really nice way to move around files, like ace-jump-mode, but
-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 ?\;))))
-#+END_SRC
-
-*** ace-link
-
-Visit any link.  Despite the name, this works with avy.
-
-#+BEGIN_SRC emacs-lisp
-(use-package ace-link
-  :after avy
-  :config (progn
-            (ace-link-setup-default)
-            (with-eval-after-load "gnus"
-              (bind-key "M-o" #'ace-link-gnus gnus-summary-mode-map)
-              (bind-key "M-o" #'ace-link-gnus gnus-article-mode-map))))
-#+END_SRC
-
-** goto-chg
-
-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))
-#+END_SRC
-
-** multiple-cursors
-
-I mentioned before that I’d used Sublime Text before.  Multiple
-cursors was one of my favourite features, so I was really happy when I
-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)))
-#+END_SRC
-
-** paredit
-
-Balanced parentheses in lisps are nice, but all the refactoring and
-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)))
-#+END_SRC
-
-** smartparens
-
-I like to use smartparens where paredit isn’t already useful.  Somehow
-I didn’t find smartparens’ implementation of paredit style to be as
-nice as the real version
-
-#+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)))
-#+END_SRC
-
-** smart-scan
-
-Move between instances of a symbol
-
-#+BEGIN_SRC emacs-lisp
-(use-package smartscan
-  :config (progn
-            (smartscan-mode 1)))
-#+END_SRC
-
-** move-text
-
-Transposing lines, made easier.
-
-#+BEGIN_SRC emacs-lisp
-(use-package move-text
-  :config (move-text-default-bindings))
-#+END_SRC
-
-** undo-tree
-
-Emacs’ default handling of undo is a bit confusing.  Undo-tree makes
-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)
-#+END_SRC
-
-** replace
-
-#+BEGIN_SRC emacs-lisp
-(use-package replace
-  :defer t
-  :config (progn
-            (setq case-replace nil)))
-#+END_SRC
-
-** visual-regexp
-
-I don’t always remember exactly how Emacs’ regular expressions work,
-so this package is pretty useful because it highlights everything in
-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)))
-#+END_SRC
-* Tangling
-
-Taken from [[https://github.com/larstvei/dot-emacs/blob/master/init.org][larstvei/dot-emacs]].  I changed it so that it would work with
-my current dotfiles repository structure and work asynchronously,
-thanks to [[https://github.com/jwiegley/emacs-async][jwiegley/emacs-async]].
-
-We can use =C-c C-v t= to run =org-babel-tangle=, which extracts the
-code blocks from the current file into a source-specific file (in this
-case a =.el=-file).
-
-To avoid doing this each time a change is made we can add a function
-to the =after-save-hook= ensuring to always tangle and byte-compile
-the =org=-document after changes.
-
-#+BEGIN_SRC emacs-lisp
-(use-package async
-  :commands (async-start)
-  :defer 2)
-
-(defun tangle-if-init ()
-  "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)))
-
-(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)))))
-
-(defun tangle-init ()
-  "Tangle init.org asynchronously."
-
-  (interactive)
-  (message "Tangling init")
-  (async-start
-   (symbol-function #'tangle-init-sync)
-   (lambda (result)
-     (message "Init tangling completed: %s" result))))
-#+END_SRC
-
-# Local Variables:
-# eval: (when (fboundp #'tangle-if-init) (add-hook 'after-save-hook #'tangle-if-init))
-# End:
-* End
-
-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)))))
-(setq gc-cons-threshold 800000
-      file-name-handler-alist file-name-handler-alist-backup)
-#+END_SRC