As my editor of choice I run Emacs. One of the benefits of Emacs is that it’ll install basically anywhere.

This configuration is designed to run in shells as well as on desktops. There are some platform specific optimisations as well.

It’s built using Org mode’s tangling functionality.

My entire Emacs configuration is thus written in a literate programming style, and is contained entirely in this file.

The previous version can be found at bradleywright/emacs-d. This version has been refactored to use traditional Emacs loading techniques and macros for installing packages.

Just check it out straight to the right directory, and use Make to install it:

cd ~/Projects/emacs.d && make

• Left option key is remapped to M-
• M-3 prints a literal # (UK Mac keyboards being weird)
• We use the Solarized Dark theme
• Font is Inconsolata

• When the Solarized Dark iTerm2 theme is installed, we use the solarized-dark color theme
• Cut/paste are made to write/read from the clipboard (via pbcopy and pbpaste)
• Mouse highlighting works via xTerm capabilities

• Re-map left option key to Esc
• Untick Smart cursor color

The following libraries are included in non-attributable ways, i.e not via package install or via a Git submodule:

• Emacs Starter Kit was a very big early influence, and continues to be helpful.

Copyright 2010-2014 Bradley Wright.

Files are licensed under the same license as Emacs (GPL) unless otherwise specified. See the COPYING file for more information.

Any external/third party works included in this work are licensed under their own licenses - refer to the submodules or packages for more information.

Functions and variables defined exclusively for my use are prefixed with my initials and a slash bw/ to namespace them.

Emacs looks in load-path for Emacs lisp files. require and other loading constructs use this when looking for implicit names.

First we define a convenience function bw/add-to-load-path that adds the passed in directory to load-path:

(defun bw/add-to-load-path (dir)
  "Adds `dir' to load-path"
  (add-to-list 'load-path dir))

and a convenience function for making a proper path out of two strings:

(defun bw/join-dirs (prefix suffix)
  "Joins `prefix' and `suffix' into a directory"
  (file-name-as-directory (concat prefix suffix)))

Define a base directory bw/dotfiles-dir that’s relative to the currently loading file (this file). This means if I deliberately start Emacs with a file loaded:

$ emacs -q -l ~/src/emacs/init.el

then bw/dotfiles-dir will be ~/src/emacs.

(defconst bw/dotfiles-dir
  (file-name-directory
   (or (buffer-file-name) load-file-name))
  "Base path for customised Emacs configuration")

This variable is important because all other directories I load things from are relative to it, which means my Emacs config doesn’t need to live in user-emacs-directory.

Emacs has many packages which need to store state in files. Generally these are in ~ or user-emacs-directory - since my entire ~/.emacs.d is versioned, I’d rather all temporary files were stored in a known place, bw/tmp-local-dir. This directory is created if it doesn’t exist.

(make-directory
 (setq bw/tmp-local-dir
       (bw/join-dirs bw/dotfiles-dir ".tmp")) t)

Emacs automatically backs up files while you’re editing them. The default configuration isn’t great though.

First, set up some directories to keep backups:

(make-directory
 (setq bw/tmp-backups-dir
       (bw/join-dirs bw/tmp-local-dir "backups")) t)
(make-directory
 (setq bw/tmp-autosaves-dir
       (bw/join-dirs bw/tmp-local-dir "autosaves")) t)

Now use those directories for backups and autosave files:

(setq backup-directory-alist `((".*" . ,bw/tmp-backups-dir))
      auto-save-file-name-transforms `((".*" ,bw/tmp-autosaves-dir)))

Always copy files when backing up to avoid breaking symlinks:

(setq backup-by-copying t)

Delete old versions automatically, and keep a limited number around:

(setq delete-old-versions t
      kept-new-versions 2
      kept-old-versions 2)

Finally, use version numbers in the filenames:

(setq version-control t)

Emacs has a client/server model for editing. The client is invoked via the emacsclient command. More information on configuration is available on the EmacsWiki EmacsClient page.

We make sure the server is running, additionally guarded to check if the version of Emacs we’re using supports the server package:

(when (require 'server nil t)
  (unless (server-running-p)
    (server-start)))

Emacs comes with a collection of strange defaults. See Magnar Sveen’s sane-defaults.el file for some commentary.

The default wrap width (known as filling) for Emacs is 70 characters. Modern conventions state that 80 characters is the standard:

(setq-default fill-column 80)

I don’t type double-space sentences, so make sure that Emacs doesn’t look for double-spaces after periods to fill paragraphs correctly:

(setq-default sentence-end-double-space nil)

Most UNIX tools work best when there’s a trailing newline on all files. Enable that option:

(setq require-final-newline t)

I don’t want to leave trailing whitespace in files I touch, so set up a hook that automatically deletes trailing whitespace after every line when saving a file:

(add-hook 'write-file-hooks 'delete-trailing-whitespace)

Emacs has lots of other options for managing superfluous whitespace.

I don’t use tabstops in files, and my default tab width is 4 characters.

It’s worth noting that Emacs can override either of those on a per-file/mode basis, so Makefiles, Ruby etc. will still get the correct indentation rules.

(setq-default
 indent-tabs-mode nil
 tab-width 4)

Electric indent mode was added in Emacs 24.1, and it enables automatic indentation when typing a newline. More about electric indent mode on Emacs Redux.

First we define convenience toggling functions we can use in a hook (or interactively):

(defun bw/turn-on-electric-indent-mode ()
  "Turns on electric-indent-mode"
  (interactive)
  (electric-indent-mode 1))

(defun bw/turn-off-electric-indent-mode ()
  "Turns off electric-indent-mode"
  (interactive)
  (electric-indent-mode -1))

then we enable it for the generic abstract programming mode prog-mode, introduced in Emacs 24.1 (more about prog-mode on Emacs Redux):

(add-hook 'prog-mode-hook 'bw/turn-on-electric-indent-mode)

I want to have UTF-8 by default. Emacs unfortunately has a few settings that govern encoding, so we should set them all at once:

(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

C-a is mapped to beginning-of-line by default, which moves point to position 0 on the current line. The irreal blog suggests a smarter alternative that moves the point to the first non-whitespace character first, and then position 0, with extra presses toggling the position:

(defadvice move-beginning-of-line (around smarter-bol activate)
  ;; Move to requested line if needed.
  (let ((arg (or (ad-get-arg 0) 1)))
    (when (/= arg 1)
      (forward-line (1- arg))))
  ;; Move to indentation on first call, then to actual BOL on second.
  (let ((pos (point)))
    (back-to-indentation)
    (when (= pos (point))
      ad-do-it)))

This functionality uses the Emacs concept of advice, which is a way of modifying existing functions in-place without redefining the entire thing.

When changing focus to the minibuffer, stop allowing point to move over the prompt. Code taken from ergoemacs.

(setq minibuffer-prompt-properties (add-to-list 'minibuffer-prompt-properties 'minibuffer-avoid-prompt))
(setq minibuffer-prompt-properties (add-to-list 'minibuffer-prompt-properties 'point-entered))

• C- means Control in combination with another key, eg C-x means Ctrl x
• M- means Meta in combination with another key. This is usually Alt, or ⌘ on OS X (by default). Esc also serves as Meta if it’s not separately bound. On OS X I want to use left ⌥ for Meta, and leave right ⌥ alone:

(when (and (eq system-type 'darwin) (display-graphic-p))
  (setq ns-alternate-modifier 'meta)
  (setq ns-right-alternate-modifier nil))

• s- means super key. On OS X I want this to be ⌘:

(when (and (eq system-type 'darwin) (display-graphic-p))
  (setq ns-command-modifier 'super))

• H- means hyper key. On OS X I want this to be fn:

(when (and (eq system-type 'darwin) (display-graphic-p))
  (setq ns-function-modifier 'hyper))

The below are some remappings I got from Steve Yegge’s Effective Emacs article. They’re designed to map some slightly difficult but very common mappings to things that are easier to type.

As per Yegge’s Item 2. This unmaps the difficult M-x (usually Alt x) to C-x m, and then add a fat-finger combination of C-x C-m:

(global-unset-key (kbd "C-x m"))
(global-unset-key (kbd "M-x"))
(global-set-key (kbd "C-x m") 'execute-extended-command)
(global-set-key (kbd "C-x C-m") 'execute-extended-command)

As per Yegge’s Item 3. This copies readline’s C-w command to backward-kill-word, remaps the command that used to live there (kill-region), and then enables a fat-finger version of the new kill=region mapping:

(global-set-key (kbd "C-w") 'backward-kill-word)
(global-set-key (kbd "C-x C-k") 'kill-region)
(global-set-key (kbd "C-c C-k") 'kill-region)

Usually one must type C-x o to switch between windows - make that quicker by also mapping M-o:

(global-set-key (kbd "M-o") 'other-window)

Burying a buffer (removing it from the current window and sending it to the bottom of the stack) is very common for dismissing buffers. Add a mapping for it:

(global-set-key (kbd "C-c y") 'bury-buffer)

Add a key combination to revert the current buffer (re-read the contents from disk):

(global-set-key (kbd "C-c r") 'revert-buffer)

Use ibuffer instead of the feature-lacking list-buffers:

(global-set-key (kbd "C-x C-b") 'ibuffer)

On OS X, make sure M-3 is remapped to hash:

(when (eq system-type 'darwin)
  (fset 'insert-pound "#")
  (define-key global-map "\M-3" #'insert-pound))

This trick I got from a blog post on launcher keymaps. I define my launcher combo as C-x C-l, which is normally downcase-region - a command I use so infrequently I didn’t even know there was a key binding for it.

(define-prefix-command 'bw/launcher-map)
(define-key ctl-x-map (kbd "C-l") 'bw/launcher-map)

rather than remembering that it’s bw/launcher-map, just make a function:

(defun bw/add-launcher (key function)
  "Maps FUNCTION to KEY under the `bw/launcher-map' prefix"
  (define-key bw/launcher-map key function))

To ensure that all scrollbars, toolbars etc. are turned off, we run this as early as possible.

(dolist (mode '(menu-bar-mode tool-bar-mode scroll-bar-mode))
  (when (fboundp mode) (funcall mode -1)))

Turn off the startup screen, and always show *scratch*.

;; inhibit startup screen
(setq inhibit-startup-screen t
      ;; Show *scratch* on start
      initial-buffer-choice t)

I use Inconsolata as my default coding font. It’s set to render at 18pt:

(when (and
       (display-graphic-p)
       (find-font (font-spec :name "Inconsolata")))
  (set-frame-font "Inconsolata-18" t t))

Syntax highlighting in Emacs is called font locking. It’s enabled by font-lock-mode. This turned on by default in modern Emacs systems, but it’s worth keeping around:

(global-font-lock-mode t)

Emacs also supports multiple levels of complexity for highlighting. Setting this value to t forces it to pick the maximum available (also the default):

(setq font-lock-maximum-decoration t)

Emacs doesn’t display line numbers by the code by default. For that you want Linum mode.

I want to display the current line number in the mode line, and also the current column number:

(line-number-mode 1)
(column-number-mode 1)

Emacs convention is to show help and other inline documentation in the message area. Show help there instead of using an OS tooltip:

(when (display-graphic-p)
  (tooltip-mode -1))

Just don’t show them. Use native Emacs controls:

(when (display-graphic-p)
  (setq use-dialog-box nil))

Make the window title display the full path of the file I’m currently editing:

(when (display-graphic-p)
  (setq frame-title-format
        '((:eval (if (buffer-file-name)
                     (abbreviate-file-name (buffer-file-name))
                   "%b")))))

Aside: Emacs calls OS windows frames and divisions within frames windows. More information on frame titles.

On modern operating systems, a vertical bar is used as a cursor:

(when (display-graphic-p)
  (setq-default cursor-type 'bar))

Make the cursor blink (interestingly in Emacs 24.4 the cursor automatically stops blinking after a period to conserve CPU).

Make the cursor blink every second:

(when (display-graphic-p)
  (setq blink-cursor-interval 1.0)
  (blink-cursor-mode 1))

Show the modifier combinations I just typed almost immediately:

(setq echo-keystrokes 0.1)

Don’t make me type yes or no to boolean interface questions:

(defalias 'yes-or-no-p 'y-or-n-p)

Don’t make a sound when ringing a bell - flash a visual bell instead:

(setq visible-bell t)

Override the ring-bell-function to conditionally ring the bell only when it’s not a valid quit case like hitting esc or C-g. Generally this means the bell will only ring when there’s actually an error raised somehow:

(setq ring-bell-function
      (lambda ()
        "Only rings the bell if it's not a valid quit case, e.g
keyboard-quit"
        (unless (memq this-command
                      '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit))
          (ding))))

By default Emacs resolves conflicting buffer names by appending a number to them. For instance, if I open ~/src/thing/init.el and ~/src/other-thing/init.el they’ll be named init.el and init.el<2> respectively.

We can use Uniquify library to name them thing/init.el and other-thing/init.el, which is much easier to make sense of.

(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)

On a GUI Emacs, I want to use solarized-theme. On a terminal I want to use zenburn-theme:

(add-hook 'after-init-hook (lambda ()
                             (when (window-system)
                                 (load-theme 'solarized-dark t))))

Besides the keyboard configuration above, there are some other specific things I do on OS X. On OS X system-type is the symbol darwin.

Typically OS X hosts are called things like hostname.localconfig or hostname.local. Make Emacs report that without the extra suffix:

(when (eq system-type 'darwin)
  (setq system-name (car (split-string system-name "\\."))))

ispell isn’t generally available on OS X. aspell is available via Homebrew, so let’s use that if we can find it:

(when (and (eq system-type 'darwin) (executable-find "aspell"))
    (setq ispell-program-name (executable-find "aspell")))

OS X’s bundled version of ls isn’t the GNU one, so it doesn’t support the --dired flag. Emacs caters for that use case:

(setq dired-use-ls-dired nil)

As of Emacs 24.4, Emacs natively supports proper sRGB values on OS X:

(setq ns-use-srgb-colorspace t)

If you’re not using Emacs 24.4 this variable setting will have no effect. See Homebrew’s Emacs recipe for details of how to get this behaviour in earlier Emacs versions.

Using this configuration, Emacs runs best in iTerm2.

On the desktop, Emacs integrates with the OS X clipboard, so kill etc. copy to the clipboard, and yank copies from the clipboard.

Obviously this doesn’t work in the terminal, so we need to use the interprogram-(cut|paste)-function variables to copy/paste. Most of this code gotten from this blog comment.

(when (and (not (display-graphic-p)) (eq system-type 'darwin))
  (defun bw/copy-from-osx ()
    "Copies the current clipboard content using the `pbcopy` command"
    (shell-command-to-string "pbpaste"))

  (defun bw/paste-to-osx (text &optional push)
    "Copies the top of the kill ring stack to the OSX clipboard"
    (let ((process-connection-type nil))
      (let ((proc (start-process "pbcopy" "*Messages*" "pbcopy")))
        (process-send-string proc text)
        (process-send-eof proc))))

  (setq interprogram-cut-function 'bw/paste-to-osx)
  (setq interprogram-paste-function 'bw/copy-from-osx))

On Emacs 24.4 and above, Lion-style fullscreen display is supported. Bind it to ⌘-<return>.

(when (and (eq system-type 'darwin) (fboundp 'toggle-frame-fullscreen))
  (global-set-key (kbd "s-<return>") 'toggle-frame-fullscreen))

On the Yosemite beta, ns-use-native-fullscreen is nil.

(when (eq system-type 'darwin)
  (setq ns-use-native-fullscreen t))

Renames the major-mode lighter in the modeline. Lifted from What the emacs.d.

(defmacro rename-modeline (package-name mode new-name)
  `(eval-after-load ,package-name
     '(defadvice ,mode (after rename-modeline activate)
        (setq mode-name ,new-name))))

If I’m on OS X, I can fetch passwords etc. from my Keychain. This is much more secure than storing them in configuration on disk:

(defun bw/chomp (str)
  "Chomp leading and tailing whitespace from `str'."
  (while (string-match "\\`\n \\|^\\s- \\|\\s- $\\|\n \\'" str)
    (setq str (replace-match "" t t str))) str)

(defun bw/get-keychain-password (account-name)
  "Get `account-name' keychain password from OS X Keychain"
  (interactive "sAccount name: ")
  (when (executable-find "security")
    (bw/chomp
     (shell-command-to-string
      (concat
       "security find-generic-password -wa "
       account-name)))))

When I’m in an emacsclient, I probably just want the client to die rather than the entire server. And, when I kill my server, I want Emacs to confirm this with me:

(defun bw/kill-emacs ()
  "If this buffer is a client, just kill it, otherwise confirm
the quit."
  (interactive)
  (if server-buffer-clients
      (server-edit)
    (if (= (length (frame-list)) 1)
        (cond ((y-or-n-p "Quit Emacs? ")
               (save-buffers-kill-terminal)))
      (save-buffers-kill-terminal))))

Enable this, and override the default command Emacs assigns to kill itself:

(define-key (current-global-map) [remap save-buffers-kill-terminal] 'bw/kill-emacs)

Emacs comes with hundreds of major and minor modes to do many many things. These are the ones I commonly use and have configured.

First let’s define a convenient macro that wraps typical eval-after-load in such a way that we don’t need to use progn to contain the callback logic. This macro was gotten from Steve Purcell’s emacs.d repo:

(defmacro after-load (feature &rest body)
  "After FEATURE is loaded, evaluate BODY."
  (declare (indent defun))
  `(eval-after-load ,feature
     '(progn ,@body)))

org-mode is a plain text system for organising information and notes.

Don’t auto-fold my documents:

(setq org-startup-folded nil)

When editing nested source code, always accept Emacs Lisp:

(org-babel-do-load-languages
 'org-babel-load-languages
 '((emacs-lisp . t)))

and automatically apply syntax highlighting:

(setq org-src-fontify-natively t)
(setq org-src-tab-acts-natively t)

When using imenu, make sure I can follow the outline to the full available depth:

(setq org-imenu-depth 6)

ido is a mode for narrowing candidates as you type. It has excellent integration with buffer switching and finding files. Mastering Emacs has a good guide to Ido.

First we enable ido-mode globally and enable ido-everywhere, which enables Ido for buffer and file reading:

(after-load 'ido
  (ido-mode t)
  (ido-everywhere t))

Force Ido to ignore Dropbox cruft:

(after-load 'ido
  (add-to-list 'ido-ignore-files "Icon\n"))

Configure Ido (see comments for more information):

(after-load 'ido
  (setq
   ;; Speed up ido by using less candidates
   ido-max-prospects 10
   ;; Match arbitrary points in strings
   ido-enable-prefix nil
   ;; Match across entire string
   ido-enable-flex-matching t
   ;; Create a new buffer if there's no match candidate
   ido-create-new-buffer 'always
   ;; Don't try and guess if the string under point is a file
   ido-use-filename-at-point nil
   ;; case-insensitive matching
   ido-case-fold t
   ;; don't store old files as virtual buffers
   ido-use-virtual-buffers nil))

Store ido temporary directory cache elsewhere:

(setq ido-save-directory-list-file (expand-file-name ".ido.last" bw/tmp-local-dir))

Finally load Ido:

(require 'ido)

Emacs has robust bookmarking functionality. It uses a file to persit the list of bookmarks, so make sure that file is in my custom temporary directory:

(after-load 'bookmark
  (setq bookmark-default-file (expand-file-name ".emacs.bmk" bw/tmp-local-dir)))

eldoc-mode is a minor mode that displays context-sensitive help when editing Emacs lisp (eg information about arity of functions). Enable that for emacs-lisp-mode:

(add-hook 'emacs-lisp-mode-hook 'turn-on-eldoc-mode)
(add-hook 'lisp-interaction-mode-hook 'turn-on-eldoc-mode)

As of 24.2, Emacs ships with a robust Python mode. However, when navigating SnakeCase words (eg class names), forward-word etc don’t work correctly.

We can work around that using subword-mode:

(add-hook 'python-mode-hook (lambda () (subword-mode 1)))

As of 24.4, Emacs comes with a much better Ruby mode. However it doesn’t come with subword-mode enabled by default:

(after-load 'ruby-mode
  (add-hook 'ruby-mode-hook (lambda () (subword-mode 1))))

Add Puppetfile files to ruby-mode:

(add-to-list 'auto-mode-alist '("[pP]uppetfile\\'" . ruby-mode))

Hippie expand is a more feature complete completion engine than the default dabbrev engine. The main feature I use over dabbrev is that it supports a wide range of backends for finding completions - dabbrev only looks at currently open buffers.

First we customise the types of things it looks for:

(setq hippie-expand-try-functions-list
      '(try-expand-dabbrev
        try-expand-dabbrev-all-buffers
        try-expand-dabbrev-from-kill
        try-complete-file-name-partially
        try-complete-file-name
        try-expand-all-abbrevs
        try-expand-list
        try-expand-line
        try-complete-lisp-symbol-partially
        try-complete-lisp-symbol))

Then we override dabbrev-expand’s keybinding to use hippie-expand instead (normally this is M-/):

(define-key (current-global-map) [remap dabbrev-expand] 'hippie-expand)

tramp-mode is a package that provides remote file editing, eg find-file /user@host:file. This allows one to edit files on other servers using your local Emacs (rather than the Vim user’s equivalent of editing the file on the server).

All of the below are wrapped in an after-load construct because tramp-mode isn’t loaded by default on older versions of Emacs.

First we set the default mode to be ssh (it’s normally scp). There are two reasons for this choice:

• ssh takes a port number as an argument, whereas scp doesn’t
• It’s apparently faster for smaller files

(after-load 'tramp
  (setq tramp-default-method "ssh"))

We also want to alter the list of allowed proxies (tramp uses a whitelist for patterns that it can remotely access) so I can edit remote files as sudo, eg find-file /sudo:example.com/etc/something-owned-by-root.

I got this code from the Multi-hops section of the tramp manual.

(after-load 'tramp
  (add-to-list 'tramp-default-proxies-alist
               '(nil "\\`root\\'" "/ssh:%h:")))

Also make sure we can edit local files as sudo - this is normally disallowed for security reasons:

(after-load 'tramp
  (add-to-list 'tramp-default-proxies-alist
               '((regexp-quote (system-name)) nil nil)))

More on the last two incantations at emacs-fu’s guide to editing files owned by root.

eshell is a shell-like command interpreter built with Emacs lisp. It integrates well with Emacs, and can be a convenient way to get a shell without invoking bash or similar (provided you don’t want any interactive commands).

There’s a great guide to mastering eshell on Mastering Emacs.

eshell has a directory where it stores bookmarks and other temporary cruft - move that out of the way:

(setq eshell-directory-name (bw/join-dirs bw/tmp-local-dir "eshell"))

When using the ssh command (or vagrant ssh, which is really the same thing), we’ll want to jump into something that’s an actual terminal emulator like ansi-term (eshell won’t be able to deal with the login on the remote machine):

(after-load 'esh-opt
  (require 'em-term)
  (add-to-list 'eshell-visual-commands "ssh")
  (when (fboundp 'eshell-visual-subcommands)
    (add-to-list 'eshell-visual-subcommands '("vagrant" "ssh"))))

Define a keybinding to get an eshell buffer anywhere:

(global-set-key (kbd "C-c C-t e") 'eshell)

ansi-term is a terminal emulator written in Emacs Lisp. It’s more like a traditional terminal emulator than eshell.

Force ansi-term to be UTF-8 after it launches:

(defadvice ansi-term (after bw/advise-ansi-term-coding-system activate)
  (set-buffer-process-coding-system 'utf-8-unix 'utf-8-unix))

When exiting a terminal buffer (either with exit or EOF), automatically kill the buffer:

(defadvice term-sentinel (around bw/advice-term-sentinel (proc msg) activate)
  (if (memq (process-status proc) '(signal exit))
      (let ((buffer (process-buffer proc)))
        ad-do-it
        (kill-buffer buffer))
    ad-do-it))

recentf stores a list of recently opened files.

Never clean up the list:

(after-load 'recentf
  (setq recentf-auto-cleanup 'never))

The list of files contains any files Emacs has read, not just files I’ve explicitly opened. Clean that list to exclude Emacs metafiles, package cruft etc.

TODO: refactor to use recentf-keep: http://www.emacswiki.org/emacs/RecentFiles#toc18

(after-load 'recentf
  (setq recentf-exclude '("[/\\]\\.elpa/" "[/\\]\\.ido\\.last\\'" "[/\\]\\.git/" ".*\\.gz\\'" ".*-autoloads\\.el\\'" "[/\\]archive-contents\\'" "[/\\]\\.loaddefs\\.el\\'" "url/cookies" ".*\\emacs.bmk\\'")))

Save the most recent 100 items (this is manily to keep the list low for ido):

(after-load 'recentf
  (setq recentf-max-saved-items 100))

Customise the place recentf persists its list of items:

(after-load 'recentf
  (setq recentf-save-file (expand-file-name ".recentf" bw/tmp-local-dir)))

Strip $HOME from the front of recentf candidate files:

(after-load 'recentf
  (add-to-list 'recentf-filename-handlers 'abbreviate-file-name))

I want easy access to my recent files, so define a function that lets me use ido to search over them. Bind this to C-x C-r (C-c C-r is used in modes like =org=mode):

(after-load 'recentf
  (after-load 'ido
    (defun bw/recentf-ido-find-file ()
      "Find a recent file using ido."
      (interactive)
      (let ((file (ido-completing-read "Recently: " recentf-list nil t)))
        (when file
          (find-file file))))

    (global-set-key (kbd "C-x C-r") 'bw/recentf-ido-find-file)))

Now enable recentf:

(after-load 'recentf
  (recentf-mode 1))
(require 'recentf)

ediff is a full-featured visual diff and merge tool, built into Emacs.

Make sure that the window split is always side-by-side:

(setq ediff-split-window-function 'split-window-horizontally)

Ignore whitespace changes:

(setq ediff-diff-options "-w")

Only ever use one set of windows in one frame:

(setq ediff-window-setup-function 'ediff-setup-windows-plain)

Emacs has a built-in package manager.

Rather than using Git submodules or similar my Emacs configuration is set up to automatically download and install any required packages at load time. This makes my configuration fully portable.

First set up convenience function (borrowed from Steve Purcell’s emacs config) that installs a package if it’s not already installed:

(defun require-package (package &optional min-version no-refresh)
  "Install given PACKAGE, optionally requiring MIN-VERSION.
If NO-REFRESH is non-nil, the available package lists will not be
re-downloaded in order to locate PACKAGE."
  (if (package-installed-p package min-version)
      t
    (if (or (assoc package package-archive-contents) no-refresh)
        (package-install package)
      (progn
        (package-refresh-contents)
        (require-package package min-version t)))))

The default value for package-user-dir is ~/.emacs.d/elpa - since these are third-party packages that are dynamically installed I’d prefer them to be in a hidden directory.

Packages are also byte compiled upon installation, so namespace the install directory to the version of Emacs I’m using.

Final result should be something like ~/.emacs.d/.elpa/24.3.93.1/.

(after-load 'package
  (setq package-user-dir
        (bw/join-dirs (bw/join-dirs bw/dotfiles-dir ".elpa") emacs-version)))

By default Emacs only installs files from ELPA. Some of these packages are old or out of date, and they don’t track GitHub repositories.

I want to also add:

• MELPA (tracks GitHub repositories, is much more comprehensive)
• MELPA stable (like MELPA, but pinned to specific versions)
• Elpy (allows me to install the Elpy Python development environment)

(after-load 'package
  (setq package-archives
        '(("gnu"          . "http://elpa.gnu.org/packages/")
          ("melpa"        . "http://melpa.org/packages/")
          ("melpa-stable" . "http://stable.melpa.org/packages/")
          ("elpy"         . "http://jorgenschaefer.github.io/packages/"))))

Finally we initialise the package manager:

(package-initialize)

diminish removes or abbreviates the minor mode indicators that can clutter up one’s modeline.

(require-package 'diminish)

Diminish subword-mode, eldoc-mode, and auto-revert-mode:

(after-load 'diminish
  (after-load 'subword
    (diminish 'subword-mode))
  (after-load 'eldoc
    (diminish 'eldoc-mode))
  (after-load 'autorevert
    (diminish 'auto-revert-mode)))

paradox is an advanced package.el frontend with GitHub integration.

(require-package 'paradox)

Force paradox into a fullframe:

(after-load 'fullframe
  (fullframe paradox-list-packages paradox-quit-and-close nil))

Automatically ‘star’ packages on GitHub after I install them (so I can easily follow changes to them):

(let ((github-token (bw/get-keychain-password "paradox-github-token")))
  (setq paradox-automatically-star github-token)
  (setq paradox-github-token github-token))

Add launch command:

(bw/add-launcher "p" 'paradox-list-packages)

Paradox now supports an asynchronous mode which requires the async package:

(require-package 'async)
(setq paradox-execute-asynchronously t)

OS X doesn’t use the environment variables available in a shell in a GUI environment (more here).

Since Emacs runs shell commands regularly it’s important that the same PATH is available to my editor as Homebrew etc. set and use.

exec-path-from-shell is a package that copies across PATH and other variables to the Emacs environment.

I only want this to be installed and enabled on OS X.

(when (and (eq system-type 'darwin) (display-graphic-p))
  (require-package 'exec-path-from-shell)
  (setq exec-path-from-shell-variables '("PATH"  "MANPATH" "SHELL"))
  (exec-path-from-shell-initialize))

smex is an advanced completion mode for execute-extended-command (usually known as M-x).

(require-package 'smex)

Replace execute-extended-command’s keyboard shortcuts:

(define-key (current-global-map) [remap execute-extended-command] 'smex)

Make sure we stop the annoying “click this menubar” advice in the buffer:

(setq-default smex-key-advice-ignore-menu-bar t)

Move smex’s cache file out of the home directory:

(setq smex-save-file (expand-file-name ".smex-items" bw/tmp-local-dir))

fullframe is a minor mode which allows certain buffers to take over the full frame using advice.

(require-package 'fullframe)

Magit is an Emacs interface to Git. It’s very feature-rich and I find it intuitive.

magit-status is the main command to launch Magit. It’s autoloaded so I don’t need to load Magit first.

(global-set-key (kbd "C-c g") 'magit-status)
(bw/add-launcher "g" 'magit-status)

magit-grep isn’t autoloaded, so I need to explicitly load it before binding it:

(autoload 'magit-grep "magit" "Grep for files" t)
(global-set-key (kbd "C-c f") 'magit-grep)

Since I use Magit I don’t need to use Emacs’s native vc-mode:

(delete 'Git vc-handled-backends)

When performing a completing-read within Magit, I’d like to use IDO:

(setq magit-completing-read-function 'magit-ido-completing-read)

When I create a new local branch from remote, by default I want it to be named the same as the remote branch (default is $(remotename)-$(branchname), eg origin-my-branch):

(setq magit-default-tracking-name-function 'magit-default-tracking-name-branch-only)

Open the magit-status buffer in the same window as the current buffer:

(setq magit-status-buffer-switch-function 'switch-to-buffer)

Highlight individual word and letter changes when showing hunk diff overlays:

(setq magit-diff-refine-hunk t)

When rewriting, always ask me if I want to include the revision at point in the rewrite:

(setq magit-rewrite-inclusive 'ask)

When Magit asks me to save modified buffers, ask me about them:

(setq magit-save-some-buffers t)

When Magit takes a while to call out to Git, pop the process buffer after 10 seconds so I can look for issues:

(setq magit-process-popup-time 10)

When pushing a branch without a remote, ask me which remote to set it to:

(setq magit-set-upstream-on-push t)

When magit-auto-revert-mode is enabled, diminish its lighter in the modeline:

(setq magit-auto-revert-mode-lighter "")

If fullframe is installed (see below), use it to make magit-status take over the entire frame:

(after-load 'fullframe
  (fullframe magit-status magit-mode-quit-window nil))

Finally we can install Magit:

(require-package 'magit)

gitignore-mode is a major mode for editing gitignore files:

(require-package 'gitignore-mode)

gitconfig-mode is a major more for editing gitconfig files:

(require-package 'gitconfig-mode)

ido-ubiquitous mode enables ido in many more places than the default ido setup:

(require-package 'ido-ubiquitous)
(ido-ubiquitous-mode 1)

ido-vertical mode renders the ido prompt vertically instead of horizontally. I find this easier to read.

(require-package 'ido-vertical-mode)
(ido-vertical-mode) ;; autoloaded

Because it’s displayed vertically and I want to save screen real estate, I want to reduce the maximum number of candidates ido displays:

(setq ido-max-prospects 5)

flx-ido is an advanced flex-matching algorithm that’s significantly faster and more accurate than the built-in method.

(require-package 'flx-ido)

The flx-ido documentation suggests upping the threshold at which GC occurs within Emacs so that flx can cache its candidate lists for longer:

(setq gc-cons-threshold 20000000)

Finally we cause flx-ido-mode to take over ido:

(flx-ido-mode 1)

ace-jump-mode allows one to jump around the buffer to named characters (it’s easier to watch the video on that link than explain).

(require-package 'ace-jump-mode)

Bind it:

(global-set-key (kbd "C-c SPC") 'ace-jump-char-mode)
(global-set-key (kbd "C-<return>") 'ace-jump-line-mode)
(bw/add-launcher "j" 'ace-jump-char-mode)
(bw/add-launcher "J" 'ace-jump-line-mode)

Since evil has excellent support for ace-jump-mode, we should add extra bindings for that:

(after-load 'evil
  (define-key evil-normal-state-map (kbd "SPC") 'ace-jump-char-mode)
  (define-key evil-normal-state-map (kbd "<return>") 'ace-jump-line-mode))

Also make sure that SPC and <return> do the right thing:

(after-load 'evil
  (define-key evil-motion-state-map (kbd "SPC") 'ace-jump-char-mode)
  (define-key evil-motion-state-map (kbd "<return>") 'ace-jump-line-mode))

popwin is a popup window manager that helps make the behaviour of compilation buffers, search buffers etc. a bit more sane.

(require-package 'popwin)

As well as the defaults, I want ag, magit, flycheck and occur to ‘pop’. I don’t want to auto-select the Magit process buffer as it’s for information only.

(after-load 'popwin
  (add-to-list 'popwin:special-display-config `"*ag search*")
  (add-to-list 'popwin:special-display-config `("*magit-process*" :noselect t))
  (add-to-list 'popwin:special-display-config `"*Flycheck errors*")
  (add-to-list 'popwin:special-display-config `"*Occur*")
  (add-to-list 'popwin:special-display-config `("*Compile-Log*" :noselect t)))

Load popwin and configure keyboard shortcuts:

(require 'popwin)
(popwin-mode 1)
(global-set-key (kbd "C-c P") 'popwin:popup-last-buffer)
(when (eq system-type 'darwin)
  (global-set-key (kbd "s-P") 'popwin:popup-last-buffer))

ag is an Emacs frontend to the ag command, a grep-like code-searching tool. It’s installed via Homebrew on my Mac.

(require-package 'ag)

Set up some key bindings:

(global-set-key (kbd "C-c f") 'ag-project)
(global-set-key (kbd "C-c a") 'ag)
(when (eq system-type 'darwin)
  (global-set-key (kbd "s-F") 'ag-project)
  (global-set-key (kbd "s-A") 'ag))
(bw/add-launcher "a" 'ag-project)
(bw/add-launcher "A" 'ag)

Make sure that we re-use the ag buffers - without this my buffer list is full of buffers named after the project root.

(setq ag-reuse-buffers t)

Highlight search results using isearch highlight faces (otherwise it just copies them from the shell):

(setq ag-highlight-search t)
(add-hook 'ag-mode-hook
          (lambda ()
            (copy-face 'lazy-highlight 'ag-match-face)))

wgrep-ag allows me to edit ag results directly from the buffer.

(require-package 'wgrep-ag)

projectile is a minor mode for performing commands over a single ‘project’ or grouping of files.

(require-package 'projectile)
(projectile-global-mode)

I want my keyboard shortcuts to be the same in Projectile as in non-Projectile buffers, so do some remapping:

(after-load 'projectile
  (define-key projectile-mode-map [remap magit-find-file-completing-read] 'projectile-find-file)
  (define-key projectile-mode-map [remap ag-project] 'projectile-ag))

Since I use ag, always use that instead of grep:

(after-load 'projectile
  (define-key projectile-mode-map [remap projectile-grep] 'projectile-ag))

Also define a convenience keyboard shortcut to switch between buffers from the same project:

(after-load 'projectile
  (global-set-key (kbd "s-b") 'projectile-switch-to-buffer)
  (global-set-key (kbd "C-x 4 s-b") 'projectile-switch-to-buffer-other-window)
  (bw/add-launcher "s" 'projectile-switch-project))

Provide some advice to projectile-current-project-files so it uses the magit-find-file library when we’re in a Git repository - using Magit’s process manager is significantly faster than Projectile’s own Git interaction, which creates a new shell process each time. Since magit-find-file might be loaded at any time, just make sure this advice runs after everything has finished:

(add-hook 'after-init-hook
          (lambda ()
            (when (fboundp 'magit-find-file-completing-read)
              (defadvice projectile-current-project-files (around bw/use-magit-find-file activate)
                "If magit-find-file-completing-read is available use that to
call the files instead of Projectile's native caller - this is
much much faster"
                (autoload 'magit-find-file-files "magit-find-file")
                (autoload 'magit-get-top-dir "magit")
                (if (magit-get-top-dir)
                    (let ((default-directory (projectile-project-root)))
                      (setq ad-return-value (magit-find-file-files)))
                  ad-do-it)))))

I use the solarized dark theme in my editor. Specifically, I use the https://github.com/bbatsov/solarized-emacs variant as it has the best support for the major modes I use, and is the most up to date. Previously I used sellout’s variant as it has much better terminal support, but it hasn’t been updated seriously in years and it fell behind for modern modes.

(require-package 'solarized-theme)

Since it doesn’t work well with my terminal theme (also Solarized Dark), I only want to enable it on graphical displays (see Themes). I also want to make sure I set the modeline to be high contrast (reversed out):

(setq solarized-high-contrast-mode-line t)

Ensure that the descender in the modeline doesn’t sit up against the buffer name (this only comes into play if solarized-high-contrast-mode-line isn’t set):

(setq x-underline-at-descent-line t)

I use the zenburn-theme on a TTY Emacs as it has excellent terminal colouring (see Themes):

(require-package 'zenburn-theme)

magit-find-file is a package that uses Magit’s process buffers to emulate SublimeText’s Command p functionality within Git repositories.

(require-package 'magit-find-file)

Set up keybindings for it, particularly the SublimeText equivalent:

(global-set-key (kbd "C-c t") 'magit-find-file-completing-read)
(global-set-key (kbd "M-p") 'magit-find-file-completing-read)
(when (eq system-type 'darwin)
    (global-set-key (kbd "s-p") 'magit-find-file-completing-read))
(bw/add-launcher "t" 'magit-find-file-completing-read)

evil is a very full-featured Vim emulator for Emacs.

(require-package 'evil)

evil-leader is a way of using Vim’s leader key concept in Emacs. Since Emacs already supports nested key bindings, this is really just for convenience.

Install evil-leader, and enable it globally:

(require-package 'evil-leader)
(global-evil-leader-mode 1)

and set it to , (the default is \):

(evil-leader/set-leader ",")

Now set up all the evil-leader powered shortcuts I want:

(evil-leader/set-key
  "b" 'ido-switch-buffer
  "d" 'dired-jump
  "k" 'kill-this-buffer
  "K" 'kill-buffer
  "l" 'linum-mode
  "o" 'occur
  "O" 'browse-url
  "P" 'popwin:popup-last-buffer
  "r" 'bw/recentf-ido-find-file
  "w" 'save-buffer
  "x" 'smex
  "y" 'bury-buffer)

Now we automatically copy across everything from bw/launcher-map to ensure I easily retain muscle memory:

(dolist (entry (cdr bw/launcher-map))
  (evil-leader/set-key
    (key-description (vector (car entry))) (cdr entry)))

If we have guide-key installed, push the leader key onto that:

(after-load 'guide-key
  (add-hook 'evil-leader-mode-hook
            #'(lambda () (guide-key/add-local-guide-key-sequence evil-leader/leader))))

Set up some defaults for evil.

Firstly, stop Evil from making the cursor color invisible sometimes:

(after-load 'evil
  (setq evil-default-cursor t))

Make sure that sideways motion keys (h, l etc.) wrap around to the next/previous lines:

(after-load 'evil
  (setq evil-cross-lines t))

When starting Evil, start in normal mode:

(after-load 'evil
  (setq evil-default-state 'normal))

Include the first and last character when moving to the start or end of lines:

(after-load 'evil
  (setq evil-want-visual-char-semi-exclusive t))

When exiting insert mode, don’t move the cursor:

(after-load 'evil
  (setq evil-move-cursor-back nil))

Use ido-find-file when using the :e ex-command - but only after typing a space (e by itself will still reload):

(define-key evil-ex-map "e " 'ido-find-file)

diminish abbrev-mode, which is bundled with evil:

(after-load 'diminish
  (diminish 'abbrev-mode))

Also diminish undo-tree-mode, a mode which allows one to visualise their undo/redo history. This mode is bundled with evil:

(after-load 'undo-tree
  (diminish 'undo-tree-mode))

Finally, invoke evil-mode using my launcher:

(bw/add-launcher "e" 'evil-mode)

Evil has some annoying defaults that I don’t want to unlearn.

C-e is normally evil-copy-from-below in insert mode - I’d rather it was end-of-line:

(define-key evil-insert-state-map "\C-e" 'end-of-line)

C-g is the default ‘exit everything’ key in Emacs - make it do the same thing in Evil (these mappings have been manually copied from evil-maps.el):

(define-key evil-normal-state-map "\C-g" 'evil-force-normal-state)
(define-key evil-visual-state-map "\C-g" 'evil-exit-visual-state)
(define-key evil-insert-state-map "\C-g" 'evil-normal-state)
(define-key evil-replace-state-map "\C-g" 'evil-normal-state)
(define-key evil-ex-completion-map "\C-g" 'abort-recursive-edit)

On OS X, evil copies every single visual state move to the kill ring, which in turns copies it to my system clipboard. I don’t want that to happen.

This has been filed as a bug against evil, and most of the code has come from this StackOverflow question:

(defadvice evil-visual-update-x-selection (around clobber-x-select-text activate)
  (unless (featurep 'ns)
    ad-do-it))

This allows me to perform a motion command that narrows the range to a new buffer as an indirect buffer (good explanation of how they might be used).

This code has been mostly copied from http://demonastery.org/2013/04/emacs-evil-narrow-region/.

(after-load 'narrow-indirect
  (evil-define-operator evil-narrow-indirect (beg end type)
    "Indirectly narrow the region from BEG to END."
    (interactive "<R>")
    (evil-normal-state)
    (ni-narrow-to-region-indirect-other-window beg end))
  (define-key evil-normal-state-map "m" 'evil-narrow-indirect)
  (define-key evil-visual-state-map "m" 'evil-narrow-indirect))

evil supports a default starting state for different major modes. I often want evil to start in emacs-mode, for example:

(dolist (mode-map '((ag-mode . emacs)
                    (cider-repl-mode . emacs)
                    (comint-mode . emacs)
                    (eshell-mode . emacs)
                    (fundamental-mode . emacs)
                    (git-commit-mode . insert)
                    (git-rebase-mode . emacs)
                    (help-mode . emacs)
                    (paradox-menu-mode . emacs)
                    (term-mode . emacs)))
  (evil-set-initial-state `,(car mode-map) `,(cdr mode-map)))

smartparens is a paredit like minor-mode for many more things than just Lisp.

show-smartparens-mode is a replacement mode for show-paren-mode.

(require-package 'smartparens)
(require 'smartparens-config)
(show-smartparens-global-mode 1)

company-mode is a modern and modular completion framework (the other one Emacs people use is autocomplete. I chose company because it’s well-maintained and has better code for integrating with).

I don’t want company to auto-start - it should only pop when I ask for it:

(after-load 'company
  (setq company-idle-delay nil))

I want it to attempt a completion immediately after a . character - without this I need a few characters before it’ll show candidates:

(after-load 'company
  (setq company-minimum-prefix-length 0))

Show candidates immediately rather than waiting:

(after-load 'company
  (setq company-echo-delay 0))

Make the lighter shorter:

(after-load 'company
  (after-load 'diminish
    (diminish 'company-mode "com")))

Define a function to enable company-mode and overwrite hippie’s key binding for the local buffer only (this means I can use the same key binding for completion no matter which minor mode I’m using):

(defun bw/enable-company-mode ()
  "Enables company-mode and overloads hippie-expand's binding"
  (company-mode 1)
  (define-key (current-local-map) [remap dabbrev-expand] 'company-complete))

Add this function to any modes derived from prog-mode:

(after-load 'company
  (add-hook 'prog-mode-hook 'bw/enable-company-mode))

If I’m using evil, I’ll need to create a new function which acts like a lambda (and ignores arguments):

(defun bw/company-complete-lambda (arg)
  "Ignores passed in arg like a lambda and runs company-complete"
  (company-complete))

And then bind that to the functions evil uses to complete:

(after-load 'evil
  (setq
   evil-complete-next-func 'bw/company-complete-lambda
   evil-complete-previous-func 'bw/company-complete-lambda))

(require-package 'company)
(require 'company)

flycheck is a modern, more easily customisable version of flymake. It’s used to perform on-the-fly syntax checking and linting.

(require-package 'flycheck)
(after-load 'flycheck
  (setq
   ;; don't show anything in the left fringe
   flycheck-indication-mode nil))
(require 'flycheck)

I use js2-mode for editing JavaScript. js2-mode is a JavaScript major mode that includes a full syntax parser written in Emacs Lisp.

(require-package 'js2-mode)
(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))

js2-mode isn’t auto-loaded for *.js files, as Emacs ships with a default JavaScript major mode, so I need the final line to make sure I use the right mode.

The default lighter for js2-mode Javascript-IDE, which is too long. Rename it:

(rename-modeline "js2-mode" js2-mode "JS2")

JavaScript classes are typically written in CamelCase, so enabled subword-mode:

(add-hook 'js2-mode-hook (lambda () (subword-mode 1)))

Highlight everything:

(after-load 'js2-mode
  (setq js2-highlight-level 3))

Always indent by 4 spaces:

(after-load 'js2-mode
  (setq js2-basic-offset 3))

Make the closing bracket position indent itself idiomatically:

(after-load 'js2-mode
  (setq js2-consistent-level-indent-inner-bracket-p t))

Allow for multi-line var declaration indenting:

(after-load 'js2-mode
  (setq js2-pretty-multiline-decl-indentation-p t))

I use jslint on the command line (via node.js) to provide syntax checking/linting, and this is integrated with flycheck.

This repository includes an npm manifest that installs a local copy of JSLint. Add the node_modules binary path to my exec path.

(after-load 'flycheck
  (add-to-list 'exec-path (concat bw/dotfiles-dir "node_modules/.bin/")))

Define a custom checker that supports the output of the --terse flag to JSLint, and enable it only for js2-mode.

(after-load 'flycheck
  (flycheck-define-checker javascript-jslint-reporter
      "JSLint based checker"
      :command ("jslint" "--terse" source)
      :error-patterns
      ((warning line-start (1  nonl) ":" line ":" column ":" blank (message) line-end))
      :modes js2-mode))

Finally, enable my custom checker when js2-mode is enabled. This also dynamically disables js2-mode’s built-in linting functionality so it doesn’t clash.

(after-load 'flycheck
  (defun bw/turn-on-flycheck-mode-js2 ()
    "Turn on and define JS2 mode checker"
    (set (make-local-variable 'js2-highlight-external-variables) nil)
    (set (make-local-variable 'js2-strict-missing-semi-warning) nil)
    (flycheck-select-checker 'javascript-jslint-reporter)
    (flycheck-mode 1))

  (add-hook 'js2-mode-hook 'bw/turn-on-flycheck-mode-js2))

Go is an open source language created by Google.

go-mode is a major mode for editing .go files. It has excellent integration with the Go compiler and toolchain.

(require-package 'go-mode)

Make sure we run gofmt before saving any Go files:

(after-load 'go-mode
  (add-hook 'before-save-hook 'gofmt-before-save))

Make sure we capture the GOPATH environment variable on OS X:

(when (eq system-type 'darwin)
  (after-load 'exec-path-from-shell
    (exec-path-from-shell-copy-env "GOPATH")))

Deal with gom - gom puts locally versioned packages into ./_vendor, so let’s dynamically add that to our GOPATH:

(defun bw/set-local-go-path ()
  "Sets a local GOPATH if appropriate"
  (make-local-variable 'process-environment)
  (let* ((local-go-path (concat (projectile-project-root) "_vendor"))
         (current-go-path (getenv "GOPATH")))
    (if (not current-go-path)
        (setenv "GOPATH" local-go-path)
      (unless (string-match-p local-go-path current-go-path)
        (setenv "GOPATH" (concat local-go-path ":" current-go-path))))))

(add-hook 'go-mode-hook 'bw/set-local-go-path)

Make sure that if we’re using goenv or gom we can detect that with projectile:

(after-load 'projectile
  (add-to-list 'projectile-project-root-files ".go-version")
  (add-to-list 'projectile-project-root-files "Gomfile"))

flycheck has excellent golang integration, so enable it:

(after-load 'go-mode
  (after-load 'flycheck
    (add-hook 'go-mode-hook 'flycheck-mode-on-safe)))

Because Go is a compiled language, we can inspect functions statically and provide documentation in the editor using eldoc:

(require-package 'go-eldoc)
(after-load 'go-mode
  (add-hook 'go-mode-hook 'go-eldoc-setup))

Because of libraries like gocode, Go has very good completion. I use company for completion, so let’s integrate with that. Note this requires gocode to be installed on the system before it’ll work.

First I define a hook lambda that deletes all other company backends - gocode is so accurate that I don’t need any other suggestions:

(defun bw/setup-company-go ()
  "Hook for running on company-go"
  (set (make-local-variable 'company-backends) '(company-go)))

Now add the hook:

(after-load 'company-go
  (add-hook 'go-mode-hook 'bw/setup-company-go))

and install and load company-go:

(after-load 'go-mode
  (after-load 'company
    (require-package 'company-go)
    (require 'company-go)))

puppet-mode is a major mode for editing .pp files.

(require-package 'puppet-mode)

markdown-mode is a major mode for editing Markdown files.

(require-package 'markdown-mode)

There’s no official Markdown file extension, so support all the unofficial ones:

(add-to-list 'auto-mode-alist '("\\.md$" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.markdown$" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.ft$" . markdown-mode)) ;; FoldingText

paredit is a minor mode for editing S-expressions in a balanced way. It’s a very good way to edit Lisp, Clojure etc. files. More on EmacsWiki.

(require-package 'paredit)

Enable it for Emacs Lisp files:

(add-hook 'emacs-lisp-mode-hook 'enable-paredit-mode)
(add-hook 'lisp-interaction-mode-hook 'enable-paredit-mode)

Conditionally enable it in the minibuffer when entering an expression:

(defun bw/conditionally-enable-paredit-mode ()
  (if (eq this-command 'eval-expression)
      (enable-paredit-mode)))
(add-hook 'minibuffer-setup-hook 'bw/conditionally-enable-paredit-mode)

CIDER (Clojure IDE and REPL) is the best way to develop Clojure in Emacs.

(require-package 'cider)

Automatically enable eldoc-mode and paredit in CIDER buffers:

(after-load 'cider-mode
  (add-hook 'cider-mode-hook 'cider-turn-on-eldoc-mode)
  (add-hook 'cider-mode-hook 'enable-paredit-mode)
  (add-hook 'cider-repl-mode-hook 'enable-paredit-mode))

Finally enable the CIDER minor mode in Clojure buffers:

(after-load 'clojure-mode
  (add-hook 'clojure-mode-hook 'clojure-enable-cider))

web-mode is a major mode for editing templates and HTML. It supports a very broad range of template languages and is highly configurable.

(require-package 'web-mode)

Jinja templates are mostly like Django templates, so just force them to behave like that:

(after-load 'web-mode
  (setq web-mode-engines-alist
        '(("\\.jinja\\'" . "django"))))

Enable web-mode by default for several common file extensions:

(dolist (alist '(("\\.html$'" . web-mode)
                 ("\\.html\\.erb$" . web-mode)
                 ("\\.mustache$" . web-mode)
                 ("\\.jinja$" . web-mode)
                 ("\\.php$" . web-mode)))
  (add-to-list 'auto-mode-alist alist))

idomenu offers ido completion over imenu candidates. It allows me to navigate through classes etc. using completion for methods.

(require-package 'idomenu)

Add it to my launcher:

(bw/add-launcher "i" 'idomenu)

Automatically rescan the current file so imenu is up to date:

(setq imenu-auto-rescan t)

know-your-http-well is a documentation set for HTTP, linked out to all the various RFCs and specifications.

(require-package 'know-your-http-well)
(require 'know-your-http-well)

Regrettably I need to occasionally edit YAML.

(require-package 'yaml-mode)

guide-key shows a popup help window after a pressing defined keys for a short delay.

(require-package 'guide-key)

Enable it for my Launcher keymap prefix:

(setq guide-key/guide-key-sequence '("C-x C-l" "C-c p"))
(guide-key-mode 1)

diminish guide-key-mode:

(diminish 'guide-key-mode)

browse-kill-ring allows one to browse the kill ring history when yanking.

(require-package 'browse-kill-ring)

remap yank-pop:

(define-key (current-global-map) [remap yank-pop] 'browse-kill-ring)

make browse-kill-ring act like yank-pop by overwriting the previous yank:

(after-load 'browse-kill-ring
  (setq browse-kill-ring-replace-yank t))

narrow-indirect allows one to focus a buffer onto some particular code in another window, editing it separately from its original context (a better description of this workflow).

(require-package 'narrow-indirect)

projectile-rails provides some convenience functions and hooks to make working with Ruby on Rails projects easier:

(require-package 'projectile-rails)

and make sure it’s loaded during projectile’s loading phase:

(add-hook 'projectile-mode-hook 'projectile-rails-on)

So I can configure my Emacs per computer/user, I attempted to automatically load some configuration.

First set up a directory to hold the files:

(setq bw/local-dotfiles-dir (bw/join-dirs bw/dotfiles-dir "local"))

Now try to load a file named after the current user:

(load (concat bw/local-dotfiles-dir user-login-name ".el") t)

and try to load a file named after the local system:

(load (concat bw/local-dotfiles-dir system-name ".el") t)

Finally, try loading a default file:

(load (concat bw/local-dotfiles-dir "local-overrides.el") t)

Make sure anything saved using customize goes into a consistent (and ignored) place:

(load (setq custom-file (concat bw/dotfiles-dir "custom.el")) t)

(note that this works because setq returns the value it’s set to)