diff options
Diffstat (limited to 'emacs')
| -rw-r--r-- | emacs/.emacs.d/init.org | 2522 |
1 files changed, 2522 insertions, 0 deletions
diff --git a/emacs/.emacs.d/init.org b/emacs/.emacs.d/init.org new file mode 100644 index 0000000..151efbf --- /dev/null +++ b/emacs/.emacs.d/init.org @@ -0,0 +1,2522 @@ +#+TITLE: Emacs Configuration for Alan Pearce +#+OPTIONS: ^:nil +#+PROPERTY: results silent +#+PROPERTY: eval no-export +#+PROPERTY: header-args :comments link +* Introduction +This is a living document, detailing my Emacs configuration using org-mode +* Basics +** Startup +Open Emacs with just a plain window. No graphics or messages, please! +#+BEGIN_SRC emacs-lisp +(put 'inhibit-startup-echo-area-message 'saved-value + (setq inhibit-startup-echo-area-message (user-login-name))) +(setq inhibit-startup-screen t) +(setq gc-cons-threshold 100000000) +(defvar file-name-handler-alist-backup file-name-handler-alist) +(setq file-name-handler-alist nil) +(remove-hook 'find-file-hooks #'vc-refresh-state) +#+END_SRC + +** Scratch buffers +I usually use scratch buffers for any sort of text. If I need a +programming mode in one, then I’ll just call it manually. I also like +the buffer to be empty. +#+BEGIN_SRC emacs-lisp +(setq initial-scratch-message "" + initial-major-mode 'text-mode) +#+END_SRC + +** Personal Information +#+BEGIN_SRC emacs-lisp +(setq user-mail-address "alan@alanpearce.co.uk" + user-full-name "Alan Pearce") +#+end_src + +* Packaging + +** Use-package + +#+BEGIN_SRC emacs-lisp +(eval-and-compile + (setq tls-checktrust t + gnutls-verify-error t + package-archives '(("gnu" . "https://elpa.gnu.org/packages/") + ("melpa-stable" . "https://stable.melpa.org/packages/") + ("melpa" . "https://melpa.org/packages/")) + package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa") + package-pinned-packages '(("use-package" . melpa-stable) + ("diminish" . melpa-stable) + ("bind-key" . melpa-stable)) + package-archive-priorities '(("melpa-stable" . 10) + ("gnu" . 10) + ("marmalade" . 5) + ("melpa" . 0)) + package-menu-async t + package-menu-hide-low-priority t) + (package-initialize) + (unless (package-installed-p 'use-package) + (package-refresh-contents) + (package-install 'use-package))) +(eval-when-compile (require 'use-package)) +(unless (featurep 'use-package) + (require 'diminish) + (require 'bind-key) + (use-package use-package + :commands (use-package-autoload-keymap) + :defer 5)) +(setq use-package-verbose t + use-package-always-ensure t + package-enable-at-startup nil) +#+END_SRC + +* Customize +I don’t really like using customize for normal configuration. +Instead, I use it for things that get saved automatically. That’s why +I use a different file, which is ignored by the VCS. It also means +that it’s not important whether the file exists or not, which is why I +pass =:noerror= to =load= + +#+BEGIN_SRC emacs-lisp +(setq custom-file "~/.emacs.d/custom.el") +(load custom-file :noerror :nomessage) +#+END_SRC + +* Styles + +I prefer an always-visible cursor. Feels less distracting. +#+BEGIN_SRC emacs-lisp +(when (fboundp #'blink-cursor-mode) + (blink-cursor-mode -1)) +#+END_SRC + +Disable all the bars, unless on OSX, in which case, keep the menu bar. + +#+BEGIN_SRC emacs-lisp +(when (and menu-bar-mode (not (eq window-system 'ns))) + (menu-bar-mode -1)) +(with-eval-after-load 'scroll-bar + (set-scroll-bar-mode nil)) +(with-eval-after-load 'tooltip + (tooltip-mode -1)) +(with-eval-after-load 'tool-bar + (tool-bar-mode -1)) +#+END_SRC + +Ring the bell sometimes, but not so often +#+BEGIN_SRC emacs-lisp +(setq ring-bell-function + (lambda () + (unless (memq this-command + '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit undo-tree-undo)) + (ding)))) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(use-package dash) +#+END_SRC + +** Colours + +Let’s try a more minimal theme. + +#+BEGIN_SRC emacs-lisp +(use-package minimal-theme + :disabled t + :config (progn + (load-theme 'minimal-light t))) +#+END_SRC + +Let’s try a basic theme. + +#+BEGIN_SRC emacs-lisp +(use-package basic-theme + :if (display-graphic-p) + :config (progn + (load-theme 'basic t) + + (set-face-background 'mode-line "#a1b56c") + (set-face-background 'border "#a1b56c") + (set-face-foreground 'border "#a1b56c") + (set-face-background 'vertical-border "#a1b56c") + (set-face-foreground 'vertical-border "#a1b56c") + (set-face-background 'window-divider "#a1b56c") + (set-face-foreground 'window-divider "#a1b56c") + + (defvar mode-line-default-format mode-line-format) + (defvar mode-line-default-hidden nil + "Whether to hide the mode line by default") + + (defun show-mode-line () + (interactive) + (setq mode-line-format mode-line-default-format) + (when (called-interactively-p 'interactive) + (setq-default mode-line-format mode-line-default-format) + (setq mode-line-default-hidden nil))) + (defun hide-mode-line () + (interactive) + (setq mode-line-format nil) + (when (called-interactively-p 'interactive) + (setq-default mode-line-format nil) + (setq mode-line-default-hidden t))) + + (setq-default cursor-type '(bar . 1)) + (setq-default cursor-in-non-selected-windows nil) + + (defun hide-clutter () + (interactive) + (fringe-mode '(0 . 4)) + (hide-mode-line)) + + (defun show-clutter () + (interactive) + (fringe-mode '(8 . 4)) + (show-mode-line)) + (hide-clutter) + + (when mode-line-default-hidden + (call-interactively #'hide-mode-line)) + + (defun hide-mode-line-if-default-hidden () + (if mode-line-default-hidden + (hide-mode-line) + (show-mode-line))) + + (add-to-list 'default-frame-alist '(border-width . 0)) + (add-to-list 'default-frame-alist '(internal-border-width . 0)) + (when (eq window-system 'x) + (setq window-divider-default-bottom-width 1 + window-divider-default-right-width 1 + window-divider-default-places t) + (setq mode-line-default-hidden t) + (window-divider-mode +1)) + + (add-hook 'after-change-major-mode-hook #'hide-mode-line-if-default-hidden) + + (add-hook 'minibuffer-setup-hook #'show-mode-line) + (add-hook 'minibuffer-exit-hook #'hide-mode-line))) +#+END_SRC + +Highlighting quasi-quoted expressions in lisps is quite useful, but I +don't need it all the time. I'll keep it around for a while so that I +can enable it if needed. +#+BEGIN_SRC emacs-lisp +(use-package highlight-stages + :diminish highlight-stages-mode) +#+END_SRC + +** Fonts + +When possible, set up fonts. I don’t have any settings here for X11, +because I manage those in my [[file:~/projects/dotfiles/tag-xresources/xresources/main][XResources file]]. +#+BEGIN_SRC emacs-lisp +(when (or (display-graphic-p) + (daemonp)) + + (defun use-variable-fonts () + (interactive) + (variable-pitch-mode) + (setq cursor-type 'bar)) + + (defun ap/set-fonts (mono-face mono-font-size variable-face variable-font-size antialias) + (if (boundp 'ns-antialias-text) + (setq ns-antialias-text antialias)) + (when mono-face + (let ((default-font (font-spec :family mono-face :size mono-font-size))) + (add-to-list 'default-frame-alist `(font . ,(format "%s %s" mono-face mono-font-size))) + (set-face-font 'fixed-pitch default-font) + (set-frame-font default-font t t))) + (when variable-face + (set-face-font 'variable-pitch (font-spec :name variable-face :size variable-font-size)))) + + (defun ap/set-fonts-according-to-system () + (interactive) + (cond + ((eq window-system 'w32) + (ap/set-fonts "Liberation Mono" 11 "Segoe UI" 11 t)) + ((eq window-system 'ns) + (let ((displays (string-to-number (shell-command-to-string "system_profiler SPDisplaysDataType | grep \"Online: Yes\" | wc -l")))) + (if (eq displays 1) + (ap/set-fonts "Roboto Mono" 13 "Lucida Grande" 13 t) + (ap/set-fonts "Monaco" 10 "Lucida Grande" 12 nil)))) + ((eq window-system 'x) + (set-fontset-font "fontset-default" 'unicode (font-spec :name "Terminus" :size 8)) + (ap/set-fonts "Fixed" 8 "Lucida" 8 nil)))) + + (ap/set-fonts-according-to-system)) +#+END_SRC + +Reduce font decoration. I’m trying to see whether this helps me focus +on the right things. +#+BEGIN_SRC emacs-lisp +(setq font-lock-maximum-decoration '((dired-mode . 1) + (t . 1))) +#+END_SRC + +** Page Breaks + +By default, Emacs displays page breaks as ^L. Lines look much nicer. +On Windows, Emacs incorrectly detects that U+2500 (Box Drawings Light +Horizontal) can only be displayed with a different font, which is not +correct, at least for Liberation Mono. + +#+BEGIN_SRC emacs-lisp +(use-package page-break-lines + :defer 5 + :diminish page-break-lines-mode + :config (progn + (global-page-break-lines-mode) + (unless (eq (char-displayable-p ?─) (char-displayable-p ?a)) + (set-fontset-font "fontset-default" + (cons page-break-lines-char page-break-lines-char) + (face-attribute 'default :family))))) +#+END_SRC +** Modeline + +#+BEGIN_SRC emacs-lisp +(column-number-mode t) +(size-indication-mode t) + +(setq frame-title-format '("%f" (dired-directory dired-directory))) +#+END_SRC + +** Highlight Changes + +Highlight what just changed when I undo, yank, and so on. + +#+BEGIN_SRC emacs-lisp +(use-package volatile-highlights + :diminish volatile-highlights-mode + :config (progn + (volatile-highlights-mode t))) +#+END_SRC + +** Beacon + +I was against the idea of having flashy animations inside Emacs, but +this one is useful. It highlights the cursor when scrolling or +switching windows. + +#+BEGIN_SRC emacs-lisp +(use-package beacon + :diminish beacon-mode + :config (beacon-mode +1)) +#+END_SRC + +** Renaming major modes + +Diminishing major modes does not happen in the same manner as minor +modes. + +#+BEGIN_SRC emacs-lisp +(use-package cyphejor + :defer 2 + :config (progn + (setq cyphejor-rules `(("emacs" "ε") + ("diff" "Δ") + ("js2" "js") + ("magit-status" ,(char-to-string (-find #'char-displayable-p '(11942 5848 177)))) + ("inferior" "i" :prefix) + ("interaction" "i" :prefix) + ("interactive" "i" :prefix) + ("menu" "▤" :postfix) + ("ledger" "Ledger") + ("mode" "") + ("shell" "sh" :postfix))) + (cyphejor-mode 1))) +#+END_SRC + + +* Environment Variables + +MacOS doesn’t have a reasonable way to set environment variables and +read them automatically any more. So, let’s use the +[[https://github.com/purcell/exec-path-from-shell][exec-path-from-shell]] package to set up ~exec-path~ and similar +variables from whatever my shell configuration is. + +#+BEGIN_SRC emacs-lisp +(use-package exec-path-from-shell + :if (eq system-type 'darwin) + :config (exec-path-from-shell-initialize)) +#+END_SRC + +* Keybindings + +I think =set-keyboard-coding-system= stops OS X from doing something +annoying to add accents. The modifier setup is to match my +re-arrangement of modifiers on OSX: Cmd on the outside, then +Option/alt, then Control. + +#+BEGIN_SRC emacs-lisp +(when (eq system-type 'darwin) + (set-keyboard-coding-system nil) + (custom-set-variables + '(mac-option-modifier 'meta) + '(mac-right-option-modifier 'none) + '(mac-control-modifier 'control) + '(mac-right-control-modifier 'left) + '(mac-command-modifier 'super) + '(mac-right-command-modifier 'left) + '(mac-function-modifier 'hyper)) + (unbind-key "s-x")) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(unbind-key "<f4>") +(bind-key* "<f5>" #'compile) +(bind-key* "<f6>" #'kmacro-start-macro-or-insert-counter) +(bind-key* "<f7>" #'kmacro-end-or-call-macro) + +(bind-key* "<apps>" #'execute-extended-command) + +(unbind-key "C-z") +(bind-key* "C-<tab>" #'other-window) + +(bind-key* "C-x C-r" #'revert-buffer) +(bind-key* "C-x C-j" #'delete-indentation) +(unbind-key "C-x C-c") + +(bind-key* "C-c i" #'insert-char) +(bind-key* "M-/" #'hippie-expand) + +(unbind-key "s-h") +(unbind-key "s-n") +(unbind-key "s-p") +(unbind-key "s-w") +(bind-key* "s-k" #'kill-or-delete-this-buffer-dwim) + +(bind-key "C-M-a" #'backward-paragraph text-mode-map) +(bind-key "C-M-e" #'forward-paragraph text-mode-map) + +(bind-key* "s-x" (define-prefix-command 'super-x-map)) +(bind-key* "s-," #'switch-to-dotfiles) +(bind-key* "C-M-x" #'execute-extended-command) +(set-register ?z `(file . ,(expand-file-name ".config/zsh/zshrc" "~"))) +#+END_SRC + +** Crux + +I can replace most of the simple helper/wrapper functions in my +configuration with crux.el + +#+BEGIN_SRC emacs-lisp +(use-package crux + :bind (("M-o" . crux-smart-open-line-above) + ("C-o" . crux-smart-open-line) + + ("C-x 4 t" . crux-transpose-windows) + ("C-c e" . crux-eval-and-replace) + ("C-c D" . crux-delete-file-and-buffer) + ("C-c R" . crux-rename-file-and-buffer)) + :init (progn + (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer) + (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer))) +#+END_SRC + +* Projects + +#+BEGIN_SRC emacs-lisp +(defvar work-project-directory "~/work") +(defvar home-project-directory "~/projects") +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(defun switch-to-dotfiles () + (interactive) + (projectile-switch-project-by-name (expand-file-name "dotfiles" home-project-directory))) +#+END_SRC + +** The Silver Searcher + +#+BEGIN_SRC emacs-lisp +(use-package ag + :defer 30 + :config (setq ag-project-root-function #'projectile-project-root)) + +(use-package wgrep-ag + :after ag) +#+END_SRC + +** Ripgrep + +Step over Silver Search, here comes a new challenger. + +#+BEGIN_SRC emacs-lisp +(use-package ripgrep + :if (executable-find "rg")) + +(use-package projectile-ripgrep + :after (ripgrep projectile) + :if (executable-find "rg") + :bind (("C-c p s r" . projectile-ripgrep))) +#+END_SRC + +** Projectile + +Projectile is awesome for working in projects, especially VCS-backed +ones. I added a couple of functions to allow me to open new projects +based upon some folder conventions I use. + +#+BEGIN_SRC emacs-lisp +(use-package projectile + :bind (("s-p" . projectile-switch-project) + ("C-c C-f" . projectile-find-file) + ("s-x s-f" . projectile-find-file) + ("C-x g" . projectile-vc) + ("s-G" . projectile-vc)) + :demand t + :diminish projectile-mode + :config (progn + (projectile-global-mode) + (add-to-list 'projectile-globally-ignored-directories ".stversions") + (defun ap/subfolder-projects (dir) + (--map (file-relative-name it dir) + (-filter (lambda (subdir) + (--reduce-from (or acc (funcall it subdir)) nil + projectile-project-root-files-functions)) + (-filter #'file-directory-p (directory-files dir t "\\<"))))) + + (defun ap/open-subfolder-project (from-dir &optional arg) + (let ((project-dir (projectile-completing-read "Open project: " + (ap/subfolder-projects from-dir)))) + (projectile-switch-project-by-name (expand-file-name project-dir from-dir) arg))) + + (defun yarn-install (&optional arg) + (interactive "P") + (projectile-with-default-dir (projectile-project-root) + (cmd-to-echo "yarn" "install"))) + + (defun yarn-add-dev (package) + (interactive "spackage: ") + (projectile-with-default-dir (projectile-project-root) + (cmd-to-echo "yarn" (concat "add --dev " package)))) + + (defun yarn-add (package) + (interactive "spackage: ") + (projectile-with-default-dir (projectile-project-root) + (cmd-to-echo "yarn" (concat "add " package)))) + + (defun ap/open-work-project (&optional arg) + (interactive "P") + (ap/open-subfolder-project work-project-directory arg)) + + (defun ap/open-home-project (&optional arg) + (interactive "P") + (ap/open-subfolder-project home-project-directory arg)) + + (setq projectile-switch-project-action #'projectile-commander + projectile-completion-system 'ivy))) +#+END_SRC + +** vc + +This is nice for some things that magit doesn’t do, and for those rare +occasions that I’m working with something other than git. + +#+BEGIN_SRC emacs-lisp +(use-package vc + :defer t + :bind (("C-x v C" . vc-resolve-conflicts)) + :config (progn + (setq vc-follow-symlinks t) + (setq vc-ignore-dir-regexp (format "\\(%s\\)\\|\\(%s\\)" + vc-ignore-dir-regexp + tramp-file-name-regexp)))) +#+END_SRC + +** git-gutter-fringe + +It’s nice to be able to see at a glance which lines of a file have +changed. This package colours the fringe. I have it set to the right +fringe so it doesn’t interfere with flycheck. + +#+BEGIN_SRC emacs-lisp +(use-package git-gutter-fringe + :defer 2 + :diminish git-gutter-mode + :config (progn + (global-git-gutter-mode 1) + (set-face-foreground 'git-gutter:modified "grey") + (setq git-gutter-fr:side 'right-fringe))) +#+END_SRC + +** magit + +Magit is my favourite way to use git. I use selective staging all the +time. Make sure to set it up with a nice =completing-read-function= + +#+BEGIN_SRC emacs-lisp +(use-package magit + :defer 5 + :commands (magit-status) + :config (progn (setq magit-completing-read-function #'ivy-completing-read + magit-popup-use-prefix-argument 'default + magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1 + global-magit-file-mode nil) + (add-to-list 'magit-no-confirm 'safe-with-wip)) + :init (add-hook 'magit-mode-hook #'magit-load-config-extensions)) +#+END_SRC + +** git-timemachine + +This package allow me to go through a file’s history with just a few +keys. It makes it very easy to figure what what exactly was in a file +in the past. I often find it useful when I remember writing something +a particular way, but it changed later. + +#+BEGIN_SRC emacs-lisp +(use-package git-timemachine + :commands git-timemachine) +#+END_SRC + +* Files + +** Auto-saving + +Auto-save everything to a temporary directory, instead of cluttering +the filesystem. I don’t want emacs-specific lockfiles, either. + +#+BEGIN_SRC emacs-lisp +(setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t)) + create-lockfiles nil) +#+END_SRC +** Backups + +I like to keep my backups out of regular folders. I tell emacs to use +a subfolder of its configuration directory for that. Also, use the +trash for deleting on OS X. +#+BEGIN_SRC emacs-lisp +(let ((backup-dir (expand-file-name "~/.emacs.d/backups/"))) + (unless (file-directory-p backup-dir) + (make-directory backup-dir)) + (setq backup-directory-alist `((".*" . ,backup-dir)) + backup-by-copying-when-linked t + backup-by-copying-when-mismatch t)) +(if (eq system-type 'darwin) + (setq delete-by-moving-to-trash t) + (if (and (executable-find "trash") (not (fboundp #'system-move-file-to-trash))) + (defun system-move-file-to-trash (file) + (call-process (executable-find "trash") + nil 0 nil + file)))) +#+END_SRC + +** autorevert + +#+BEGIN_SRC emacs-lisp +(use-package autorevert + :diminish auto-revert-mode + :init (progn + (global-auto-revert-mode 1) + (setq auto-revert-verbose nil + auto-revert-use-notify (not (eq system-type 'darwin))))) +#+END_SRC + +** Encoding + +UTF-8 is usually appropriate. Note that =prefer-coding-system= expects +only a coding system, not a coding system and line ending combination. + +#+BEGIN_SRC emacs-lisp +(prefer-coding-system 'utf-8) +(setq-default buffer-file-coding-system 'utf-8-auto-unix) +#+END_SRC + +** Buffer-file management + +Ask if I want to create a directory when it doesn’t exist. This is +especially nice when starting new projects. + +#+BEGIN_SRC emacs-lisp +(defun my-create-non-existent-directory () + (let ((parent-directory (file-name-directory buffer-file-name))) + (when (and (not (file-exists-p parent-directory)) + (y-or-n-p (format "Directory `%s' does not exist! Create it?" parent-directory))) + (make-directory parent-directory t)))) +(add-to-list 'find-file-not-found-functions #'my-create-non-existent-directory) +#+END_SRC + +I often want to rename or delete the file that I’m currently visiting +with a buffer. + +#+BEGIN_SRC emacs-lisp +(defun kill-or-delete-this-buffer-dwim (&optional arg) + "Kills current buffer. With prefix arg, delete it." + (interactive "P") + (if (equal arg '(4)) + (delete-current-buffer-file) + (if server-buffer-clients + (server-edit) + (let ((buf (buffer-name))) + (when (equal buf "*HTTP Response*") + (other-window 1)) + (kill-buffer buf))))) +#+END_SRC + +** Whitespace Butler + +I don’t like it when editors change an entire file’s layout when I +open it. Whitespace butler fixes whitespace only for lines that I’m editing. + +#+BEGIN_SRC emacs-lisp +(use-package ws-butler + :if window-system + :diminish ws-butler-mode + :config (ws-butler-global-mode 1)) +(if (daemonp) + (add-hook 'before-make-frame-hook (lambda () + (use-package ws-butler + :config (ws-butler-global-mode 1))))) +#+END_SRC + +** shrink-whitespace + +DWIM whitespace removal. So I don’t need =M-SPC=, =M-\= and =C-x o= +for similar things any more. + +#+BEGIN_SRC emacs-lisp +(use-package shrink-whitespace + :bind ("M-SPC" . shrink-whitespace)) +#+END_SRC + +** Tramp + +Tramp is awesome. It makes SSH feel Unix-y. The proxy setup is so +that I can sudo on remote machines + +#+BEGIN_SRC emacs-lisp +(use-package tramp + :defer 7 + :config (progn + (unless (getenv "SSH_AUTH_SOCK") + (setenv "SSH_AUTH_SOCK" (format "/run/user/%s/ssh-agent" (user-uid)))) + (setq tramp-default-method "ssh" + tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root")) + tramp-backup-directory-alist backup-directory-alist + tramp-completion-reread-directory-timeout 60 + tramp-ssh-controlmaster-options nil + backup-enable-predicate (lambda (name) + (and (normal-backup-enable-predicate name) + (not (let ((method (file-remote-p name 'method))) + (when (stringp method) + (member method '("su" "sudo"))))))) + tramp-shell-prompt-pattern "\\(?:^\\| \\)[^]#$%>\n]*#?[]#$%>❯›] *\\(\\[\\??[0-9;]*[a-zA-Z] *\\)*") + (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" (concat "/" tramp-default-method ":%h:"))) + (add-to-list 'tramp-default-proxies-alist `(,(regexp-quote (system-name)) nil nil)) + (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil)))) + +(use-package tramp-sh + :ensure nil + :defer t + :config (progn + (add-to-list 'tramp-remote-path "/usr/local/sbin") + (add-to-list 'tramp-remote-path "~/bin"))) +#+END_SRC + +** ediff + +I like a horizonal diff setup, with everything in one frame. + +#+BEGIN_SRC emacs-lisp +(use-package ediff + :defer t + :config (progn + (setq ediff-split-window-function 'split-window-horizontally + ediff-window-setup-function 'ediff-setup-windows-plain))) +#+END_SRC + +* Indentation + +Ah, a complicated topic. One day we’ll all be using elastic +tabstops. I’ve recently switched to using two spaces, since elastic +tabstops is probably never going to happen. + +#+BEGIN_SRC emacs-lisp +(setq-default tab-width 2 + indent-tabs-mode nil) +#+END_SRC + + +** smart-tabs-mode + +Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns +with spaces. Perfect! + +#+BEGIN_SRC emacs-lisp +(use-package smart-tabs-mode + :defer 1 + :config (progn + (smart-tabs-insinuate 'c 'cperl 'python) + (add-hook 'php-mode-hook (lambda () + (smart-tabs-mode indent-tabs-mode))))) +#+END_SRC + +** editorconfig + +#+BEGIN_SRC emacs-lisp +(use-package editorconfig + :config (editorconfig-mode 1)) +#+END_SRC + +** dtrt-indent-mode + +Sometimes people use different indentation settings. [[https://github.com/jscheid/dtrt-indent][dtrt-indent]] +guesses the correct settings for me. + +#+BEGIN_SRC emacs-lisp +(use-package dtrt-indent + :config (progn + (defun ap/dtrt-adapt-if-needed () + (unless editorconfig-mode + (dtrt-indent-adapt))) + (if (fboundp #'editorconfig-mode) + (add-hook 'after-change-major-mode-hook #'ap/dtrt-adapt-if-needed) + (add-hook 'after-change-major-mode-hook #'dtrt-indent-adapt)) + (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate) + (smart-tabs-mode (or indent-tabs-mode -1))))) +#+END_SRC + +* Security + +** password-store + +This is a frontend to the GPG-powered =pass= program. +#+BEGIN_SRC emacs-lisp +(use-package password-store + :defer 15 + :config (progn + (setq password-store-password-length 16))) +#+END_SRC +* Buffers + +** Ibuffer +Ibuffer is quite nice for listing all buffers. + +#+BEGIN_SRC emacs-lisp +(use-package ibuffer + :bind (("C-x C-b" . ibuffer)) + :config (progn + (setq ibuffer-saved-filter-groups + (quote (("default" + ("org" (mode . org-mode)) + ("emacs" (mode . emacs-lisp-mode)) + ("zsh" (filename . "/zsh")) + ("server" (filename . "/su:root@server")))))) + + ;; Human-readable base-2 size column + (define-ibuffer-column size-h + (:name "Size" :inline t) + (cond + ((> (buffer-size) 1024) + (format "%7.2fK" (/ (buffer-size) 1024.0))) + ((> (buffer-size) 1048576) + (format "%7.2fM" (/ (buffer-size) 1048576.0))) + (t + (format "%8d" (buffer-size))))) + + (setq ibuffer-formats + '((mark modified read-only " " + (name 18 18 :left :elide) + " " + (size-h 9 -1 :right) + " " + (mode 16 16 :left :elide) + " " + filename-and-process))))) +#+END_SRC + +** Relative Buffer names + +#+BEGIN_SRC emacs-lisp +(use-package relative-buffers + :defer 15 + :config (progn + (global-relative-buffers-mode))) +#+END_SRC +** Narrowing + +Enable it without prompting + +#+BEGIN_SRC emacs-lisp +(put 'narrow-to-defun 'disabled nil) +(put 'narrow-to-page 'disabled nil) +(put 'narrow-to-region 'disabled nil) +#+END_SRC + +** ace-window + +I don’t often have many windows open at once, but when I do, +=ace-window= is really nice to jump around them in the same way that +=ace-jump= or =avy= work. +#+BEGIN_SRC emacs-lisp +(use-package ace-window + :bind (("s-s" . ace-window)) + :config (progn + (setq aw-dispatch-always t + aw-dispatch-alist '((?k aw-delete-window " Ace - Delete Window") + (?K aw-delete-window) + (?m aw-swap-window " Ace - Swap Window") + (?f aw-flip-window) + (?v aw-split-window-vert " Ace - Split Vert Window") + (?b aw-split-window-horz " Ace - Split Horz Window") + (?m delete-other-windows " Ace - Maximize Window") + (?l delete-other-windows) + (?, winner-undo) + (?. winner-redo)) + aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o)))) +#+END_SRC + +* Windows + +Scrolling is tricky. I use this setup to help me keep track of the +point whilst I’m moving about. + +#+BEGIN_SRC emacs-lisp +(setq scroll-conservatively 100 + scroll-margin 1 + scroll-preserve-screen-position t + mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control))) + split-height-threshold 80 + split-width-threshold 160 + frame-resize-pixelwise nil) +(if (boundp 'ns-pop-up-frames) + (setq ns-pop-up-frames nil)) +#+END_SRC + +** winner + +Undo, for window-based commands. + +#+BEGIN_SRC emacs-lisp +(use-package winner + :config (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*")) + :init (progn + (winner-mode 1))) +#+END_SRC + +** windmove + +Directional window movement + +#+BEGIN_SRC emacs-lisp +(use-package windmove + :bind (("S-<left>" . windmove-left) + ("S-<right>" . windmove-right) + ("S-<up>" . windmove-up) + ("S-<down>" . windmove-down))) +#+END_SRC +* Completion + +Make built-in completion a bit more intelligent, by adding substring +and initial-based completion and ignoring case. + +#+BEGIN_SRC emacs-lisp +(setq completion-styles '(basic initials partial-completion substring) + completion-ignore-case t + tab-always-indent 'complete) +#+END_SRC + +** Company + +The main choices for automatic completion in Emacs are company and +auto-complete-mode. I’ve not tried auto-complete-mode as company +seems to work perfectly well for me. + +#+BEGIN_SRC emacs-lisp +(use-package company + :commands (company-mode) + :diminish "Cmpl" + :bind (("C-<tab>" . company-complete) + ("TAB" . company-indent-or-complete-common)) + :init (progn + (add-hook 'prog-mode-hook #'company-mode) + (setq company-backends '(company-bbdb company-web-html company-tern company-nxml company-css company-eclim company-semantic company-elisp + company-clang company-xcode company-cmake company-capf + company-files (company-gtags + company-etags company-keywords) company-oddmuse) + company-frontends '(company-pseudo-tooltip-unless-just-one-frontend + company-preview-frontend + company-echo-metadata-frontend) + company-idle-delay .3 + company-begin-commands '(self-insert-command) + company-auto-complete #'company-explicit-action-p + company-auto-complete-chars '(?\ ?\( ?\) ?.) + company-tooltip-align-annotations t))) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(use-package company-web + :after company) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(use-package company-nixos-options + :if (eq system-type 'gnu/linux) + :config (progn + (add-to-list 'company-backends 'company-nixos-options))) +#+END_SRC + +* Dates & Times + +** Calendar + +Weeks start on Monday for me and I prefer ISO-style dates. +#+BEGIN_SRC emacs-lisp +(use-package calendar + :defer 1 + :config (progn + (setq calendar-week-start-day 1) + (calendar-set-date-style 'iso))) +#+END_SRC + +Sometimes I want to insert a date or time into a buffer. +#+BEGIN_SRC emacs-lisp +(defun insert-date (prefix) + "Insert the current date. With prefix-argument, use British format. With + two prefix arguments, write out the day and month name." + (interactive "P") + (let ((format (cond + ((not prefix) "%Y-%m-%d") + ((equal prefix '(4)) "%d/%m/%Y") + ((equal prefix '(16)) "%A, %d %B %Y")))) + (insert (format-time-string format)))) + +(defun insert-datetime (prefix) + "Insert the current date and time." + (interactive "P") + (let ((format (cond + ((not prefix) "%Y-%m-%d %H:%M:%S") + ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ")))) + (insert (format-time-string format)))) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(defun yesterday-time () + "Provide the date/time 24 hours before the time now in the format of current-time." + (timer-relative-time (current-time) -86400)) +#+END_SRC + +* Directories + +Dired works quite nicely, but not always in the way I want. I don’t +like having so many prompts for recursive operations. Also, when I +have two dired windows open, assume that I’m going to be +copying/moving files between them. + +#+BEGIN_SRC emacs-lisp +(use-package dired + :defer 3 + :ensure nil + :config (progn + (bind-key "<return>" #'dired-find-file dired-mode-map) + (bind-key "^" (lambda () (interactive) (find-alternate-file "..")) dired-mode-map) + (setq dired-dwim-target t + dired-recursive-copies 'top + dired-recursive-deletes 'top + dired-listing-switches "-alh") + (when (and (eq system-type 'darwin) (executable-find "gls")) + (setq insert-directory-program (executable-find "gls"))) + (put 'dired-find-alternate-file 'disabled nil))) +#+END_SRC + +Don’t show uninteresting files in dired listings. + +#+BEGIN_SRC emacs-lisp +(defun turn-on-dired-omit-mode () + (interactive) + (dired-omit-mode 1)) + +(use-package dired-x + :commands (dired-omit-mode + dired-expunge) + :ensure nil + :config (progn + (setq dired-omit-files "#\\|\\.$" + dired-omit-verbose nil + dired-find-subdir t + dired-bind-jump nil)) + :init (progn + (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode))) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(use-package dired+ + :defer 5 + :config (progn + (diredp-toggle-find-file-reuse-dir 1) + (unbind-key "C-h C-m" dired-mode-map))) +#+END_SRC + +Expand subfolders like a tree inside the parent + +#+BEGIN_SRC emacs-lisp +(with-eval-after-load 'dired + (use-package dired-subtree + :functions (dired-subtree--get-ov + dired-subtree-maybe-up) + :init (progn + (setq dired-subtree-use-backgrounds nil) + (defun dired-subtree-maybe-up () + "Jump up one subtree or directory" + (interactive) + (let ((ov (dired-subtree--get-ov))) + (if ov + (progn (goto-char (overlay-start ov)) + (dired-previous-line 1)) + (dired-up-directory)))) + (bind-key "^" #'dired-subtree-maybe-up dired-mode-map) + (bind-key "i" #'dired-subtree-toggle dired-mode-map)))) +#+END_SRC + +** Dired-narrow +One can already use dired with wildcards to browse a filtered +directory listing, but it opens a new buffer. Dired-narrow is a +slightly nicer interface: with a currently-open dired buffer, use =/= +to start filtering, =RET= to complete the filter and =g= to refresh +the buffer, removing the filter. + +#+BEGIN_SRC emacs-lisp +(with-eval-after-load 'dired + (use-package dired-narrow + :bind (:map dired-mode-map + ("/" . dired-narrow)))) +#+END_SRC + +* Documentation + +** ehelp + +ehelp is a less well-known package that’s part of Emacs and slightly +improves the normal help commands, mostly by making quitting them easier. + +#+BEGIN_SRC emacs-lisp +(use-package ehelp + :bind-keymap ("C-h" . ehelp-map)) +#+END_SRC +** counsel-dash + +Emacs’ documentation is great to read from inside Emacs. Counsel-dash +helps to make documentation for other languages easier to access + +#+BEGIN_SRC emacs-lisp +(defmacro ap/create-counsel-dash-hook (mode docsets) + (let* ((mode-s (symbol-name mode)) + (fun (intern (concat "counsel-dash-hook-" mode-s))) + (hook (intern (concat mode-s "-mode-hook")))) + `(progn + (defun ,fun () + (when (require 'counsel-dash nil :noerror) + (-each (-difference ',docsets + (helm-dash-installed-docsets)) + #'counsel-dash-install-docset) + (setq-local counsel-dash-docsets ',docsets))) + (add-hook (quote ,hook) (function ,fun))))) + +(use-package counsel-dash + :defer 20 + :defines counsel-dash-docsets + :config (progn + (setq counsel-dash-browser-func #'eww) + (ap/create-counsel-dash-hook nginx ("Nginx")) + (ap/create-counsel-dash-hook ansible ("Ansible")) + (ap/create-counsel-dash-hook php ("PHP" "Symfony")) + (ap/create-counsel-dash-hook twig ("Twig")) + (ap/create-counsel-dash-hook js2 ("JavaScript" "NodeJS" "jQuery" "Express" "SailsJS" "Lo-Dash")) + (ap/create-counsel-dash-hook markdown ("Markdown")) + (ap/create-counsel-dash-hook saltstack ("SaltStack")) + (ap/create-counsel-dash-hook clojure ("Clojure")) + (ap/create-counsel-dash-hook sql ("PostgreSQL" "MySQL")))) +#+END_SRC + +** discover-my-major + +A nicer way to browse keybindings for major modes. + +#+BEGIN_SRC emacs-lisp +(use-package discover-my-major + :bind ("<f1>" . discover-my-major)) +#+END_SRC + +** which-key + +Popup keybindings following a prefix automatically. + +#+BEGIN_SRC emacs-lisp +(use-package which-key + :diminish which-key-mode + :config (progn + (which-key-mode 1) + (which-key-setup-side-window-right-bottom))) +#+END_SRC + +** eldoc + +Documentation in the echo-area (where the minibuffer is displayed) is +rather useful. + +#+BEGIN_SRC emacs-lisp +(use-package eldoc + :commands (eldoc-mode) + :diminish eldoc-mode + :config (progn + (setq eldoc-idle-delay 0.1) + (eldoc-add-command 'paredit-backward-delete 'paredit-close-round))) +#+END_SRC +* Misc + +#+BEGIN_SRC emacs-lisp +(defvar *init-file* + (let ((init-file (or user-init-file + (expand-file-name "init.el" user-emacs-directory)))) + (expand-file-name "init.el" + (file-name-directory (file-truename init-file)))) + "Where the emacs init file really is, passing through symlinks.") +(set-register ?e `(file . ,*init-file*)) + +(defun ap/remove-extra-cr () + "Remove extraneous CR codes from a file" + (interactive) + (save-excursion + (goto-char (point-min)) + (while (search-forward " + " nil t) + (replace-match "")))) + +(use-package rect + :ensure nil + :init (defun copy-rectangle (start end) + "Copy the region-rectangle." + (interactive "r") + (setq killed-rectangle (extract-rectangle start end)))) + +(defun shell-execute (to-current-buffer) + (interactive "P") + (let ((file-buffer (if (buffer-file-name) + (file-name-nondirectory (buffer-file-name)) + "")) + (command (read-shell-command "Shell command: " nil nil nil))) + (shell-command (replace-regexp-in-string "%" file-buffer command) to-current-buffer))) + +(defun process-exit-code (program &rest args) + "Run PROGRAM with ARGS and return the exit code" + (apply 'call-process program nil nil nil args)) + +(defun narrow-to-region-indirect (start end) + "Restrict editing in this buffer to the current region, indirectly." + (interactive "r") + (deactivate-mark) + (let ((buf (clone-indirect-buffer nil nil))) + (with-current-buffer buf + (narrow-to-region start end)) + (switch-to-buffer buf))) + +(bind-key* "M-!" #'shell-execute) +(bind-key* "C-x r M-w" #'copy-rectangle) +#+END_SRC + +** Auxillary Configuration + +#+BEGIN_SRC emacs-lisp +(require 'pinentry) + +(defvar have-private-key + (file-exists-p (expand-file-name "secring.gpg" "~/.gnupg/"))) + +(defvar gpg-agent-ssh-sock + (or (getenv "GPG_AGENT_INFO") + (concat "/run/user/" (number-to-string (user-uid)) "/gnupg/S.gpg-agent.ssh"))) + +(defun read-gpg-file (file) + (let ((file-to-decrypt (expand-file-name file user-emacs-directory)) + (ctx (epg-make-context epa-protocol))) + (if (file-exists-p file-to-decrypt) + (epg-decrypt-file ctx file-to-decrypt nil) + (message "Decrypting %s...failed" file-to-decrypt) + (error "File %s does not exist" file-to-decrypt)))) + +(defun load-gpg (file) + (if have-private-key + (load file) + (message "WARNING: Couldn't load %s (No gpg key found)" file))) + +; load this in a post-frame hook because gpg-agent asks for a password on first +; startup and caches it. Don't want emacs daemon to hang because of gpg-agent. +(defun load-private-data () + (interactive) + (if (not have-private-key) + (message "ERROR: Private GPG key not found") + (unless (or (getenv "GPG_AGENT_INFO") + (getenv "SSH_AUTH_SOCK")) + (start-process "gpg-agent" nil "gpg-agent" "--daemon") + (setenv "SSH_AUTH_SOCK" gpg-agent-ssh-sock)) + (setq password-cache-expiry nil) + (unless (file-exists-p (concat pinentry--socket-dir "pinentry")) + (pinentry-start) + (add-hook 'kill-emacs-hook 'pinentry-stop)) + (add-to-list 'load-suffixes ".el.gpg") + (load-gpg (expand-file-name "private" user-emacs-directory)))) + +(defun first-frame-hook (frame) + (remove-hook 'after-make-frame-functions #'first-frame-hook) + (run-at-time nil nil 'load-private-data)) + +(if (eq 1 (length (frame-list))) + (add-hook 'after-init-hook #'load-private-data) + (add-hook 'after-make-frame-functions #'first-frame-hook)) +#+END_SRC + +* Minibuffer + +Sometimes I want to use the minibuffer, but I’m already inside it. +Fortunately, this is possible. Of course, I need to know how many +minibuffers there are on the stack. + +#+BEGIN_SRC emacs-lisp +(setq enable-recursive-minibuffers t) +(minibuffer-depth-indicate-mode t) +#+END_SRC + +This avoids some issue with the minibuffer and the point being behind +the prompt. I don’t remember what exactly. +#+BEGIN_SRC emacs-lisp +(setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt)) +#+END_SRC + +Occasionally, I exit emacs. I should probably reduce the frequency of this. +#+BEGIN_SRC emacs-lisp +(if (daemonp) + (defalias 'exit-emacs #'delete-frame) + (defalias 'exit-emacs #'save-buffers-kill-emacs)) +#+END_SRC + +** swiper/ivy + +Ivy is the new kid on the completion block. It seems to be a strong +replacement for helm so far. + +#+BEGIN_SRC emacs-lisp +(use-package swiper + :bind (("C-s" . swiper) + ("C-r" . swiper) + ("C-x i" . ivy-imenu-goto) + ("C-=" . swiper)) + :diminish ivy-mode + :demand t + :config (progn + (ivy-mode 1) + (setq ivy-re-builders-alist '((internal-complete-buffer . ivy--regex-fuzzy) + (t . ivy--regex-plus))) + (defun ivy-imenu-get-candidates-from (alist &optional prefix) + (cl-loop for elm in alist + nconc (if (imenu--subalist-p elm) + (ivy-imenu-get-candidates-from + (cl-loop for (e . v) in (cdr elm) collect + (cons e (if (integerp v) (copy-marker v) v))) + (concat prefix (if prefix ".") (car elm))) + (and (cdr elm) ; bug in imenu, should not be needed. + (setcdr elm (copy-marker (cdr elm))) ; Same as [1]. + (list (cons (concat prefix (if prefix ".") (car elm)) + (copy-marker (cdr elm)))))))) + + (defun ivy-imenu-goto () + "Go to buffer position" + (interactive) + (let ((imenu-auto-rescan t) items) + (unless (featurep 'imenu) + (require 'imenu nil t)) + (setq items (imenu--make-index-alist t)) + (ivy-read "imenu items:" + (ivy-imenu-get-candidates-from (delete (assoc "*Rescan*" items) items)) + :action (lambda (k) (goto-char k))))) + (ivy-set-actions 'ivy-switch-buffer '(("k" (lambda (x) + (kill-buffer x) + (ivy--reset-state ivy-last)) + "kill"))) + (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . "")))) +#+END_SRC + +** counsel + +#+BEGIN_SRC emacs-lisp +(use-package counsel + :config (progn + (bind-key "M-x" #'counsel-M-x) + (bind-key "<apps>" #'counsel-M-x) + (bind-key "<menu>" #'counsel-M-x) + (bind-key "C-c M-x" #'execute-extended-command) + (bind-key "C-x C-f" #'counsel-find-file) + (bind-key "M-y" #'counsel-yank-pop) + (bind-key "M-y" #'ivy-next-line ivy-minibuffer-map) + (defadvice counsel-find-file (after find-file-sudo activate) + "Find file as root if necessary." + (when (and buffer-file-name + (not (file-writable-p buffer-file-name))) + (message "File not writable %s" buffer-file-name) + (find-alternate-file (concat "/sudo::" buffer-file-name)))))) +#+END_SRC + + +** smex + +Smex is my favourite way to use =M-x=. Counsel’s =counsel-M-x= +function uses it internally, so I’m keeping it around, even though I +don’t use it directly. + +#+BEGIN_SRC emacs-lisp +(use-package smex + :commands (smex + smex-update + smex-initialize) + :config (progn + (setq smex-key-advice-ignore-menu-bar t + smex-auto-update nil) + (defun smex-update-after-load (_unused) + (if (boundp 'smex-cache) + (smex-update))) + (add-hook 'after-load-functions 'smex-update-after-load)) + :init (progn + (setq smex-history-length 100 + smex-save-file (concat user-emacs-directory + "smex-items")))) +#+END_SRC + +** cmd-to-echo + +I’ve been looking for some way to run programming projects (mostly +node.js) inside emacs. =cmd-to-echo= seems great for this, as new +output pops up in the echo area. + +#+BEGIN_SRC emacs-lisp +(use-package cmd-to-echo + :commands (cmd-to-echo) + :config (setq cmd-to-echo-add-output-to-process-buffers t)) +#+END_SRC +* Modes + +Setup some modes for systemd files +#+BEGIN_SRC emacs-lisp +(add-to-list 'auto-mode-alist '("\\.service\\'" . conf-mode)) +(add-to-list 'auto-mode-alist '("\\.target\\'" . conf-mode)) +(add-to-list 'auto-mode-alist '("\\.socket\\'" . conf-mode)) +#+END_SRC + +=direnv=’s files are basically shell scripts, it’s a nice way to +set environment variables for projects. +#+BEGIN_SRC emacs-lisp +(add-to-list 'auto-mode-alist '("\\.envrc\\'" . sh-mode)) +#+END_SRC + +Some modes that I don’t really customise much, mostly for +configuration files. +#+BEGIN_SRC emacs-lisp +(use-package xrdb-mode + :ensure nil + :mode (("\\.Xdefaults\\'" . xrdb-mode) + ("\\.Xresources\\'" . xrdb-mode))) + +(use-package haskell-mode + :mode (("\\.hs\\'" . haskell-mode))) + +(use-package dockerfile-mode + :mode (("Dockerfile\\'" . dockerfile-mode))) + +(use-package nix-mode + :mode (("\\.nix\\'" . nix-mode))) + +(define-derived-mode xmonad-mode haskell-mode "XM") +(add-to-list 'auto-mode-alist '("xmobarrc\\'" . xmonad-mode)) +(add-to-list 'auto-mode-alist '("xmonad.hs\\'" . xmonad-mode)) + +(use-package nginx-mode + :defer t + :mode (("/nginx/servers/" . nginx-mode) + ("/nginx/.*\\.d/" . nginx-mode))) + +(use-package lua-mode + :defer t) + +(use-package ruby-mode + :mode (("\\.rb\\'" . ruby-mode) + ("\\.cap\\'" . ruby-mode))) + +(use-package go-mode + :mode (("\\.go\\'" . go-mode))) + +(use-package jinja2-mode + :mode (("\\.j2\\'" . jinja2-mode) + ("\\.jinja\\'" . jinja2-mode))) + +(use-package scss-mode + :defer t + :config (progn + (setq scss-compile-at-save nil))) + +(use-package yaml-mode + :mode (("/group_vars/.*" . yaml-mode) + ("/host_vars/.*" . yaml-mode))) + +(define-derived-mode ansible-mode yaml-mode "Ansible") +(add-to-list 'auto-mode-alist '("\\(?:ansible.+\\|roles/.+/\\(?:tasks\\|handlers\\)\\)/.+\\.yml\\'" . ansible-mode)) + +(define-derived-mode saltstack-mode yaml-mode "Salt") +(add-to-list 'auto-mode-alist '("\\.sls\\'" . saltstack-mode)) +#+END_SRC + +** ledger + +I use [[http://ledger-cli.org/][=ledger=]] to manage my finances. It has an Emacs mode, which +works really nicely. + +#+BEGIN_SRC emacs-lisp +(use-package ledger-mode + :mode ("\\.ledger\\'" . ledger-mode) + :init (progn + (defun open-budget () + (interactive) + (projectile-switch-project-by-name "~/Sync/Default") + (find-file (expand-file-name "ledger/my.ledger" (projectile-project-root))) + (ledger-report "Budget (Cumulative)" nil))) + :config (progn + (setq ledger-use-iso-dates t + ledger-post-use-completion-engine :built-in + ledger-reconcile-default-commodity "€" + ledger-clear-whole-transactions t + ledger-narrow-on-reconcile t + ledger-default-date-format "%Y-%m-%d" + ledger-reports '(("Monthly Expenses" "ledger -f %(ledger-file) reg -M Expenses --real -l \"payee != 'Opening Balances'\"") + ("Expenses:This Month" "ledger -f %(ledger-file) bal \\^Expenses -p \"this month\"") + ("On-budget Balances" "ledger -f %(ledger-file) bal --current -R :Budget: Assets:Receivable Liabilities:Personal") + ("All Account Balances" "ledger -f %(ledger-file) bal --current -R \\^Assets \\^Liabilities") + ("Budget Values (Current Month)" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds") + ("Budget (Cumulative)" "ledger -f %(ledger-file) bal -E \\^Funds \\^Assets:Budget$") + ("Budget Allocation" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds --format \"\\ + %-17((depth_spacer)+(partial_account))\\ + %10(percent(market(display_total), market(parent.total)))\\ + %16(market(display_total))\n%/\"") + ("bal" "ledger -f %(ledger-file) bal") + ("reg" "ledger -f %(ledger-file) reg") + ("equity" "ledger -f %(ledger-file) equity") + ("payee" "ledger -f %(ledger-file) reg @%(payee)") + ("account" "ledger -f %(ledger-file) reg %(account)"))))) +#+END_SRC + +** Markdown + +#+BEGIN_SRC emacs-lisp +(use-package markdown-mode + :defer t + :config (progn + (add-hook 'markdown-mode-hook #'turn-on-auto-fill))) +#+END_SRC + +** Org + +Org is wünderbar. + +#+BEGIN_SRC emacs-lisp +(use-package org + :bind (("C-c C-a" . org-agenda-list) + ("C-c a" . org-agenda) + ("C-c l" . org-store-link)) + :defer 8 + :init (setq org-replace-disputed-keys t + org-ellipsis "…") + :config (progn + (setq org-directory "~/Sync/org" + org-agenda-files `(,(concat org-directory "/agenda")) + + org-default-notes-file (concat org-directory "/notes") + + ;; ‘Remember’: new items at top + org-reverse-note-order t + + org-modules '(org-protocol) + + ;; Add time done to ‘done’ tasks + org-log-done 'time + + org-list-allow-alphabetical t + + org-adapt-indentation nil + + org-pretty-entities t + + org-table-duration-custom-format 'seconds + + org-src-fontify-natively nil + + org-export-have-math t + + org-blank-before-new-entry '((heading . t) + (plain-list-item . auto)) + org-fontify-done-headline t + + org-todo-keywords '((sequence "BACKLOG(b)" "TODO(t)" "WAIT(w@/!)" "STARTED(s!)" "|" "DONE(d!)") + (sequence "|" "CANCELLED(c@)")) + org-log-into-drawer "LOGBOOK") + (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory))) + (add-hook 'org-mode-hook #'turn-on-auto-fill) + (org-load-modules-maybe t))) +#+END_SRC + +**** org-babel + +Org’s babel feature is really nice. I use it for this file, and I can +use it to communicate between programming languages. Sometime I hope +to have my =ledger= setup in an org file with some graph processing +with R or something. + +#+BEGIN_SRC emacs-lisp +(use-package ob-core + :defer t + :ensure nil + :config (progn + (org-babel-do-load-languages 'org-babel-load-languages + '((ledger . t) + (sh . t))) + (setq org-src-tab-acts-natively t + org-edit-src-content-indentation 0 + org-src-preserve-indentation t))) +#+END_SRC + +**** org-journal + +I can use this to keep a journal. I should use it. + +#+BEGIN_SRC emacs-lisp +(use-package org-journal + :bind ("s-j" . org-journal-new-entry) + :defer 20 + :config (progn + (setq org-journal-date-format "%A, %d %B %Y") + (defun org-journal-display-entry-yesterday () + "Show org-journal entry for yesterday" + (interactive) + (org-journal-read-or-display-entry (yesterday-time))))) +#+END_SRC + +**** org-mobile + +#+BEGIN_SRC emacs-lisp +(defun ap/org-mobile-pull (descriptor action file) + (org-mobile-pull)) +(use-package org-mobile + :defer 30 + :ensure nil + :disabled t + :config (progn + (setq org-mobile-directory "~/Mobile/Org" + org-mobile-inbox-for-pull "~/Mobile/Org/from-mobile.org") + (defvar org-mobile-push-timer nil + "Timer that `org-mobile-push-timer' used to reschedule itself, or nil.") + + (defun org-mobile-push-with-delay (secs) + (when org-mobile-push-timer + (cancel-timer org-mobile-push-timer)) + (setq org-mobile-push-timer + (run-with-idle-timer + (* 1 secs) nil 'org-mobile-push))) + + (add-hook 'after-save-hook + (lambda () + (when (eq major-mode 'org-mode) + (dolist (file (org-mobile-files-alist)) + (if (string= (file-truename (expand-file-name (car file))) + (file-truename (buffer-file-name))) + (org-mobile-push-with-delay 30)))))) + + (run-at-time "00:05" 86400 '(lambda () (org-mobile-push-with-delay 1))) ;; refreshes agenda file each day + (org-mobile-pull) ;; run org-mobile-pull at startup + + (defvar org-mobile-watcher nil) + (when file-notify--library + (let ((org-file (expand-file-name + (concat + (file-name-as-directory org-mobile-directory) + org-mobile-capture-file)))) + (setq org-mobile-watcher + (file-notify-add-watch org-file '(change) #'ap/org-mobile-pull)))))) +#+END_SRC + +**** org-caldav + +I’ve setup CalDAV on my server, it would be nice to use it directly +from org-mode. Previously I had to wait for org-mobile to sync and +write to the Android calendar, and then for DAVDroid to sync with the server. + +#+BEGIN_SRC emacs-lisp +(use-package org-caldav + :defer 30 + :config (progn + (setq org-caldav-url "https://calendar.alanpearce.uk/alan" + org-caldav-calendar-id "caldav" + org-caldav-inbox (concat org-directory "/agenda/caldav.org") + org-caldav-files `(,(concat org-directory "/agenda/organiser.org")) + org-icalendar-timezone "Europe/Berlin" + org-icalendar-use-scheduled '(event-if-todo event-if-not-todo todo-start) + org-icalendar-use-deadline '(event-if-todo event-if-not-todo todo-due) + org-icalendar-alarm-time 60))) +#+END_SRC + +**** org-page + +I would like to convert my website from using hugo to something else +that I can work with nicely from inside Emacs. I wonder if org-page +will do the trick. + +#+BEGIN_SRC emacs-lisp +(use-package org-page + :config (progn + (setq op/site-domain "https://alanpearce.uk/" + op/repository-directory "~/projects/alanpearce/" + op/personal-github-link "https://github.com/alanpearce"))) +#+END_SRC + +* Music +Emacs actually supports playing music via mpd. + +#+BEGIN_SRC emacs-lisp +(use-package mpc + :defer t + :config (progn + (setq mpc-browser-tags '(Genre Albumartist|Composer|Performer Album|Playlist)))) +#+END_SRC +* Programming +** flycheck + +On-the-fly error checking in programming modes? Yes please. + +#+BEGIN_SRC emacs-lisp +(use-package flycheck + :diminish " ✓" + :defer 5 + :config (progn + (global-flycheck-mode) + (setq flycheck-check-syntax-automatically '(save new-line mode-enabled)) + (if (executable-find "eslint_d") + (setq flycheck-javascript-eslint-executable (executable-find "eslint_d"))))) +#+END_SRC + +** golang + +Go has a few packages to inter-operate with other emacs packages. + +#+BEGIN_SRC emacs-lisp +(use-package company-go + :commands company-go + :config (progn + (setq company-go-show-annotation t)) + :init (progn + (defun ap/company-go-setup () + (set (make-local-variable 'company-backends) + '(company-go))) + (add-hook 'go-mode-hook #'ap/company-go-setup))) + +(use-package go-eldoc + :commands go-eldoc-setup + :init (progn + (add-hook 'go-mode-hook #'go-eldoc-setup))) + +(use-package go-projectile + :defer t + :config (progn + (setq go-projectile-switch-gopath 'maybe))) + + +#+END_SRC + +** ggtags + +A nice completion backend for programming modes. + +#+BEGIN_SRC emacs-lisp +(use-package ggtags + :disabled t + :commands turn-on-ggtags-mode + :functions (ggtags-navigation-mode-abort) + :config (progn + (bind-key "q" #'ggtags-navigation-mode-abort ggtags-navigation-mode-map)) + :init (progn + (defun turn-on-ggtags-mode () + (interactive) + (ggtags-mode 1)) + (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode))) +#+END_SRC + +** Lisps + +*** All + +Lisp modes don’t seem to have a common ancestor. So I made a custom +hook which I trigger in every lispy-mode. + +#+BEGIN_SRC emacs-lisp +(defcustom lisp-mode-common-hook nil + "Hook run when entering any Lisp mode." + :type 'hook + :group 'lisp) + +(defun ap/lisp-setup () + (run-hooks 'lisp-mode-common-hook)) +#+END_SRC + +**** Redshank + +Lisp syntax allows for really easy refactoring. Redshank gives some +operations that aren’t part of paredit, like extracting variables into +let bindings. +#+BEGIN_SRC emacs-lisp +(use-package redshank + :diminish " Λ" + :after (paredit) + :config (progn + (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode))) +#+END_SRC + +*** Emacs Lisp + +Customise the modeline-display of =emacs-lisp-mode=. Then make sure +it runs the common lisp hooks. + +#+BEGIN_SRC emacs-lisp +(add-hook 'emacs-lisp-mode-hook #'ap/lisp-setup) +(add-hook 'emacs-lisp-mode-hook #'eldoc-mode) +#+END_SRC + +Go-to function for elisp. Except it works through the entire Emacs ecosystem. + +#+BEGIN_SRC emacs-lisp +(use-package elisp-slime-nav + :commands elisp-slime-nav-mode + :diminish elisp-slime-nav-mode + :init (progn + (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode))) +#+END_SRC + +Interactive elisp + +#+BEGIN_SRC emacs-lisp +(use-package ielm + :defer t + :ensure nil + :config (progn + (add-hook 'ielm-mode-hook (lambda () + (run-hooks 'lisp-mode-common-hook))))) +#+END_SRC + +*** Scheme & Lisp + +I don’t work with these as often as I would like + +#+BEGIN_SRC emacs-lisp +(add-hook 'scheme-mode-hook #'ap/lisp-setup) +(add-hook 'lisp-mode-hook #'ap/lisp-setup) +(defun set-common-lisp-indentation () + (set (make-local-variable 'lisp-indent-function) + #'common-lisp-indent-function)) +(add-hook 'lisp-mode-hook #'set-common-lisp-indentation) +#+END_SRC + +**** geiser + +A REPL thing for Scheme. Hopefully I’ll get to use it more in the +future. + +#+BEGIN_SRC emacs-lisp +(use-package geiser + :commands (geiser-mode + geiser + run-geiser + run-racket)) +#+END_SRC + +**** slime + +A REPL thing (and more) for Lisp. + +#+BEGIN_SRC emacs-lisp +(use-package slime + :commands (slime) + :config (progn + (let ((ql-slime-helper (expand-file-name "~/quicklisp/slime-helper.el"))) + (if (file-exists-p ql-slime-helper) + (load ql-slime-helper)) + (slime-setup)) + (setq inferior-lisp-program (executable-find "sbcl")))) +#+END_SRC + +*** Clojure + +#+BEGIN_SRC emacs-lisp +(use-package clojure-mode + :defer t + :init (progn + (add-hook 'cider-repl-mode-hook (lambda () (highlight-changes-mode -1))) + (add-hook 'clojure-mode-hook #'ap/lisp-setup))) + +(use-package clj-refactor + :defer t + :functions (clj-refactor-mode cljr-add-keybindings-with-prefix) + :config (progn + (cljr-add-keybindings-with-prefix "C-c C-m")) + :init (progn + (defun turn-on-clj-refactor-mode () + (clj-refactor-mode 1)) + (add-hook 'clojure-mode-hook #'turn-on-clj-refactor-mode))) +#+END_SRC + +**** cider + +A REPL thing for Clojure + +#+BEGIN_SRC emacs-lisp +(use-package cider + :defer t + :config (progn + (setq nrepl-hide-special-buffers t) + (unbind-key "C-c C-f" cider-mode-map) + (add-hook 'cider-mode-hook #'eldoc-mode))) +#+END_SRC + +** Auto-compile + +Auto-compile emacs lisp when saving. +#+BEGIN_SRC emacs-lisp +(use-package auto-compile + :defer t + :init (add-hook 'emacs-lisp-mode-hook #'auto-compile-on-save-mode)) +#+END_SRC + +** cc-mode + +Although I don’t use C or C++, setting up the mode is helpful because +quite a few other modes are derived from it. + +#+BEGIN_SRC emacs-lisp +(use-package cc-mode + :defer 5 + :init (progn + (add-hook 'c-mode-common-hook #'electric-indent-mode)) + :config (progn + (setq c-default-style '((java-mode . "java") + (awk-mode . "awk") + (other . "k&r")) + c-basic-offset 4) + (c-set-offset 'case-label '+))) +#+END_SRC + +** quickrun + +It’s nice to be able to quickly evaluate some code. Although I don’t +really seem to use it. +#+BEGIN_SRC emacs-lisp +(use-package quickrun + :bind (("C-c C-e" . quickrun))) +#+END_SRC + +** Scala + +Let’s try using Scala. + +#+BEGIN_SRC emacs-lisp +(use-package scala-mode + :pin melpa-stable) +#+END_SRC + +And add ensime, an IDE-style environment. + +#+BEGIN_SRC emacs-lisp +(use-package ensime + :pin melpa-stable) +#+END_SRC + +** Web development + +*** js2-mode + +This mode is really great for editing Javascript. It turns code into +an AST internally, so it can work with it almost like a lisp. I don’t +think there’s anything as good as paredit/redshank for refactoring in +it though + +#+BEGIN_SRC emacs-lisp +(use-package js2-mode + :mode (("\\.js\\'" . js2-mode) + ("\\.jsx\\'" . js2-jsx-mode)) + :interpreter ("node" . js2-mode) + :functions js2-next-error + :config (progn + (define-key js2-mode-map [menu-bar Javascript] nil) + (defun js2--imenu-around (do-it name) + "Don't create a menu from js2-mode" + (if (and (not (string-equal name "IM-Javascript-IDE")) + (fboundp #'do-it)) + (do-it name))) + (advice-add 'imenu-add-to-menubar :around #'js2--imenu-around) + (defun ap/js2-prev-error () + (interactive) + (js2-next-error -1)) + (bind-key "M-g M-n" #'js2-next-error js2-mode-map) + (bind-key "M-g M-p" #'ap/js2-prev-error js2-mode-map) + (setq js2-basic-offset 2 + js2-include-node-externs t))) +#+END_SRC + +**** jade (not pug) + +Javascript with an inferior node.js process and a debugger? Awesome. + +To debug with node, use version 6.9.1 or later of node and run it with +~--inspect~ and, to break on the first line, ~--debug-brk~. + +For Chrom*, it needs to be launched with ~--remote-debugging-port=9222~ + +#+BEGIN_SRC emacs-lisp +(use-package jade + :config (progn + (add-hook 'js2-mode-hook #'jade-interaction-mode))) +#+END_SRC + +*** coffee-mode + +#+BEGIN_SRC emacs-lisp +(use-package coffee-mode + :mode ("\\.coffee\\'" . coffee-mode) + :config (progn + (setq coffee-indent-like-python-mode t))) +#+END_SRC + +*** tern + +Tern understands javascript. It adds really clever documented +completions, besides other IDE-like things. + +#+BEGIN_SRC emacs-lisp +(use-package tern + :commands ap/enable-tern + :if (executable-find "tern") + :defer 5 + :config (progn + (setq tern-command (list (executable-find "tern"))) + (defun ap/enable-tern () + (tern-mode 1)) + (add-hook 'js2-mode-hook #'ap/enable-tern) + (add-hook 'web-mode-hook #'ap/enable-tern))) + +(with-eval-after-load 'tern + (use-package company-tern)) +#+END_SRC + +*** json-mode + +#+BEGIN_SRC emacs-lisp +(use-package json-mode + :mode (("\\.json\\'" . json-mode) + ("\\.sailsrc\\'" . json-mode) + ("composer\\.lock\\'" . json-mode) + ("\\.tern-project\\'" . json-mode))) +#+END_SRC + +*** restclient + +Restclient is really nice. It’s like a scratchpad for HTTP api +calls. Feels a bit like using =org-babel=. I wonder if there’s an +integration between the two yet. + +#+BEGIN_SRC emacs-lisp +(use-package restclient + :mode ("\\.api\\'" . restclient-mode) + :config (progn + (defun imenu-restclient-sections () + (setq imenu-prev-index-position-function nil) + (add-to-list 'imenu-generic-expression '("Services" "^## ?\\(.+\\)$" 1) t) + (add-to-list 'imenu-generic-expression '("Calls" "^# ?\\(.+\\)$" 1) t)) + (add-hook 'restclient-mode-hook #'imenu-restclient-sections))) + +(use-package company-restclient + :after (company restclient) + :init (add-to-list 'company-backends #'company-restclient t)) +#+END_SRC + +*** sgml-mode + +This is for HTML, since old versions of HTML were derived from SGML. +#+BEGIN_SRC emacs-lisp +(use-package sgml-mode + :defer t + :config (setq sgml-basic-offset 2)) +#+END_SRC + +*** emmet-mode + +Emmet is really nice to write HTML quickly. Especially with +frameworks that require multiple nested elements to do anything useful. +#+BEGIN_SRC emacs-lisp +(use-package emmet-mode + :commands (emmet-mode) + :diminish (emmet-mode . " >") + :init (progn + (setq emmet-indentation 2) + (add-hook 'web-mode-hook #'emmet-mode))) +#+END_SRC + +*** web-mode + +This mode handles just about every templating language out ther, which +is really nice, because it handles the HTML part the same way in all +of them as well. + +#+BEGIN_SRC emacs-lisp +(use-package web-mode + :mode (("/views/.*\\.php\\'" . web-mode) + ("\\.html\\'" . web-mode) + ("/templates/.*\\.php\\'" . web-mode) + ("\\.ejs\\'" . web-mode)) + :config (progn + (setq web-mode-code-indent-offset 2 + web-mode-css-indent-offset 2 + web-mode-markup-indent-offset 2 + web-mode-style-padding 0 + web-mode-script-padding 0 + web-mode-comment-style 2 + web-mode-enable-auto-pairing nil + web-mode-enable-auto-quoting nil) + (sp-local-pair '(web-mode) "<%" "%>"))) +#+END_SRC + +I derived a mode for twig, in order to use its =mode-hook=. + +#+BEGIN_SRC emacs-lisp +(define-derived-mode twig-mode web-mode "Twig") +(add-to-list 'auto-mode-alist '("\\.html\\.twig\\'" . twig-mode)) +#+END_SRC + +* Spelling + +#+BEGIN_SRC emacs-lisp +(use-package ispell + :bind (("<f8>" . ispell-word)) + :config (progn + (cond + ((executable-find "aspell") (setq ispell-program-name "aspell" + ispell-dictionary "british" + ispell-really-aspell t + ispell-really-hunspell nil)) + ((executable-find "hunspell") (setq ispell-program-name "hunspell" + ispell-really-aspell nil + ispell-really-hunspell t))))) +#+END_SRC + +* Scripting + +Make a shell-script buffer executable after saving it, if it has a shebang. + +#+BEGIN_SRC emacs-lisp +(add-hook 'after-save-hook + #'executable-make-buffer-file-executable-if-script-p) + +(use-package sh-script + :mode (("\\.zsh\\'" . shell-script-mode) + ("zshenv\\'" . shell-script-mode) + ("zshrc\\'" . shell-script-mode)) + :config (setq sh-shell-file "/usr/bin/env zsh" + sh-indentation 2 + sh-basic-offset 2)) +#+END_SRC + +#+BEGIN_SRC emacs-lisp +(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on) +#+END_SRC + +** eshell + +I should try to get into the habit of using this more. It’s really +nice, when I remember to use it. + +#+BEGIN_SRC emacs-lisp +(use-package eshell + :bind ("C-c s" . eshell) + :config (progn + (setq eshell-directory-name "~/.emacs.d/eshell" + eshell-prompt-function (lambda () + (concat + (eshell/pwd) + "\n$ "))) + (add-hook 'eshell-load-hook (lambda () + (bind-key "C-c C-l" #'counsel-esh-history eshell-mode-map))))) + +(use-package em-smart + :ensure nil + :commands eshell-smart-initialize + :init (progn + (add-hook 'eshell-load-hook #'eshell-smart-initialize)) + :config (progn + (setq eshell-where-to-jump 'begin + eshell-review-quick-commands nil + eshell-smart-space-goes-to-end t))) + +(autoload #'eshell/cd "em-dirs") +(defun eshell-goto-current-dir (&optional arg) + (interactive "P") + (let ((dir default-directory)) + (eshell arg) + (eshell/cd dir))) +(bind-key "C-c S" #'eshell-goto-current-dir) + + +#+END_SRC + +*** Shells + +#+BEGIN_SRC emacs-lisp +(use-package shell + :defer t + :ensure nil + :config (define-key shell-mode-map + (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer)) + +(use-package comint + :defer t + :ensure nil + :config (bind-key "C-c C-l" #'counsel-shell-history comint-mode-map)) + +(defun comint-delchar-or-eof-or-kill-buffer (arg) + (interactive "p") + (if (null (get-buffer-process (current-buffer))) + (kill-buffer) + (comint-delchar-or-maybe-eof arg))) +#+END_SRC + +* Text editing + +Emacs has an editor within. + +#+BEGIN_SRC emacs-lisp +(put 'upcase-region 'disabled nil) +(put 'downcase-region 'disabled nil) +(setq sentence-end-double-space t + line-move-visual nil) +#+END_SRC + +** align + +=Align= is a useful command to line things up, once given some rules. +The most important one for me is JSON property alignment. + +#+BEGIN_SRC emacs-lisp +(use-package align + :defer 10 + :ensure nil + :config (progn + (add-to-list 'align-rules-list + '(colon-key-value + (regexp . ":\\(\\s-*\\)") + (modes . '(js2-mode)))))) +#+END_SRC + +** Clipboard + +I like to use the clipboard more than the primary selection in X11. + +#+BEGIN_SRC emacs-lisp +(setq x-select-enable-clipboard t + save-interprogram-paste-before-kill t) +(if (functionp 'x-cut-buffer-or-selection-value) + (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)) +(when (boundp 'x-select-request-type) + (setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING))) +#+END_SRC + +*** Copy formatted code + +#+BEGIN_SRC emacs-lisp +(bind-key* "C-c w" (define-prefix-command 'copy-as-map)) +(use-package copy-as-format + :bind (("C-c C-w" . copy-as-format) + :map copy-as-map + ("b" . copy-as-format-bitbucket) + ("g" . copy-as-format-github) + ("h" . copy-as-format-hipchat) + ("w" . copy-as-format-html) + ("j" . copy-as-format-jira) + ("m" . copy-as-format-markdown) + ("s" . copy-as-format-slack))) +#+END_SRC + +** + +** Selection + +I’m quite used to deleting text by selecting it and typing. Emacs has +a mode for that. + +#+BEGIN_SRC emacs-lisp +(delete-selection-mode t) +#+END_SRC + +Sub-word movement is really nice for camel- and Pascal-case + +#+BEGIN_SRC emacs-lisp +(use-package subword + :diminish subword-mode + :init (global-subword-mode t)) +#+END_SRC + +I find that =zap-up-to-char= normally makes more sense to me than +=zap-to-char=. + +#+BEGIN_SRC emacs-lisp +(use-package misc + :ensure nil + :bind (("M-z" . zap-up-to-char) + ("M-Z" . zap-to-char))) +#+END_SRC + +Expanding the region by semantic units was something I quite liked +from Sublime Text. As always, there’s a mode for that. + +#+BEGIN_SRC emacs-lisp +(use-package expand-region + :bind ("C-M-SPC" . er/expand-region) + :config (setq expand-region-fast-keys-enabled nil)) +#+END_SRC + +** avy + +Avy is a really nice way to move around files, like ace-jump-mode, but +somehow I prefer it. + +#+BEGIN_SRC emacs-lisp +(use-package avy + :bind* (("M-g g" . avy-goto-line) + ("M-g M-g" . avy-goto-line) + ("C-|" . avy-goto-line) + ("M-r" . avy-goto-word-1) + ("C-c SPC" . avy-goto-char-timer)) + :config (progn + (avy-setup-default) + (setq avy-all-windows nil + avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;)))) +#+END_SRC + +*** ace-link + +Visit any link. Despite the name, this works with avy. + +#+BEGIN_SRC emacs-lisp +(use-package ace-link + :after avy + :config (progn + (ace-link-setup-default) + (with-eval-after-load "gnus" + (bind-key "M-o" #'ace-link-gnus gnus-summary-mode-map) + (bind-key "M-o" #'ace-link-gnus gnus-article-mode-map)))) +#+END_SRC + +** goto-chg + +This is like popping the mark, only it filters to only change areas +and doesn’t go back to the same place more than once. + +#+BEGIN_SRC emacs-lisp +(use-package goto-chg + :bind ("C-c C-SPC" . goto-last-change)) +#+END_SRC + +** multiple-cursors + +I mentioned before that I’d used Sublime Text before. Multiple +cursors was one of my favourite features, so I was really happy when I +saw that multiple-cursors was released for Emacs. + +#+BEGIN_SRC emacs-lisp +(use-package multiple-cursors + :defer 1 + :config (progn + (bind-key "C-." #'mc/mark-next-like-this) + (bind-key "C-," #'mc/mark-previous-like-this) + (bind-key "M-<f3>" #'mc/mark-all-like-this-dwim) + (bind-key "C-<f3>" #'mc/mark-more-like-this-extended) + (bind-key "C-S-L" #'mc/edit-lines))) +#+END_SRC + +** paredit + +Balanced parentheses in lisps are nice, but all the refactoring and +movement commands are much more interesting. + +#+BEGIN_SRC emacs-lisp +(use-package paredit + :diminish "()" + :config (progn + (add-hook 'lisp-mode-common-hook #'enable-paredit-mode) + (put #'paredit-forward-delete 'delete-selection 'supersede) + (put #'paredit-backward-delete 'delete-selection 'supersede) + (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode))) +#+END_SRC + +** smartparens + +I like to use smartparens where paredit isn’t already useful. Somehow +I didn’t find smartparens’ implementation of paredit style to be as +nice as the real version + +#+BEGIN_SRC emacs-lisp +(eval-when-compile (require 'smartparens nil :noerror)) +(use-package smartparens-config + :ensure smartparens + :config (progn + (sp-use-smartparens-bindings) + (setq sp-highlight-pair-overlay nil) + (fset 'wrap-with-paren "\C-](") ;; `sp-select-next-thing-exchange' + (bind-key "C-(" #'wrap-with-paren smartparens-mode-map) + (bind-key "C-)" #'sp-forward-slurp-sexp smartparens-mode-map) + (bind-key "M-<backspace>" #'backward-kill-word smartparens-mode-map) + (bind-key "M-?" #'sp-convolute-sexp smartparens-mode-map) + (bind-key "C-M-t" #'sp-transpose-sexp smartparens-mode-map) + (bind-key "M-R" #'sp-raise-sexp smartparens-mode-map) + (bind-key "M-S" #'sp-splice-sexp smartparens-mode-map) + (bind-key "C-M-s" #'sp-split-sexp smartparens-mode-map) + (bind-key "M-J" #'sp-join-sexp smartparens-mode-map) + (bind-key "M-<up>" #'sp-splice-sexp-killing-backward smartparens-mode-map) + (bind-key "M-<down>" #'sp-splice-sexp-killing-forward smartparens-mode-map) + (bind-key "C-M-S-k" #'sp-kill-hybrid-sexp smartparens-mode-map) + (bind-key "C-S-<right>" #'sp-slurp-hybrid-sexp smartparens-mode-map) + (sp-with-modes '(twig-mode) + (sp-local-pair "{%" "%}") + (sp-local-pair "{{" "}}")) + (show-smartparens-global-mode t) + (smartparens-global-strict-mode t) + (add-hook 'lisp-mode-common-hook #'turn-off-smartparens-mode) + (add-hook 'coffee-mode-hook #'turn-off-smartparens-mode))) +#+END_SRC + +** smart-scan + +Move between instances of a symbol + +#+BEGIN_SRC emacs-lisp +(use-package smartscan + :config (progn + (smartscan-mode 1))) +#+END_SRC + +** move-text + +Transposing lines, made easier. + +#+BEGIN_SRC emacs-lisp +(use-package move-text + :config (move-text-default-bindings)) +#+END_SRC + +** undo-tree + +Emacs’ default handling of undo is a bit confusing. Undo-tree makes +it much clearer. It’s especially helpful for protoyping and refactoring. + +#+BEGIN_SRC emacs-lisp +(use-package undo-tree + :config (progn + (global-undo-tree-mode) + ;; Keep region when undoing in region + (defadvice undo-tree-undo (around keep-region activate) + (if (use-region-p) + (let ((m (set-marker (make-marker) (mark))) + (p (set-marker (make-marker) (point)))) + ad-do-it + (goto-char p) + (set-mark m) + (set-marker p nil) + (set-marker m nil)) + ad-do-it))) + :diminish undo-tree-mode) +#+END_SRC + +** replace + +#+BEGIN_SRC emacs-lisp +(use-package replace + :defer t + :config (progn + (setq case-replace nil))) +#+END_SRC + +** visual-regexp + +I don’t always remember exactly how Emacs’ regular expressions work, +so this package is pretty useful because it highlights everything in +the buffer for me. + +#+BEGIN_SRC emacs-lisp +(use-package visual-regexp + :bind (("C-c r" . vr/replace) + ("C-c q" . vr/query-replace) + ("C-c m" . vc/mc-mark))) +#+END_SRC +* Tangling + +Taken from [[https://github.com/larstvei/dot-emacs/blob/master/init.org][larstvei/dot-emacs]]. I changed it so that it would work with +my current dotfiles repository structure and work asynchronously, +thanks to [[https://github.com/jwiegley/emacs-async][jwiegley/emacs-async]]. + +We can use =C-c C-v t= to run =org-babel-tangle=, which extracts the +code blocks from the current file into a source-specific file (in this +case a =.el=-file). + +To avoid doing this each time a change is made we can add a function +to the =after-save-hook= ensuring to always tangle and byte-compile +the =org=-document after changes. + +#+BEGIN_SRC emacs-lisp +(use-package async + :commands (async-start) + :defer 2) + +(defun tangle-if-init () + "If the current buffer is 'init.org' the code-blocks are + tangled, and the tangled file is compiled." + + (when (string-suffix-p "init.org" (buffer-file-name)) + (tangle-init))) + +(defun tangle-init-sync () + (interactive) + (message "Tangling init") + ;; Avoid running hooks when tangling. + (let ((prog-mode-hook nil) + (src (expand-file-name "init.org" user-emacs-directory)) + (dest (expand-file-name "init.el" user-emacs-directory))) + (require 'ob-tangle) + (org-babel-tangle-file src dest) + (if (byte-compile-file dest) + (byte-compile-dest-file dest) + (with-current-buffer byte-compile-log-buffer + (buffer-string))))) + +(defun tangle-init () + "Tangle init.org asynchronously." + + (interactive) + (message "Tangling init") + (async-start + (symbol-function #'tangle-init-sync) + (lambda (result) + (message "Init tangling completed: %s" result)))) +#+END_SRC + +# Local Variables: +# eval: (when (fboundp #'tangle-if-init) (add-hook 'after-save-hook #'tangle-if-init)) +# End: +* End + +Start a server if possible. A daemon is already a server. +#+BEGIN_SRC emacs-lisp +(run-with-idle-timer 2 nil (lambda () + (unless (daemonp) + (require 'server) + (unless (server-running-p server-name) + (server-start))))) +(setq gc-cons-threshold 800000 + file-name-handler-alist file-name-handler-alist-backup) +#+END_SRC |