path: root/tag-emacs/emacs.d/init.org

#+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)
  (setq file-name-handler-alist nil)
#+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 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))
  (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

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)))
#+END_SRC

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
    :config (progn
              (load-theme 'basic t)
              (defun mode-line-visual-toggle ()
                (interactive)
                (let ((faces-to-toggle '(mode-line mode-line-inactive))
                      (invisible-color "#e8e8e8")
                      (visible-color "#a1b56c"))
                  (cond ((string= visible-color (face-attribute 'mode-line :background))
                         (mapcar (lambda (face)
                                   (set-face-background face invisible-color)
                                   (set-face-attribute face nil :height 20))
                                 faces-to-toggle))
                        (t
                         (mapcar (lambda (face)
                                   (set-face-background face visible-color)
                                   (set-face-attribute face nil :height (face-attribute 'default :height)))
                                 faces-to-toggle)))))
              (mode-line-visual-toggle)))
#+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)))
#+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)
      (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))
       ((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 "SF Mono" 12 "Lucida Grande" 12)
            (ap/set-fonts "ProggyClean" 11 "Lucida Grande" 12))))
       ((eq window-system 'x)
        (set-fontset-font "fontset-default" 'unicode (font-spec :name "Terminus" :size 12))
        (ap/set-fonts "Terminus" 12 "Lucida" 10))))

    (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

** 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


* 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-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))
#+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
    :bind (("C-c p s r" . projectile-ripgrep))
    :ensure nil)
#+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 (("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 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-dired
                    projectile-remember-window-configs t
                    projectile-completion-system 'ivy)))
#+END_SRC

*** projectile-git-autofetch

Automatically fetch repositories I’m working on.

#+BEGIN_SRC emacs-lisp
  (use-package projectile-git-autofetch
    :config (progn
              (setq projectile-git-autofetch-projects 'open)
              (projectile-git-autofetch-mode 1)))
#+END_SRC

** perspective

This package makes buffer-switching inside of projects make sense, by
filtering the candidates to those within the project.  For it to work,
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)))

  (use-package persp-projectile
    :ensure t)
#+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)))
#+END_SRC

** diff-hl

It’s nice to be able to see at a glance which lines of a file have
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)))
#+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-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

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" "/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")))
#+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

** auto-indent-mode

Don’t make me think, just indent it!  Unless it’s a
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)))
#+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)))
              (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)))))
#+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.  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"))))))

              ;; 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
    :init (progn
            (winner-mode 1)
            (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))))
#+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-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)
#+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)
              (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-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"
                    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))

  (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)))
#+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 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

#+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-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 . ""))))
#+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 "C-x b" #'counsel-switch-to-persp-buffer)
              (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))))
              (defun counsel-switch-to-persp-buffer (arg)
                "Forward to `persp-switch-to-buffer'."
                (interactive "P")
                (ivy-read (format "Switch to buffer [%s]: " (persp-name persp-curr))
                          (remq nil (mapcar #'buffer-name (persp-buffers persp-curr)))
                          :preselect (buffer-name (other-buffer (current-buffer)))
                          :action #'ivy--switch-buffer-action
                          :keymap ivy-switch-buffer-map))))
#+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-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)")))))
#+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 (org-babel-do-load-languages
             'org-babel-load-languages
             '((ledger . t)
               (sh . 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))))
#+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
    :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/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)

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)))
#+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
            (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")
              (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

** 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

** Typography

I like using typographic quotes, but they’re complicated to insert manually.
them.

#+BEGIN_SRC emacs-lisp
  (electric-quote-mode)
#+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

** 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

** 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 '(("\\(?:\\.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