init.el

(require 'package)
(require 'cl)

;; Load anything in site-lisp
(eval-and-compile
  (mapc
   #'(lambda (path)
       (push (expand-file-name path user-emacs-directory) load-path))
   '("site-lisp")))

;; Needs melpa for any interesting packages
(add-to-list 'package-archives
             '("melpa" . "http://melpa.org/packages/") t)

(package-initialize)

(defun install-package (package)
  "Installs a single package"
  (unless (package-installed-p package)
    (package-install package)))

(defun install-packages (packages)
  "Installs multiple packages"
  (mapc #'install-package packages))

;; Bootstrap use-package and it's friends
(install-packages '(bind-key use-package diminish))

(require 'bind-key)
(require 'diminish)
(require 'use-package)

(use-package dash
  :ensure t)

;; General stuff
(show-paren-mode 1) ;; Always show parens
(fset 'yes-or-no-p 'y-or-n-p)
(setq load-prefer-newer t) ;; Perfer newer byte code
(setq gc-cons-threshold 50000000) ;; Set the GC up to 50mb
(setq-default indent-tabs-mode nil)   ;; don't use tabs to indent
(setq tab-always-indent 'complete) ;; Always indent
(setq blink-matching-paren nil)
(electric-indent-mode)
(setq longlines-show-hard-newlines t)
(global-visual-line-mode t)
(setq sentence-end-double-space nil)

;; Stop all kind of startup nonsense
(setq inhibit-splash-screen t)
(setq inhibit-startup-echo-area-message t)
(setq inhibit-startup-message t)

;; Make the C-. a viable prefix
(defvar ctrl-period-map)
(define-prefix-command 'ctrl-period-map)
(bind-key* "C-." 'ctrl-period-map)

;; Make dired delete recursive
(put 'dired-find-alternate-file 'disabled nil)

(setq dired-recursive-deletes 'always)
(setq dired-recursive-copies 'always)

;; Swap the buttons
(setq ns-function-modifier 'hyper)

(setq mac-command-modifier 'meta)
(setq mac-option-modifier 'super)

;; Backups
(setq backup-by-copying t)
(setq backup-directory-alist '(("." . "~/.emacs.d/backups")))

;; Keybindings for files
(bind-key* "C-. c" (lambda () (interactive) (find-file "~/.emacs.d/init.el")))
(bind-key* "C-. i" (lambda () (interactive) (find-file "~/org/info.org")))
(bind-key* "C-. s" (lambda () (interactive) (dired "~/org/cs")))
(bind-key* "C-. b" (lambda () (interactive) (find-file "~/org/books.org")))

;; Better buffer window controls
(bind-key "s-0" 'delete-window)
(bind-key "s-1" 'delete-other-windows)
(bind-key "s-2" 'split-window-below)
(bind-key "s-3" 'split-window-right)
(bind-key* "<C-return>" 'other-window)

;; Better defaults
(bind-key "<RET>" 'newline-and-indent)

;; Hippe is better than dabbdrev
(bind-key [remap dabbrev-expand] 'hippie-expand)

;; Eval'ing
(bind-key "C-c C-b" 'eval-buffer)

;; These functions are taken from the great @bbatovs Prelude.

;; Makes it easy to rename a file & buffer with C-c r
(defun prelude-rename-buffer-and-file ()
  "Rename current buffer and if the buffer is visiting a file, rename it too."
  (interactive)
  (let ((filename (buffer-file-name)))
    (if (not (and filename (file-exists-p filename)))
        (rename-buffer (read-from-minibuffer "New name: " (buffer-name)))
      (let ((new-name (read-file-name "New name: " filename)))
        (cond
         ((vc-backend filename) (vc-rename-file filename new-name))
         (t
          (rename-file filename new-name t)
          (set-visited-file-name new-name t t)))))))

(bind-key "C-c r" 'prelude-rename-buffer-and-file)

;; Cleans the whole buffer for whitespace and re-indents it with C-c n
(defcustom prelude-indent-sensitive-modes
  '(conf-mode coffee-mode haml-mode python-mode slim-mode yaml-mode)
  "Modes for which auto-indenting is suppressed."
  :type 'list
  :group 'prelude)

(defun prelude-cleanup-buffer-or-region ()
  "Cleanup a region if selected, otherwise the whole buffer."
  (interactive)
  (call-interactively 'untabify)
  (unless (member major-mode prelude-indent-sensitive-modes)
    (call-interactively 'indent-region)
    (whitespace-cleanup)))

(bind-key "C-c n" 'prelude-cleanup-buffer-or-region)

;; Flyspell
(use-package flyspell
  :defer t
  :config
  (setq ispell-program-name "aspell"
        ispell-extra-args '("--sug-mode=ultra")))

;; Yas
(use-package yasnippet
  :disabled t
  :ensure t
  :commands (yas-expand yas-minor-mode)
  :mode ("/\\.emacs\\.d/snippets/" . snippet-mode)
  :init
  (yas-global-mode 1)
  :config
  (yas-load-directory "~/.emacs.d/snippets/")

  (define-key yas-minor-mode-map (kbd "<tab>") nil)
  (define-key yas-minor-mode-map (kbd "TAB") nil)
  (define-key yas-minor-mode-map (kbd "C-c j") 'yas-expand)
  (define-key yas-minor-mode-map (kbd "C-c J") 'yas-insert-snippet))

;; Remove useless UI
(tool-bar-mode -1)
(menu-bar-mode -1)
(scroll-bar-mode -1)

;; Set that fringe
(setq window-combination-resize t)
(setq-default fringe-indicator-alist
              '((truncation . nil) (continuation . nil)))

(blink-cursor-mode 0)

;; Changing the font to an awesome one.
(set-frame-font "Source Code Pro 14")
(setq default-frame-alist '((font . "Source Code Pro 14")))

(use-package moe-theme
  :ensure t
  :config
  (load-theme 'moe-light t))

(use-package moe-theme-switcher
  :init
  (setq calendar-latitude +55)
  (setq calendar-longitude +10))

;; Setting the mode line to be a litte more smart.
(use-package smart-mode-line
  :ensure t
  :init
  (setq sml/no-confirm-load-theme t)
  (sml/setup))



(use-package paredit
  :ensure t
  :commands paredit-mode
  :init
  (paredit-mode 1))

;; Company-mode
(use-package company
  :disabled t
  :ensure company
  :diminish company-mode
  :commands company-mode
  :init
  (global-company-mode 1)
  :config
  (setq company-idle-delay 0.1
        company-show-numbers t))

;; Auctex
(use-package tex-site
  :ensure auctex
  :mode ("\\.tex\\'" . TeX-latex-mode)
  :preface
  (defun my-auctex-config-hook ()
    (turn-on-auto-fill)
    (setq TeX-auto-save t)
    (setq TeX-parse-self t)
    (setq TeX-PDF-mode t)
    (setq ispell-parser 'tex)
    (flyspell-mode))

  :config
  (add-hook 'TeX-mode-hook #'my-auctex-config-hook)

  (use-package company-auctex
    :disabled t
    :ensure t
    :init
    (company-auctex-init)))

;; Haskell
(use-package haskell-mode
  :ensure t
  :mode ("\\.l?hs\\'" . haskell-mode)
  :config
  ;; Indent
  (turn-on-haskell-indentation)
  (add-hook 'haskell-mode-hook 'turn-on-haskell-indentation)
  (add-hook 'haskell-mode-hook #'enable-paredit-mode)

  (use-package haskell-process
    :config
    (setq haskell-process-suggest-remove-import-lines t)
    (setq haskell-process-auto-import-loaded-modules t)
    (setq haskell-process-type 'cabal-repl)
    (setq haskell-process-log t))

  (use-package haskell-interactive-mode
    :init
    (add-hook 'haskell-mode-hook 'interactive-haskell-mode)
    :config
    (define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
    (define-key haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
    (define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
    (define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
    (define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
    (define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
    (define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
    (define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space)))

;; Emacs lisp editing
(use-package lisp-mode
  :mode  (("\\.el\\'" . emacs-lisp-mode)
          ("\\\*scratch\*\\'" . emacs-lisp-mode))
  :config
  (add-hook 'lisp-mode-hook #'enable-paredit-mode)
  (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode))

;; Ruby/Rails/Web Development
(use-package enh-ruby-mode
  :ensure t
  :mode (("\\.rb\\'" . enh-ruby-mode)
         ("\\Gemfile\\'" . enh-ruby-mode)
         ("\\Rakefile\\'" . enh-ruby-mode)
         ("\\.rake\\'" . enh-ruby-mode))
  :config
  (use-package ruby-end
    :ensure t
    :diminish ruby-end-mode))

(use-package js2-mode
  :ensure t
  :mode (
         ("\\.js\\'" . js2-mode)
         ("\\.json\\'" . js2-mode)
         ("\\.amethyst\\'" . js2-mode)
         )
  :commands (j2-mode))

(use-package web-mode
  :ensure t
  :mode (("\\.erb\\'" . web-mode)
         ("\\.html?\\'" . web-mode))
  :config
  (local-set-key (kbd "RET") 'newline-and-indent))

(use-package haml-mode
  :ensure t
  :mode ("\\.haml\\'" . haml-mode)
  :commands (haml-mode))

(use-package scss-mode
  :ensure t
  :mode ("\\.scss\\'" . scss-mode)
  :commands (scss-mode))

(use-package yaml-mode
  :ensure t
  :mode (("\\.yaml\\'" . yaml-mode)
         ("\\.yml\\'" . yaml-mode))
  :commands (yaml-mode))

;; Helm & Projectile & Perspective & Ido
(use-package projectile
  :ensure t
  :init
  (projectile-global-mode))

(use-package ido-vertical-mode
  :disabled t
  :ensure t
  :init
  (ido-vertical-mode 1))

(use-package ido
  :init
  (ido-mode 1)
  (ido-everywhere 1)
  :config
  (use-package flx-ido
    :ensure t
    :config
    (flx-ido-mode 1)
    (setq ido-enable-flex-matching t
          ido-use-faces nil)))

(use-package smex
  :disabled t
  :ensure t
  :bind ("M-x" . smex)
  :init
  (smex-initialize))

(use-package helm-config
  :ensure helm
  :diminish helm-mode
  :demand t
  :bind (("C-c h" . helm-command-prefix)
         ("C-c h r" . helm-recentf)
         ("M-x" . helm-M-x))
  :config
  (use-package helm-mode)
  :init
  (helm-mode 1)
  ;; Autoresize
  (helm-autoresize-mode 1)
  (setq helm-split-window-in-side-p t)

  ;; Fuzzy searching
  (setq helm-M-x-fuzzy-match t)
  (setq helm-apropos-fuzzy-match t)

  ;; Defining keys
  (define-key helm-map (kbd "<tab>")  'helm-select-action) ; list actions using C-z

  (use-package helm-projectile
    :ensure t
    :init
    (helm-projectile-on))

  (use-package helm-swoop
    :ensure t
    :bind ("M-i" . helm-swoop)))

(use-package perspective
  :ensure t
  :bind* ("M-s" . persp-switch)
  :init
  (persp-mode)
  :config
  (use-package persp-projectile
    :ensure t))

;; OSX
(use-package exec-path-from-shell
  :ensure t
  :init
  (exec-path-from-shell-initialize))

;; Org-mode
(use-package org-bullets
  :ensure t
  :config
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))

(use-package org
  :preface
  (defun rca/org-archive ()
    (interactive)
    (org-map-entries
     (lambda ()
       (org-archive-subtree)
       (setq org-map-continue-from (outline-previous-heading)))
     "/DONE" 'tree))

  (defun my-org-mode-hook ()
    (flyspell-mode 1)
    (turn-on-auto-fill))
  :bind (("M-n" . outline-next-visible-heading)
         ("M-p" . outline-previous-visible-heading))
  :config
  ;; Generally configs
  (setq org-startup-folded "showall")
  (add-hook 'org-mode-hook 'my-org-mode-hook)

  ;; Set the sequence
  (setq org-todo-keywords
        '((sequence "TODO(t)" "|")
          (sequence "SOMEDAY(e)" "STARTED(s)" "WAITING(w)" "REVIEW(r)")
          (sequence "|" "DONE(d)" )))

  (setq org-todo-keyword-faces
        '(("TODO" . (:foreground "medium blue" :weight bold))
          ("STARTED" . (:foreground "OrangeRed" :weight bold))
          ("DONE" . (:foreground "ForestGreen" :weight bold))
          ("REVIEW" . (:foreground "dark violet" :weight bold))
          ("SOMEDAY" . (:foreground "DeepSkyBlue3" :weight bold))
          ("WAITING" . (:foreground "gray" :weight bold))))

  ;; Capture
  (define-key global-map "\C-cc" 'org-capture)
  (define-key global-map "\C-cl" 'org-store-link)

  (setq org-capture-templates
        '(("b" "Book" entry (file+headline "~/org/books.org" "Bucket")
           "* %?" :prepend t)
          ("n" "Note" entry (file "~/org/notes.org")
           "* %?" :prepend t)))

  ;; Agenda
  ;; (define-key global-map "\C-ca" 'org-agenda)
  ;; (setq org-agenda-files (quote ("~/Dropbox/todo.org")))
  ;; ;; (setq org-tag-alist '(("@HOME" . ?h) ("@WORK" . ?w)))
  ;; (setq org-agenda-tags-column -100)
  ;; (setq org-agenda-start-on-weekday)
  ;; (setq org-agenda-start-with-log-mode t)
  ;; (setq org-agenda-window-setup 'current-window)
  ;; (add-to-list 'org-global-properties
  ;;              '("Effort_ALL". "0:05 0:15 0:30 1:00 2:00 3:00 4:00"))

  ;; (setq org-agenda-prefix-format
  ;;  (quote
  ;;   ((agenda . "  %-11c%?-12t% s")
  ;;    (timeline . "  % s")
  ;;    (todo . "  %-11c")
  ;;    (tags . "  %-11c"))))

  ;; (use-package org-agenda
  ;;   :config
  ;;   (bind-key "i" 'org-agenda-clock-in org-agenda-mode-map)
  ;;   (bind-key "o" 'org-agenda-clock-out org-agenda-mode-map))

  ;; Refile
  (setq org-refile-targets (quote ((nil :maxlevel . 10)
                                   (org-agenda-files :maxlevel . 10))))

  (setq org-refile-use-outline-path t)
  (setq org-outline-path-complete-in-steps nil)

  (setq org-return-follows-link t)

  ;; Habits
  ;; (setq org-modules '(org-habit))
  ;; (setq org-habit-graph-column 80)
  ;; (setq org-habit-show-habits-only-for-today t)

  ;; Clocking
  ;; (setq org-clock-idle-time nil
  ;;       org-log-done 'time
  ;;       org-clock-persist t
  ;;       org-clock-in-switch-to-state "STARTED"
  ;;       org-clock-in-resume t
  ;;       org-clock-persist-file "~/.emacs.d/data/org-clock-save.el"
  ;;       org-clock-report-include-clocking-task t
  ;;       org-log-into-drawer "LOGBOOK"
  ;;       org-clock-into-drawer 1)

  ;; Org-babel
  (setq org-src-fontify-natively t)
  (setq org-src-tab-acts-natively t)
  (setq org-fontify-whole-heading-line t)

  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)
     (ruby . t)
     (python . t)
     (java . t)
     (haskell . t)
     (R . t))))

;; Key-chord
(use-package key-chord
  :demand t
  :ensure t
  :init
  (key-chord-mode 1)
  :config
  (defun switch-to-last-used-buffer ()
    (interactive)
    (switch-to-buffer (other-buffer)))

  (key-chord-define-global "JJ" 'switch-to-last-used-buffer)
  (key-chord-define-global "jk" 'ace-jump-mode))

(use-package muttrc-mode
  :disabled t
  :ensure t
  :mode ("\\muttrc\\'" . muttrc-mode))

;; ERC
(use-package erc
  :defer t
  :bind ("C-x C-b" . switch-to-erc-buffer)
  :preface
  (defun irc ()
    (interactive)
    (erc :server "irc.freenode.net" :port 6667 :nick "nick" :password "password123"))

  (defun switch-to-erc-buffer nil
    "Switch to ERC buffer using IDO to choose which one, or start ERC if not already started."
    (interactive)
    (let (final-list (list ))
      (dolist (buf (buffer-list) final-list)
        (if (equal 'erc-mode (with-current-buffer buf major-mode))
            (setq final-list (append (list (buffer-name buf)) final-list))))
      (if final-list
          (switch-to-buffer (ido-completing-read "Buffer: " final-list))
        (call-interactively 'erc))))

  ;; Taken from Prelude
  (defun stop-irc ()
    "Disconnects from all irc servers"
    (interactive)
    (dolist (buffer (filter-server-buffers))
      (message "Server buffer: %s" (buffer-name buffer))
      (with-current-buffer buffer
        (erc-quit-server "Asta la vista"))))
  :config
  (setq erc-server-coding-system '(utf-8 . utf-8)
        erc-autojoin-channels-alist '(("freenode.net" "#learnprogramming" "#erlang"))
        erc-kill-buffer-on-part t
        erc-kill-queries-on-quit t)

  (erc-truncate-mode +1)

  (flyspell-mode 1)

  ;; (erc-track-mode 1)
  (setq erc-track-exclude-types '("JOIN" "NICK" "PART" "QUIT" "MODE"
                                  "324" "329" "332" "333" "353" "477"))
  (setq erc-hide-list '("JOIN" "PART" "QUIT")))

(use-package magit
  :ensure t
  :bind ("C-x g" . magit-status)
  :commands magit-mode
  :init
  (setq magit-last-seen-setup-instructions "1.4.0")
  :config
  (setq magit-last-seen-setup-instructions "1.4.0"))

(use-package golden-ratio
  :ensure t)

;; Evil-mode
(use-package evil
  :disabled t
  :ensure t
  :commands evil-mode
  :init
  (evil-mode 1)
  :config
  (use-package evil-leader
    :init
    (global-evil-leader-mode)
    :config
    (key-chord-define evil-insert-state-map "jj" 'evil-normal-state)
    (evil-leader/set-leader "<SPC>")

    (evil-leader/set-key
      "<SPC>" 'avy-goto-word-1
      "fs" 'save-buffer
      "ff" 'find-file
      "fd" (lambda () (interactive) (find-file "~/.emacs.d/init.el"))
      "fb" (lambda () (interactive) (find-file "~/org/books.org"))
      "bs" 'switch-to-buffer
      "gs" 'magit-status
      "hc"   'describe-char
      "hf"   'describe-function
      "hk"   'describe-key
      "hm"   'describe-mode
      "hp"   'describe-package
      "ht"   'describe-theme
      "hv"   'describe-variable
      "m'"   'org-edit-src-exit
      "oa"   'org-agenda
      "oc"   'org-capture
      "ot"   'org-todo-list
      "pp" 'projectile-switch-project
      "ps" 'projectile-find-file
      "pb" 'projectile-buffers-with-file
      "wg"    'golden-ratio-mode
      "wh"    'evil-window-left
      "wH"    'evil-window-move-far-left
      "wj"    'evil-window-down
      "wJ"    'evil-window-move-very-bottom
      "wk"    'evil-window-up
      "wK"    'evil-window-move-very-top
      "wl"    'evil-window-right
      "wL"    'evil-window-move-far-right
      "wr"    'evil-window-rotate-downwards
      "x" 'save-buffers-kill-terminal))
  (use-package evil-paredit
    :ensure t
    :commands (evil-paredit-mode)
    :init
    (evil-paredit-mode 1)))

(use-package winner-mode
  :defer t)

(use-package eldoc
  :diminish eldoc-mode
  :commands turn-on-eldoc-mode
  :defer t
  :init
  (progn
    (add-hook 'emacs-lisp-mode-hook 'turn-on-eldoc-mode)
    (add-hook 'lisp-interaction-mode-hook 'turn-on-eldoc-mode)
    (add-hook 'ielm-mode-hook 'turn-on-eldoc-mode)))

(use-package guide-key
  :ensure t
  :defer t
  :init
  (guide-key-mode 1)
  :config
  (setq guide-key/guide-key-sequence t))

(use-package racket-mode
  :disabled t
  :ensure t
  :defer t
  :config
  (setq racket-racket-program "/Applications/Racket v6.1.1/bin/racket"
        racket-raco-program "/Applications/Racket v6.1.1/bin/raco"))

(use-package erlang-start
  :disabled t
  :ensure erlang
  :commands (erlang-mode)
  :mode ("\\.erl\\'" . erlang-mode))

(use-package rainbow-delimiters
  :ensure t
  :config
  (progn
    (add-hook 'prog-mode-hook 'rainbow-delimiters-mode)))

(use-package rainbow-mode
  :ensure t
  :config
  (progn
    (add-hook 'prog-mode-hook 'rainbow-mode)))

(use-package rainbow-blocks
  :ensure t
  :config
  (progn
    (add-hook 'prog-mode-hook 'rainbow-blocks-mode)))

(use-package ace-jump-mode
  :ensure t
  :commands (ace-jump-mode))

(use-package expand-region
  :ensure t
  :bind ("C-=" . er/expand-region)
  :commands (er/expand-region))

(use-package visible-mark
  :ensure t
  :init
  (global-visible-mark-mode 1))

(use-package ag
  :ensure t
  :commands (ag ag-project))

(use-package zop-to-char
  :ensure t
  :bind ("M-z" . zop-up-to-char))

(use-package slim-mode
  :ensure t
  :mode ("\\.slim\\'" . slim-mode))