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

;; -*- lexical-binding: t; -*-
;;;; Startup
;; Do not merge echo-area-message sexp
(setq inhibit-startup-echo-area-message "alan")
(setq inhibit-startup-screen t
      initial-scratch-message ""
      initial-major-mode 'text-mode
      user-mail-address "alan@alanpearce.co.uk"
      user-full-name "Alan Pearce"
      custom-file "~/.emacs.d/custom.el")

(load custom-file :noerror)

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

;;; Allow lisps to use a common setup. I don't know why they don't have some lispy mode as their parent, but this is close enough
(defcustom lisp-common-mode-hook nil
  "Hook run when entering any Lisp mode."
  :type 'hook
  :group 'lisp)

;;;; Environment & Location

(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.")

;;;; Package Management
(add-to-list 'load-path (expand-file-name "elisp/" user-emacs-directory))

(eval-and-compile
  (add-to-list 'load-path (expand-file-name "~/.cask"))
  (require 'cask))
(cask-initialize)

(setq use-package-verbose t)
(require 'req-package)
(req-package pallet)

(req-package paradox
  :init (progn
          (when paradox-github-token
            (paradox-enable))
          (setq paradox-automatically-star t)))

;;;; Style

(req-package linum
  :config (setq linum-format " %4d "))

(req-package whitespace
  :config (setq whitespace-style
                '(face
                  space
                  tabs
                  trailing
                  newline
                  empty
                  tab-mark
                  space-before-tab
                  indentation
                  indentation::space
                  indentation::tabs)))

(global-font-lock-mode t)
;; Allow font-lock-mode to do background parsing
(setq jit-lock-stealth-time 1
      jit-lock-stealth-load 100
      jit-lock-chunk-size 1000
      jit-lock-defer-time 0.01)

(when (fboundp #'blink-cursor-mode)
  (blink-cursor-mode -1))

(setq ring-bell-function
      (lambda ()
        (unless (memq this-command
                      '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit undo-tree-undo))
          (ding))))

(req-package solarized-theme
  :config (load-theme 'solarized-light t))

(when (or (display-graphic-p)
          (daemonp))

  (defun use-variable-fonts ()
    (interactive)
    (variable-pitch-mode)
    (setq cursor-type 'bar))

  (defun ap/set-fonts (mono-face variable-face font-size)
    (when mono-face
      (let ((default-font (concat mono-face "-" (number-to-string font-size))))
        (add-to-list 'default-frame-alist `(font . ,default-font))
        (set-face-font 'fixed-pitch default-font)))
    (when variable-face
      (set-face-font 'variable-pitch (concat variable-face "-"
                                             (number-to-string (1+ font-size))))))

  (cond
   ((eq window-system 'w32)
    (ap/set-fonts "Consolas" "Segoe UI" 10))
   ((eq system-type 'darwin)
    (ap/set-fonts "Menlo" "Helvetica" 12))))

;;;; Autosaves & Backups
(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))
        auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
        backup-by-copying-when-linked t
        backup-by-copying-when-mismatch t))

;;;; Buffers

(req-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)))))

(req-package uniquify
  :config (progn
            (setq uniquify-buffer-name-style 'reverse
                  uniquify-separator "/"
                  uniquify-after-kill-buffer-p t
                  uniquify-ignore-buffers-re "^\\*")))

(req-package fancy-narrow
  :diminish fancy-narrow-mode
  :config (fancy-narrow-mode 1))

;;;; Communication

(req-package erc
  :config (progn
            (setq erc-user-full-name "Alan Pearce"
                  erc-email-userid "alan@alanpearce.co.uk"
                  erc-echo-notice-in-minibuffer t
                  erc-keywords '("alanpearce" "lethalrocks")
                  erc-autojoin-channels-alist
                  '(("freenode.net" "#emacs" "##freebsd" "#bufferbloat" "#openwrt" "#lojban" "#zfs" "#introverts")
                    ("what.cd" "#what.cd")
                    ("beusergroup.co.uk" "#be")))
            (add-to-list 'erc-modules 'scrolltobottom)
            (add-to-list 'erc-modules 'autojoin)
            (add-to-list 'erc-modules 'match)))

(setq message-send-mail-function 'smtpmail-send-it)
(setq smtpmail-smtp-server "external.home"
      smtpmail-smtp-service 587)

;;;; Completion

(setq completion-styles '(basic initials partial-completion substring)
      completion-ignore-case t)

(req-package smart-tab
  :init (global-smart-tab-mode)
  :config (progn
            (nconc smart-tab-completion-functions-alist '((php-mode . php-complete-function)))
            (diminish 'smart-tab-mode "")))

(req-package company
  :commands (company-mode)
  :bind (("C-<tab>" . company-complete))
  :init (progn
          (add-hook 'prog-mode-hook #'company-mode)
          (setq company-idle-delay .3
                company-begin-commands '(self-insert-command))))

;;;; Dates & Times

(req-package calendar
  :config (progn
            (setq calendar-week-start-day 1)
            (calendar-set-date-style 'iso)))

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

;;;; Directory browsing
(req-package dired
  :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-bind-jump nil)
            (when (and (eq system-type 'darwin) (executable-find "gls"))
              (setq insert-directory-program (executable-find "gls")))
            (put 'dired-find-alternate-file 'disabled nil)))

(req-package dired-x
  :require dired)

(req-package dired+
  :require dired
  :config (progn
            (diredp-toggle-find-file-reuse-dir 1)
            (dired-omit-mode 1)
            (setq dired-omit-files "#\\|\\.$")))

;;;; Documentation

(req-package which-func
  :init (which-function-mode)
  :config (setq which-func-modes t))

;;;; Files

(prefer-coding-system 'utf-8-auto-unix)
(set-default-coding-systems 'utf-8-auto-unix)
(setq-default buffer-file-coding-system 'utf-8-auto-unix)
(global-auto-revert-mode 1)

(add-hook 'before-save-hook #'delete-trailing-whitespace)

(defun rename-current-buffer-file ()
  "Renames current buffer and file it is visiting."
  (interactive)
  (let ((name (buffer-name))
        (filename (buffer-file-name)))
    (if (not (and filename (file-exists-p filename)))
        (error "Buffer '%s' is not visiting a file!" name)
      (let ((new-name (read-file-name "New name: " filename)))
        (if (get-buffer new-name)
            (error "A buffer named '%s' already exists!" new-name)
          (cond
           ((vc-backend filename) (vc-rename-file filename new-name))
           (t (rename-file filename new-name t)
              (rename-buffer new-name)
              (set-visited-file-name new-name)
              (set-buffer-modified-p nil)
              (message "File '%s' successfully renamed to '%s'"
                       name (file-name-nondirectory new-name)))))))))

(defun delete-current-buffer-file ()
  "Removes file connected to current buffer and kills buffer."
  (interactive)
  (let ((filename (buffer-file-name))
        (buffer (current-buffer)))
    (if (not (and filename (file-exists-p filename)))
        (ido-kill-buffer)
      (when (yes-or-no-p "Are you sure you want to remove this file? ")
        (delete-file filename)
        (kill-buffer buffer)
        (message "File '%s' successfully removed" filename)))))

(req-package recentf
  :init (progn (setq recentf-auto-cleanup 'never
                     recentf-save-file (expand-file-name "recentf" user-emacs-directory))
               (recentf-mode 1)))

(req-package saveplace
  :config (progn (setq-default save-place t)
                 (setq save-place-file (expand-file-name ".saveplace" user-emacs-directory))))

(req-package tramp
  :config (progn
            (setq tramp-default-method (if (eq system-type 'windows-nt) "plinkx" "ssh")
                  tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
                  tramp-backup-directory-alist backup-directory-alist
                  backup-enable-predicate (lambda (name)
                                            (and (normal-backup-enable-predicate name)
                                                 (not (let ((method (file-remote-p name 'method)))
                                                        (when (stringp method)
                                                          (member method '("su" "sudo")))))))
                  tramp-shell-prompt-pattern "\\(?:^\\|
\\)[^#$%>\n]*#?[#$%>›] *\\(\\[[0-9;]*[a-zA-Z] *\\)*")
            (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" (concat "/" tramp-default-method ":%h:")))
            (add-to-list 'tramp-default-proxies-alist `(,(regexp-quote (system-name)) nil nil))
            (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil))
            (add-to-list 'tramp-default-proxies-alist '("router" nil nil))))

(req-package tramp-sh
  :require tramp
  :config (progn
            (add-to-list 'tramp-remote-path "/usr/local/sbin")
            (add-to-list 'tramp-remote-path "~/bin")))

(req-package ediff
  :config (progn
            (setq ediff-split-window-function 'split-window-horizontally
                  ediff-window-setup-function 'ediff-setup-windows-plain)))

;;;; Indentation

(setq-default tab-width 4
              indent-tabs-mode t)
(setq tab-stop-list
      ;; (mapcar (lambda (x)
      ;;           (* 4 x))
      ;;         (number-sequence 1 (/ 120 4)))
      '(4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 100 104 108 112 116 120)
      tab-always-indent 'complete)

(req-package auto-indent-mode
  :commands (auto-indent-minor-mode
             auto-indent-mode)
  :config (progn
            (setq auto-indent-key-for-end-of-line-then-newline "<C-return>"
                  auto-indent-key-for-end-of-line-insert-char-then-newline "<C-S-return>"
                  auto-indent-blank-lines-on-move nil
                  auto-indent-assign-indent-level 4
                  auto-indent-backward-delete-char-behavior nil
                  auto-indent-delete-trailing-whitespace-on-save-file t
                  auto-indent-mode-untabify-on-yank-or-paste nil)
            (add-to-list 'auto-indent-disabled-modes-list 'jinja2-mode)
            (auto-indent-global-mode)
            (defun lisp-auto-indent-mode ()
              (set (make-local-variable 'auto-indent-assign-indent-level) 2))
            (add-hook 'lisp-common-mode-hook #'lisp-auto-indent-mode)))

(req-package smart-tabs-mode
  :commands (smart-tabs-mode
             smart-tabs-mode-enable
             smart-tabs-advice)
  :config (progn
            (smart-tabs-insinuate 'c 'javascript 'cperl 'python)
            (add-hook 'php-mode-hook #'smart-tabs-mode-enable)))

;;;; Keybindings

(when (eq system-type 'darwin)
  (set-keyboard-coding-system nil)
  (setq mac-option-modifier 'meta
        mac-right-option-modifier 'left
        mac-control-modifier 'control
        mac-right-control-modifier 'left
        mac-command-modifier 'super
        mac-right-command-modifier 'left
        mac-function-modifier 'hyper))

(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" #'ucs-insert)
(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-this-buffer)

(bind-key "s-x" (define-prefix-command 'super-x-map))

(bind-key "s-," (lambda ()
                  (interactive)
                  (jump-to-register ?e)))
(set-register ?e `(file . ,*init-file*))
(set-register ?z `(file . ,(expand-file-name ".config/zsh/zshrc" "~")))

(req-package discover
  :config (global-discover-mode))

;; Enable narrowing functions C-x n
(put 'narrow-to-defun  'disabled nil)
(put 'narrow-to-page   'disabled nil)
(put 'narrow-to-region 'disabled nil)

;;;; Minibuffer

(setq enable-recursive-minibuffers t)
(minibuffer-depth-indicate-mode t)

(if (daemonp)
    (defalias 'exit-emacs #'delete-frame)
  (defalias 'exit-emacs #'save-buffers-kill-emacs))

(req-package helm-config
  :bind (("C-x i"   . helm-imenu))
  :config (setq helm-idle-delay .1
                helm-input-idle-delay .1))

(req-package ido
  :bind (("C-x b"   . ido-switch-buffer))
  :init (progn
          (setq ido-save-directory-list-file (expand-file-name "ido-state" user-emacs-directory))
          (bind-key* "C-x C-f" #'ido-find-file)
          (ido-mode 1))
  :config (progn
            (setq ido-auto-merge-delay-time 99999
                  ido-enable-flex-matching t)

            (ido-init-completion-maps)
            (defun ido-manual-merge ()
              (interactive)
              (ido-initiate-auto-merge (current-buffer)))
            (bind-key "C-c C-s" #'ido-manual-merge ido-file-dir-completion-map)))

(defun ap/ido-projectile-switch-buffer-dwim (force-ido)
  (interactive "p")
  (if (and (projectile-project-p) (eq force-ido 1))
      (call-interactively #'projectile-switch-to-buffer)
    (call-interactively #'ido-switch-buffer)))

(bind-key "s-x b" #'ap/ido-projectile-switch-buffer-dwim)
(bind-key "s-x s-b" #'ap/ido-projectile-switch-buffer-dwim)

(req-package ido-vertical-mode
  :require ido
  :config (ido-vertical-mode 1))

(req-package flx-ido
  :require ido
  :init (progn
          (flx-ido-mode 1)))

(req-package smex
  :require ido
  :bind (("M-x" . smex)
         ("<apps>" . smex)
         ("<menu>" . smex)
         ("M-X" . smex-major-mode-commands)
         ("C-c M-x" . execute-extended-command))
  :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"))
          (smex-initialize)))

;;;; Modeline

(column-number-mode t)
(size-indication-mode t)

(req-package smart-mode-line
  :require solarized-theme
  :config (progn
            (setq sml/theme 'respectful)
            (sml/setup)))
;;;; Modes

;;;; systemd files
(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))

(req-package xrdb-mode
  :mode (("\\.Xdefaults\\'" . xrdb-mode)
         ("\\.Xresources\\'" . xrdb-mode)))

(req-package haskell-mode
  :mode (("\\.hs\\'" . haskell-mode)
         ("xmobarrc\\'" . haskell-mode)))

(req-package nginx-mode
  :mode (("nginx.conf" . nginx-mode)))

(req-package lua-mode
  :mode (("\\.lua\\'" . lua-mode)))

(req-package puppet-mode
  :mode (("\\.pp\\'" . puppet-mode))
  :config (progn
            (add-hook 'puppet-mode-hook #'autopair-mode)))

(req-package ruby-mode
  :mode (("\\.rb\\'" . ruby-mode)
         ("\\.cap\\'" . ruby-mode)))

(req-package yaml-mode
  :mode (("/group_vars/.*" . yaml-mode)
         ("/host_vars/.*" . yaml-mode)
         ("\\.sls\\'" . yaml-mode)))

;;;; Planning

(req-package org
  :bind (("C-c C-a" . org-agenda-list)
         ("C-c a" . org-agenda)
         ("C-c l" . org-store-link))
  :init (setq org-replace-disputed-keys t)
  :config (progn
            (setq org-directory "~/org"
                  org-agenda-files `(,org-directory)

                  org-default-notes-file (concat org-directory "/notes")

                  ;; Fewer asterisks, doesn't change indentation
                  org-hide-leading-stars t

                  org-startup-indented t

                  ;; ‘Remember’: new items at top
                  org-reverse-note-order t

                  org-modules '(org-habit
                                org-checklist)

                  ;; Add time done to ‘done’ tasks
                  org-log-done 'time

                  ;; Allow refiling into any org file
                  org-refile-targets '((org-agenda-files :maxlevel . 3))

                  org-list-allow-alphabetical t

                  org-pretty-entities t

                  org-table-duration-custom-format 'seconds

                  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 "TODO" "STARTED" "|" "DONE")
                                      (sequence "TOLEARN" "LEARNING" "LEARNED" "|" "MASTERED")
                                      (sequence "|" "CANCELLED")))
            (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory)))
            (defadvice org-clock-in (after wicked activate)
              "Mark STARTED when clocked in"
              (save-excursion
                (catch 'exit
                  (org-back-to-heading t)
                  (if (looking-at org-outline-regexp) (goto-char (1- (match-end 0))))
                  (if (looking-at (concat " +" org-todo-regexp "\\( +\\|[ \t]*$\\)"))
                      (org-todo "STARTED")))))))

(req-package org-journal
  :require org
  :config (progn
            (setq org-journal-date-format "%A, %d %B %Y")))

(req-package org-mobile
  :require org
  :config (progn
            (setq org-mobile-directory "~/Dropbox/MobileOrg")))

;;;; Programming

(req-package cedet
  :disabled t
  :config (progn
            (semantic-load-enable-code-helpers)
            (global-semantic-idle-completions-mode t)
            (global-semantic-highlight-func-mode t)
            (global-semantic-show-unmatched-syntax-mode t)
            (global-semantic-decoration-mode t)))

(req-package flycheck
  :diminish (flycheck-mode . " ✓")
  :init (global-flycheck-mode))

(req-package company-go
  :require go-mode
  :config (progn
            (setq company-go-show-annotation t)
            (defun ap/company-go-setup ()
              (set (make-local-variable 'company-backends)
                   '(company-go)))
            (add-hook 'go-mode-hook #'ap/company-go-setup)))

(req-package go-eldoc
  :require go-mode
  :config (progn
            (add-hook 'go-mode-hook #'go-eldoc-setup)))

(req-package go-projectile
  :require (go-mode go-eldoc projectile)
  :config (progn
            (setq go-projectile-switch-gopath 'maybe)))

(req-package auto-compile
  :init (add-hook 'emacs-lisp-mode-hook #'auto-compile-on-save-mode))

(req-package cc-mode
  :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 '+)))

(req-package quickrun
  :bind (("C-c C-e" . quickrun)))

;;;; Projects

(req-package projectile
  :bind (("C-c C-f" . projectile-find-file)
         ("s-x s-f" . projectile-find-file))
  :init (projectile-global-mode)
  :diminish projectile-mode
  :config (progn
            (setq projectile-switch-project-action #'projectile-dired
                  projectile-remember-window-configs t)))

(req-package vc
  :config (progn
            (setq vc-follow-symlinks t)))

(req-package diff-hl
  :init (progn
          (global-diff-hl-mode)
          (add-hook 'magit-refresh-file-buffer-hook #'diff-hl-update)))

(req-package magit
  :diminish magit-auto-revert-mode
  :commands (magit-status)
  :bind (("C-x g" . magit-status)
         ("s-G" . magit-status))
  :init (add-hook 'magit-mode-hook #'magit-load-config-extensions))

;;;; Spelling
(setq ispell-program-name "aspell"
      ispell-dictionary "british")
;; (setq ispell-process-directory (expand-file-name "~/"))
;; If aspell is too slow
;; If it is still too slow, use ‘ultra’ instead of ‘fast’
;; (setq ispell-extra-args '(" --sug-mode=fast"))
(req-package ispell
  :bind (("<f8>" . ispell-word)))

;;;; Scripting

(add-hook 'after-save-hook
          #'executable-make-buffer-file-executable-if-script-p)

(req-package sh-script
  :mode (("\\.zsh\\'" . shell-script-mode))
  :config (setq sh-shell-file "/usr/bin/env zsh"))

(req-package ntcmd
  :mode (("\\`.cmd\\'" . ntcmd-mode)
         ("\\`.bat\\'" . ntcmd-mode)))

;;;; Shells & REPLs

(req-package eshell
  :bind ("C-c s" . eshell)
  :config (progn
            (setq eshell-directory-name "~/.emacs.d/eshell")
            (req-package em-smart
              :init (progn
                      (setq eshell-where-to-jump 'begin
                            eshell-review-quick-commands nil
                            eshell-smart-space-goes-to-end t)
                      (eshell-smart-initialize)))))

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

(req-package shell
  :config (define-key shell-mode-map
            (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer))

(req-package multi-term
  :if (not (eq system-type 'windows-nt))
  :bind ("C-`" . multi-term-dedicated-toggle))

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

;;;; Text editing

;; Enable upcase and downcase-region
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(setq sentence-end-double-space t
      line-move-visual nil)

(setq x-select-enable-clipboard t)
(if (functionp 'x-cut-buffer-or-selection-value)
    (setq interprogram-paste-function 'x-cut-buffer-or-selection-value))

;; replace highlighted text rather than just inserting at point
(delete-selection-mode t)

(show-paren-mode t)

(bind-key "S-SPC" #'set-mark-command)

(req-package subword
  :init (global-subword-mode t))

(req-package misc
  :bind (("M-z" . zap-up-to-char)
         ("M-Z" . zap-to-char)))

(req-package ap-functions
  :commands (ap/remove-extra-cr)
  :bind (("C-x r M-w" . copy-rectangle)
         ("M-!" . shell-execute)))

(when (boundp 'x-select-request-type)
  (setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING)))

(req-package ace-jump-mode
  :bind (("C-c SPC" . ace-jump-mode))
  :config (progn
            (ace-jump-mode-enable-mark-sync)
            (setq ace-jump-word-mode-use-query-char nil
                  ace-jump-mode-scope 'window)))

(req-package autopair
  :commands (autopair-mode
             autopair-on)
  :init (progn
          (add-hook 'prog-mode-hook #'autopair-on)
          (defun autopair-off ()
            (autopair-mode -1))
          (add-hook 'lisp-common-mode-hook #'autopair-off)
          (setq autopair-blink nil
                autopair-skip-whitespace nil)))

(req-package expand-region
  :bind ("C-M-SPC" . er/expand-region))

(req-package goto-chg
  :bind ("C-x SPC" . goto-last-change))

(req-package multiple-cursors
  :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)))

(req-package eldoc
  :diminish eldoc-mode
  :config (progn
            (eldoc-add-command 'paredit-backward-delete 'paredit-close-round 'autopair-insert-opening)
            (setq eldoc-idle-delay 0.1)))

(req-package paredit
  :commands (paredit-mode)
  :init (progn
          (add-hook 'lisp-common-mode-hook #'enable-paredit-mode)
          (put #'paredit-forward-delete 'delete-selection 'supersede)
          (put #'paredit-backward-delete 'delete-selection 'supersede)
          (add-hook 'minibuffer-setup-hook #'conditionally-enable-paredit-mode)
          (defun conditionally-enable-paredit-mode ()
            "enable paredit-mode during eval-expression"
            (if (eq this-command 'eval-expression)
                (paredit-mode 1)))))

(req-package move-text
  :config (move-text-default-bindings))

(req-package smart-forward
  :bind (("C-M-u" . smart-up)
         ("C-M-d" . smart-down)
         ("C-M-p" . smart-backward)
         ("C-M-n" . smart-forward)))

(req-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)

(req-package visual-regexp
  :bind (("C-c r" . vr/replace)
         ("C-c q" . vr/query-replace)
         ("C-c m" . vc/mc-mark)))

;;;; Lisps

(defun ap/lisp-setup ()
  (run-hooks 'lisp-common-mode-hook)
  (setq indent-tabs-mode nil)
  (local-set-key (kbd "RET") #'paredit-newline))

(defun set-common-lisp-indentation ()
    (set (make-local-variable 'lisp-indent-function)
         #'common-lisp-indent-function))

(rename-modeline "lisp-mode" emacs-lisp-mode "ξ")
(add-hook 'emacs-lisp-mode-hook #'ap/lisp-setup)
(add-hook 'emacs-lisp-mode-hook #'turn-on-eldoc-mode)

(add-hook 'scheme-mode-hook #'ap/lisp-setup)
(add-hook 'lisp-mode-hook #'ap/lisp-setup)
(add-hook 'lisp-mode-hook #'set-common-lisp-indentation)

(req-package elisp-slime-nav
  :commands elisp-slime-nav-mode
  :diminish elisp-slime-nav-mode)

(req-package geiser
  :commands (geiser-mode
             geiser
             run-geiser
             run-racket))

(req-package redshank
  :init (progn
          (add-hook 'lisp-common-mode-hook #'turn-on-redshank-mode)))

(req-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"))))

(defun imenu-elisp-sections ()
  (setq imenu-prev-index-position-function nil)
  (add-to-list 'imenu-generic-expression '("Sections" "^;;;; \\(.+\\)$" 1) t)
  (add-to-list 'imenu-generic-expression '("Packages" "^(req-package\\s-+\\(\\(\\sw\\|\\s_\\)+\\)$" 1) t))

(defun init-narrow-to-section ()
  (interactive)
  (save-excursion
    (beginning-of-line)
    (unless (looking-at "^;;;;")
      (re-search-backward "^;;;;" nil t))
    (push-mark)
    (forward-line)
    (re-search-forward "^;;;;" nil t)
    (forward-line -1)
    (narrow-to-region (region-beginning) (region-end))))

(defun init-imenu (p)
  (interactive "P")
  (find-file-existing *init-file*)
  (widen)
  (helm-imenu)
  (if p (init-narrow-to-section)))

(add-hook 'emacs-lisp-mode-hook 'imenu-elisp-sections)

(defun eval-and-replace ()
  "Replace the preceding sexp with its value."
  (interactive)
  (backward-kill-sexp)
  (condition-case nil
      (prin1 (eval (read (current-kill 0)))
             (current-buffer))
    (error (message "Invalid expression")
           (insert (current-kill 0)))))

(bind-key "C-c e" #'eval-and-replace)

;;;; Web Development

(req-package skewer-mode
  :init (progn
          (add-hook 'js2-mode-hook #'skewer-mode)
          (add-hook 'html-mode-hook #'skewer-html-mode)
          (add-hook 'css-mode-hook #'skewer-css-mode)))

(req-package js2-mode
  :mode ("\\.js\\'" . js2-mode)
  :config (progn
            (defun ap/javascript-setup ()
               (autopair-mode -1)
              (auto-indent-mode -1))
            (add-hook 'js2-mode-hook #'ap/javascript-setup)
            (setq js2-basic-offset 4
                  js2-global-externs '("$"))))

(req-package mustache-mode
  :mode (("\\.mustache" . mustache-mode)
         ("\\.mt\\'" . mustache-mode)
         ("\\.template\\'" . mustache-mode)))

(req-package jinja2-mode
  :mode (("\\.j2\\'" . jinja2-mode)))

(req-package php-mode
  :mode ("\\.php\\'" . php-mode)
  :config (progn
            (setq php-template-compatibility nil)
            (bind-key "C-h C-f" #'php-search-documentation php-mode-map)
            (unbind-key "C-c C-f" php-mode-map)
            (unbind-key "C-." php-mode-map)
            (setq php-mode-coding-style "Symfony2")
            (add-hook 'php-mode-hook #'turn-on-eldoc-mode)))

(req-package sgml-mode
  :config (setq sgml-basic-offset 4))

(req-package emmet-mode
  :config (progn
            (if (functionp 'web-mode)
                (add-hook 'web-mode-hook #'emmet-mode))))

(req-package web-mode
  :mode (("/views/.*\\.php\\'" . web-mode)
         ("\\.html\\.twig\\'" . web-mode)
         ("/templates/.*\\.php\\'" . web-mode))
  :config (setq web-mode-code-indent-offset 4
                web-mode-css-indent-offset 4
                web-mode-markup-indent-offset 4
                web-mode-style-padding 0
                web-mode-script-padding 0
                web-mode-comment-style 2
                web-mode-disable-auto-pairing t))

;;;; Windows & Frames

(setq frame-title-format
      '(""
        (:eval (capitalize invocation-name)) ": "
        (:eval (if (buffer-file-name)
                   (abbreviate-file-name (buffer-file-name))
                 "%b"))))

(setq scroll-conservatively 100 ; Keep the cursor position when scrolling
      scroll-margin 1
      scroll-preserve-screen-position nil
      mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control))))

(when menu-bar-mode
  (menu-bar-mode -1))
(when scroll-bar-mode
  (scroll-bar-mode -1)
  (tooltip-mode -1)
  (tool-bar-mode -1))

(defun toggle-window-dedicated ()
  "Toggle whether the current active window is dedicated or not"
  (interactive)
  (message
   (if (let (window (get-buffer-window (current-buffer)))
         (set-window-dedicated-p window
                                 (not (window-dedicated-p window))))
       "Window '%s' is dedicated"
     "Window '%s' is normal")
   (current-buffer)))

(req-package popwin
  :config (progn
            (popwin-mode 1)))

(req-package winner
  :init (progn
          (winner-mode 1)
          (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))))

(req-package windmove
  :bind (("S-<left>"  . windmove-left)
         ("S-<right>" . windmove-right)
         ("S-<up>"    . windmove-up)
         ("S-<down>"  . windmove-down)))

(if (eq system-type 'darwin)
    (setq ns-pop-up-frames nil))

(req-package-finish)