dotfiles/emacs/.emacs.d/emacs.org

Emacs Configuration

• readme
  • Clone this repo
  • Preferably backup your emacs configuration
  • Remove/move your old configuration
  • Lastly copy necessary files
• use-package-hack
• prelude
  • always babel tangle and byte compile emacs.org
  • debug on error
  • emacs server
  • os detection
    • Mac OS X Gui emacs PATH setup
  • disable pointless startup stuff
  • temporary files
  • auto revert
  • dired
  • ediff
  • tramp
  • always remove trailing whitespace
  • chmod u+x on save for scripts
  • misc text related
    • wtf does this do?
    • default major mode
    • encoding
    • text selection
    • line width
    • we aren't banging rocks on typewriters anymore emacs
    • sentence end
    • default tab-width
  • uncategorized
• global key bindings
• appearance
  • theme
  • modeline
  • whitespace
  • gui chrome
  • fonts
• packages
  • Helm
  • helm-descbinds
  • helm-ag
  • magit
  • autopair
  • org
  • flycheck
  • auto-complete
  • smartparens
  • uniquify
  • desktop-save
• mode related
  • common defaults
    • prog-mode hook
    • c
    • elisp
    • python
    • shell
  • auto-insert-mode new file templates
    • c
    • elisp
    • python
    • shell

readme

This is my emacs configuration file. I don't encourage anyone to use this verbatim, but if you wanted to this is how you would do so:

Clone this repo

git clone https://github.com/mitchty/dotfiles

Preferably backup your emacs configuration

Always good to back things up, just in case you hate how I did things.

tar cvf ~/.emacs-backup.tar ~/.emacs.d ~/.emacs

Remove/move your old configuration

This is up to you to do right, just an example.

rm -fr ~/.emacs.d ~/.emacs

Lastly copy necessary files

mkdir ~/.emacs.d
cp dotfiles/init.el dotfiles/emacs.org ~/.emacs.d

use-package-hack

For some reason init.el doesn't always seem to get reflecte here. Weird reaserch later.

(require 'use-package)

prelude

always babel tangle and byte compile emacs.org

Add a save hook to always tangle and byte compile emacs.org file when we save it.

  (defun tangle-init ()
    "If the current buffer is 'emacs.org' the code-blocks are
  tangled, and the tangled file is compiled."
    (when (equal (buffer-file-name)
                 (expand-file-name (concat user-emacs-directory "emacs.org")))
      (let ((prog-mode-hook nil))
        (org-babel-tangle)
        (byte-compile-file (concat user-emacs-directory "emacs.el")))))

  (add-hook 'after-save-hook 'tangle-init)

debug on error

Not having to start emacs with –debug-init is useful.

(customize-set-variable 'debug-on-error t)

emacs server

Start up the emacs server if it isn't running.

(load "server")
(unless (server-running-p) (server-start))

os detection

Make it easier to determine what os we're running on.

(defvar on-mswindows (string-match "windows" (symbol-name system-type))
  "Am I running under windows?")
(defvar on-osx (string-match "darwin" (symbol-name system-type))
  "Am I running under osx?")
(defvar on-linux (string-match "gnu/linux" (symbol-name system-type))
  "Am I running under linux?")

Mac OS X Gui emacs PATH setup

This is here because if gui emacs gets started say from Finder, one can end up with missing certain things that aren't in the default PATH.

The strategy is fire off a $SLL and have it echo the PATH it has and then parse that to setup emacs exec-path.

For now we restrict this only to OSX. It may be more generally useful however.

(defun set-exec-path-from-shell-PATH ()
  (let ((path-from-shell
   (shell-command-to-string "$SHELL -i -c 'echo $PATH'")))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))

(if on-osx (set-exec-path-from-shell-PATH))

disable pointless startup stuff

Like the startup screen and the echo hooey.

(customize-set-variable 'inhibit-startup-screen t)
(customize-set-variable 'inhibit-startup-message t)
(customize-set-variable 'inhibit-startup-echo-area-message t)

temporary files

Keep temporary stuff isolated from everyone else. It infects everything otherwise. As bad as the .DS_Store files on osx.

(customize-set-variable 'temporary-file-directory "/tmp")
(customize-set-variable 'backup-directory-alist `((".*" . ,temporary-file-directory)))
(customize-set-variable 'auto-save-file-name-transforms `((".*" ,temporary-file-directory t)))
(customize-set-variable 'create-lockfiles nil)
(customize-set-variable 'make-backup-files nil)
(customize-set-variable 'auto-save-default nil)
(customize-set-variable 'backup-by-copying t)
(customize-set-variable 'auto-save-list-file-prefix temporary-file-directory)
(customize-set-variable 'backup-directory-alist `((".*" . ,temporary-file-directory)))
(customize-set-variable 'auto-save-file-name-transforms `((".*" ,temporary-file-directory t)))

auto revert

Update files in open buffers as they're changed on disk, freaking annoying without this on.

(customize-set-variable 'global-auto-revert-mode t)

dired

Use dired-x.

(add-hook 'dired-load-hook (function (lambda () (load "dired-x"))))

ediff

For those rare times I use it, make it a bit less derp on output.

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

tramp

Tramp configuration.

Make the proxy list less weird.

  (require 'tramp)
  ;; FIXME
  ;; (customize-variable 'tramp-default-proxies-alist
  ;;   (quote ((".*" "\\`root\\'" "/ssh:%h:"))))

So this was originally a way to do tramp over ssh where sudo only worked with su.

Its a hack, but it work(ed). Will remove it at some date in the future.

(add-to-list 'tramp-methods
             '("susudo"
               (tramp-login-program "sudo")
               (tramp-login-args
                (("-u" "%u")
                 ("-H")
                 ("-p" "Password:")
                 ("su -c /bin/sh")))
               (tramp-remote-sh "/bin/sh")
               (tramp-copy-program nil)
               (tramp-copy-args nil)
               (tramp-copy-keep-date nil)
               (tramp-password-end-of-line nil)))

always remove trailing whitespace

Trailing whitespace is not normally useful. Remove it always on save in the before-save-hook.

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

chmod u+x on save for scripts

Because its derp to have to chmod 755 stuff after I save. Honestly, do it for me kthxbai.

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

misc text related

Not sure what to categorize this crap as tbh.

wtf does this do?

TOOD: find out why I added this ages ago.

;;(move-text-default-bindings)

default major mode

So if we don't know, call it text-mode.

(custom-set-variables '(default-major-mode 'text-mode))

encoding

utf8 is the best. Default to it.

(custom-set-variables '(locale-coding-system 'utf-8))
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

text selection

If I selected text, delete the selection, I probably meant it emacs.

(delete-selection-mode 1)

line width

80 char line columns not 72.

(custom-set-variables '(fill-column 80))

we aren't banging rocks on typewriters anymore emacs

Double spacing after a line isn't needed.

(set-default 'sentence-end-double-space nil)

sentence end

Semi related to the above, make the sentence endings a bit more code-ish.

(custom-set-variables '(sentence-end "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"))
(custom-set-variables '(sentence-end-double-space nil))

default tab-width

Two seems sensible, cause well, tabs are evil incarnate.

(custom-set-variables '(default-tab-width 2))

uncategorized

I have no idea how to label these.

Highlight parens.

(show-paren-mode)

Typing out yes or no is stupid.

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

global key bindings

Global key bindings.

(global-set-key (kbd "C-,") 'kill-whole-line)
(global-set-key (kbd "C-]") 'er/expand-region)

appearance

theme

Solarized light is decent. I'll just use that.

  (use-package solarized-theme
   :ensure t
   :init (load-theme 'solarized-light 't))

modeline

Updat the time every ~3 seconds in the mode line.

  (custom-set-variables '(display-time-default-load-average nil))
  (custom-set-variables '(display-time-format "%T"))
  (custom-set-variables '(display-time-interval 3))
  (display-time-mode)

Display line and column always in the modeline.

  (custom-set-variables '(line-number-mode t))
  (custom-set-variables '(column-number-mode t))

Format the mode line, I… can't decipher this anymore nor do I care to, it works eff it.

  (custom-set-variables
   '(mode-line-format
     (list
      '(:eval (propertize "%b " 'face 'font-lock-keyword-face
                          'help-echo (buffer-file-name)))
      (propertize "%02l" 'face 'font-lock-type-face) ","
      (propertize "%02c" 'face 'font-lock-type-face)
      " ["
      '(:eval (propertize "%m" 'face 'font-lock-string-face
                          'help-echo buffer-file-coding-system))
      minor-mode-alist
      "] "
      "["
      '(:eval (propertize (if overwrite-mode "Ovr" "Ins")
                          'face 'font-lock-preprocessor-face
                          'help-echo (concat "Buffer is in "
                                             (if overwrite-mode "overwrite" "insert") " mode")))
      '(:eval (when (buffer-modified-p)
                (concat ","  (propertize "Mod"
                                         'face 'font-lock-warning-face
                                         'help-echo "Buffer has been modified"))))
      '(:eval (when buffer-read-only
                (concat ","  (propertize "RO"
                                         'face 'font-lock-type-face
                                         'help-echo "Buffer is read-only"))))        "] "
                                         '(:eval (propertize
                                                  (format-time-string "%H:%M:%S")
                                                  'help-echo
                                                  (concat (format-time-string "%c; ")
                                                          (emacs-uptime "Uptime:%hh")
                                                          )))
                                         " --"
                                         "%-"
                                         )))

whitespace

Customize whitespace mode to make tabs obvious as boxes, and to highlight lines over 80 characters in length.

(require 'whitespace)

(setq whitespace-style '(face tabs trailing))

(set-face-attribute 'whitespace-tab nil
                    :foreground "#2075c7"
                    :background "lightgrey")

(set-face-attribute 'whitespace-line nil
                    :foreground "#2075c7"
                    :background "lightgrey")

gui chrome

When i'm running in a terminal emacs, most of this junk isn't needed. For that matter gui counts for most.

Basically, never show the tool bar or the scroll bar in gui or tty. In gui its ok to show the menu-bar.

  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (when (not window-system)
    (menu-bar-mode -1))

fonts

Fonts. Let me specify them for gui emacs.

  (when window-system
    (require 'cl)

    (defun font-candidate (&rest fonts)
      "Return first font that matches list of provided fonts."
      (find-if (lambda (f) (find-font (font-spec :name f))) fonts))

    (set-face-attribute 'default nil :font
                        (font-candidate '"Pragmata\ Pro-13:weight=normal"
                                        "Source Code Pro-13:weight=normal"
                                        "Menlo-12:weight=normal"
                                        "Monaco-12:weight=normal"
                                        ))

    (cond (on-linux
           (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)
           (setq x-select-enable-clipboard t)
           )
          )
    )

packages

All the packages I use.

Helm

By Helms Deep use Helm to do ALL THE THINGS. IDO is ass in comparison.

  (use-package helm
    :ensure t
    :diminish helm-mode
    :bind (("M-x" . helm-M-x)
           ("M-y" . helm-show-kill-ring)
           ("C-x b" . helm-mini)
           ("C-x C-b" . helm-buffers-list)
           ("C-x C-f" . helm-find-files)
           ("C-x C-r" . helm-recentf)
           ("C-x c o" . helm-occur))
    :init (progn
            (require 'helm-config)
            (helm-mode 1)))

helm-descbinds

Its nice being able to describe helm things you know?

  (use-package helm-descbinds
               :ensure t
               :bind (("C-h b" . helm-descbinds)
                      ("C-h w" . helm-descbinds))
               )

helm-ag

Helm search plugin for Ag (The Silver Searcher) so much nicer than regular searching in helm imo.

  (use-package helm-ag
               :ensure t
               )

magit

Make git not ass to use. At least in emacs. magit is the best git interface… in the world.

  (use-package magit
               :ensure t
               :commands (magit-init
                          magit-status
                          magit-diff
                          magit-commit)
               :bind ("C-x m" . magit-status)
               :config
               (progn
                 (defadvice magit-status (around magit-fullscreen activate)
                   (window-configuration-to-register :magit-fullscreen)
                   ad-do-it
                   (delete-other-windows))

                 (defadvice magit-quit-window (around magit-restore-screen activate)
                   ad-do-it
                   (jump-to-register :magit-fullscreen)))
               )

  (use-package magit-blame
               :ensure magit
               :commands (magit-blame-mode)
               )

autopair

Highlight matching ()'s []'s etc…

  (use-package autopair
               :ensure t
               :config (customize-set-variable 'autopair-blink 'nil)
               )

org

Org mode keybindings and settings, pretty sparse really.

  (use-package org
               :ensure t
               :bind (("C-c a" . org-agenda)
                      ("C-c b" . org-iswitchb)
                      ("C-c c" . org-capture)
                      ("C-c l" . org-store-link)
                      ("C-c p" . org-latex-export-to-pdf))
               :config (customize-set-variable 'org-log-done t)
               )

flycheck

Flycheck for on the fly checking of code.

  (use-package flycheck
               :ensure t
               :config (customize-set-variable 'flycheck-indication-mode 'right-fringe)
               )

Need to vet this, used it more when I did more c. But its handy for non standard pkg-config setups.

Not tangled into the config intentionally.

  (defun pkg-config-add-lib-cflags (pkg-config-lib)
    "This function will add necessary header file path of a
  specified by `pkg-config-lib' to `flycheck-clang-include-path', which make it
  completionable by auto-complete-clang"
    (interactive "spkg-config lib: ")
    (if (executable-find "pkg-config")
        (if (= (shell-command
                (format "pkg-config %s" pkg-config-lib))
               0)
            (setq flycheck-clang-include-path
                  (append flycheck-clang-include-path
                          (split-string
                           (shell-command-to-string
                            (format "pkg-config --cflags-only-I %s"
                                    pkg-config-lib)))))
          (message "Error, pkg-config lib %s not found." pkg-config-lib))
      (message "Error: pkg-config tool not found.")))

auto-complete

Auto complete functionality is nice to have.

  (use-package auto-complete
               :ensure t
               )

smartparens

Helpfully inserts matching parens, can be a pita too.

  (use-package smartparens
               :ensure t
               )

uniquify

Make buffer names unique based on their directory and not have <N> or other nonsense.

  (require 'uniquify)
  (customize-set-variable 'uniquify-buffer-name-style 'post-forward)

desktop-save

Desktop saving of session information handy to keep the same buffers between sessions.

  (require 'desktop)

  (desktop-save-mode 1)

  (customize-set-variable 'desktop-restore-eager 5)
  (customize-set-variable 'desktop-path           '("~/.emacs.d"))
  (customize-set-variable 'desktop-dirname        "~/.emacs.d")
  (customize-set-variable 'desktop-base-file-name "desktop")

  (defun local-desktop-save ()
    (interactive)
    (if (eq (desktop-owner) (emacs-pid))
        (desktop-save desktop-dirname)))

  (add-hook 'auto-save-hook 'desktop-save-in-desktop-dir)

mode related

common defaults

Common mode defaults I think are sensible.

prog-mode hook

  (add-hook 'prog-mode-hook
        '(lambda ()
           (interactive)
           (hl-line-mode)
           (auto-complete-mode)
           (whitespace-mode)
           (smartparens-mode)
           (visual-line-mode)
           (customize-set-variable 'indent-tabs-mode nil)
           (customize-set-variable 'tab-width 2)
           (flycheck-mode)
          )
        )

c

  (add-to-list 'auto-mode-alist '("\\.[chm]\\'" . c-mode))
  (add-hook 'c-mode-common-hook
            '(lambda ()
               (global-set-key "\C-x\C-m" 'compile)
               (setq flycheck-clang-language-standard "c11")
               (setq flycheck-idle-change-delay 2)
               (setq flycheck-highlighting-mode 'symbols)
  ;; later...
  ;;             (add-hook 'before-save-hook 'clang-format-buffer nil t)
               (c-toggle-auto-state 1)
               (setq-default c-basic-offset 2
                             tab-width 2
                             indent-tabs-mode nil
                             c-electric-flag t
                             indent-level 2
                             c-default-style "bsd"
                             backward-delete-function nil)
               ))

elisp

(add-hook 'emacs-lisp-hook
          (lambda ()
            (define-key emacs-lisp-map
              "\C-x\C-e" 'pp-eval-last-sexp)
            (define-key emacs-lisp-map
              "\r" 'reindent-then-newline-and-indent)))

python

  (add-hook 'python-mode-hook '(lambda () (flycheck-select-checker 'python-flake8)))

shell

(autoload 'sh--mode "sh-mode" "mode for shell stuff" t)

(add-to-list 'auto-mode-alist '("\\.sh$\\'" . sh-mode))
(add-to-list 'auto-mode-alist '("\\.[zk]sh$\\'" . sh-mode))
(add-to-list 'auto-mode-alist '("\\.bash$\\'" . sh-mode))
(add-to-list 'auto-mode-alist '("\\[.].*shrc$\\'" . sh-mode))
(add-to-list 'auto-mode-alist '("sourceme$\\'" . sh-mode))

(add-hook 'sh-mode-hook
          '(lambda ()
             (setq sh-basic-offset 2 sh-indentation 4
                   sh-indent-for-case-label 0 sh-indent-for-case-alt '+)))

auto-insert-mode new file templates

Use auto-insert-mode to insert in templates for blank files.

So first up, add auto-insert to find-file-hooks so we insert straight away. Also setup the copyright bit to minimally put in name.

(add-hook 'find-file-hooks 'auto-insert)
(setq auto-insert-copyright (user-full-name))

Create the auto-insert-alist so all the mode lists are the same

(setq auto-insert-alist '(()))

c

    (setq auto-insert-alist
          (append
           '(
             ((c-mode . "c")
              nil
              "/*\n"
              "File: " (file-name-nondirectory buffer-file-name) "\n"
              "Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
              "Description: " _ "\n"
              "*/\n"
              "#include <stdio.h>\n"
              "#include <stdlib.h>\n\n"
              "int main(int argc, char **argv) {\n"
              "  return 0;\n"
              "}\n"
              )
             )
           auto-insert-alist)
          )

elisp

    (setq auto-insert-alist
          (append
           '(
             ((emacs-lisp-mode . "elisp")
              nil
              ";;-*-mode: emacs-lisp; coding: utf-8;-*-\n"
              ";; File: " (file-name-nondirectory buffer-file-name) "\n"
              ";; Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
              ";; Description: " _ "\n"
              )
             )
           auto-insert-alist)
          )

python

  (setq auto-insert-alist
        (append
         '(((python-mode . "python")
           nil
           "#!/usr/bin/env python\n"
           "# -*-mode: Python; coding: utf-8;-*-\n"
           "# File: " (file-name-nondirectory buffer-file-name) "\n"
           "# Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
           "# Description: " _ "\n\n"
           )
           )
         auto-insert-alist)
        )

shell

  (setq auto-insert-alist
        (append
         '(
           ((sh-mode . "sh")
            nil
            "#!/usr/bin/env sh\n"
            "#-*-mode: Shell-script; coding: utf-8;-*-\n"
            "# File: " (file-name-nondirectory buffer-file-name) "\n"
            "# Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
            "# Description: " _ "\n"
            "export script=$(basename \"$0\")\n"
            "export dir=$(cd \"$(dirname \"$0\")\"; pwd)\n"
            "export iam=${dir}/${script}\n"
            )
           )
         auto-insert-alist)
        )