init.el

;;
;; paths
;;

(setq system-uses-terminfo nil)

(add-to-list 'exec-path (expand-file-name "~/bin"))
(add-to-list 'exec-path (expand-file-name "/usr/local/bin"))
(setenv "PATH" (concat (expand-file-name "~/bin")
                       ":/usr/local/bin:"
                       (getenv "PATH")))

(setq default-directory (expand-file-name "~/"))

;;
;; packages
;;

(require 'package)
(require 'hippie-exp)
(add-to-list 'package-archives
             '("marmalade" . "http://marmalade-repo.org/packages/") t)
(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)

(package-initialize)

(when (not package-archive-contents)
  (package-refresh-contents))

(defvar my-packages
  '(ac-slime
    align-cljlet
    auto-complete
    auto-indent-mode
    clojure-mode
    clojure-test-mode
    clojurescript-mode
    dired-details
    find-file-in-project
    go-mode
    hl-sexp
    magit
    markdown-mode
    monokai-theme
    cyberpunk-theme
    cider
    dash
    ac-nrepl
    org
    paredit
    zen-and-art-theme))

(dolist (p my-packages)
  (when (not (package-installed-p p))
    (package-install p)))

;;
;; server
;;
(server-start)

;;
;; visual settings
;;
(setq inhibit-splash-screen t
      initial-scratch-message nil
      truncate-partial-width-windows nil
      ;; initial-major-mode 'clojure-mode
      linum-format "%d  "
      visual-bell t)

(line-number-mode 0)
(column-number-mode 0)
(global-linum-mode 0)

(if (window-system)
    (progn (load-theme 'tronesque t)
           (tronesque-mode-line))
  (load-theme 'zen-and-art t))
  
(setq mode-line
      '((t (:background "magenta" :foreground "black" :box (:line-width -1 :style released-button))))
      show-paren-match
      '((t (:background "gold" :foreground "black")))
      show-paren-mismatch
      '((t (:background "medium violet red" :foreground "white"))))

(setq x-select-enable-clipboard t
      make-backup-files nil
      auto-save-default nil
      diff-switches "-u -w"
      whitespace-style '(trailing
                         lines
                         space
                         -before-tab
                         face
                         indentation
                         space-after-tab)
      auto-indent-modes '(ruby-mode
                          java-mode
                          javascript-mode
                          ;; emacs-lisp-mode
                          ))

(setq-default tab-width 2
              indent-tabs-mode nil
              c-basic-offset 2
              js-indent-level 2)

(dolist (mode auto-indent-modes)
  (add-hook (intern (format "%s-hook" mode)) 'auto-indent-minor-mode))

(fset 'yes-or-no-p 'y-or-n-p)
(delete-selection-mode t)
(show-paren-mode t)
(auto-compression-mode t)
(recentf-mode 1)
(setq diff-switches "-u -w")
(tool-bar-mode 0)
(menu-bar-mode 1)

;;
;; custom.el
;;
(setq custom-file "~/.emacs.d/custom.el")
(when (file-exists-p custom-file)
  (load custom-file))

;;
;; creature comforts
;;
(require 'ido)
(ido-mode t)
(setq ido-save-directory-list-file "~/.emacs.d/.ido.last"
      ido-enable-flex-matching t
      ido-use-filename-at-point 'guess
      ido-show-dot-for-dired t)

(defun recentf-ido-find-file ()
  "find a recent file using ido.
   from phil hagelberg's emacs-starter-kit."
  (interactive)
  (let ((file (ido-completing-read "choose recent file: " recentf-list nil t)))
    (when file
      (find-file file))))

(global-set-key (kbd "C-x f") 'recentf-ido-find-file)
(global-set-key (kbd "M-/") 'hippie-expand)

(defun devn-untabify-buffer ()
  (interactive)
  (untabify (point-min) (point-max)))

(defun devn-indent-buffer ()
  (interactive)
  (indent-region (point-min) (point-max)))

(defun devn-cleanup-buffer ()
  "perform a bunch of operations on the whitespace content of a buffer"
  (interactive)
  (devn-indent-buffer)
  (devn-untabify-buffer)
  (delete-trailing-whitespace))

(global-set-key (kbd "C-c n") 'devn-cleanup-buffer)
(global-set-key (kbd "C-c C-a") 'align-regexp)

;;; :set wrapscan emulation
(defadvice isearch-search (after isearch-no-fail activate)
  (unless isearch-success
    (ad-disable-advice 'isearch-search 'after 'isearch-no-fail)
    (ad-activate 'isearch-search)
    (isearch-repeat (if isearch-forward 'forward))
    (ad-enable-advice 'isearch-search 'after 'isearch-no-fail)
    (ad-activate 'isearch-search)))

;;; vim dt emulation
(defadvice zap-to-char (after my-zap-to-char-advice (arg char) activate)
  "kill up to the arg'th occurence of char, and leave char.
  the char is replaced and the point is put before char."
  (insert char)
  (forward-char -1))

;;
;; org
;;
(define-key global-map "\C-ca" 'org-agenda)
(setq org-src-window-setup 'current-window
      org-todo-keywords (quote ((sequence "TODO" "ONGOING" "DONE")))
      org-export-html-postamble nil
      org-todo-keyword-faces
      '(("ONGOING" . "orange")))

(setq org-html-validation-link nil)
(global-set-key (kbd "C-c q") 'auto-fill-mode)

(defun devn-insert-date ()
  "Insert a timestamp according to the locale's date and time format.
   Will insert a timestamp of the format: 09/24/13"
  (interactive)
  (insert (concat "<" (format-time-string "%Y-%m-%d %a" (current-time)) ">")))

(global-set-key (kbd "C-c M-d") 'devn-insert-date)

;; avoid "fontifying..." on OSX
(setq font-lock-verbose nil)

;;
;; clojure-mode
;;
(autoload 'clojure-mode "clojure-mode" nil t)
(autoload 'align-cljlet "align-cljlet" nil t)

(add-hook 'clojure-mode-hook
          (lambda ()
            ;; (clj-refactor-mode 1)
            (cljr-add-keybindings-with-prefix "C-c C-m")))

(global-set-key (kbd "C-x M-i") 'imenu-add-menubar-index)


;;
;; change font size
;;
(defun increase-font-size ()
  (interactive)
  (set-face-attribute
   'default
   nil
   :height
   (ceiling (* 1.10 (face-attribute 'default :height)))))

(defun decrease-font-size ()
  (interactive)
  (set-face-attribute
   'default
   nil
   :height
   (floor (* 0.9 (face-attribute 'default :height)))))


;;
;; key bindings
;;
(windmove-default-keybindings)
(global-set-key (kbd "C-c <left>")  'windmove-left)
(global-set-key (kbd "C-c <right>") 'windmove-right)
(global-set-key (kbd "C-c <up>")    'windmove-up)
(global-set-key (kbd "C-c <down>")  'windmove-down)

(global-set-key (kbd "C-+") 'increase-font-size)
(global-set-key (kbd "C--") 'decrease-font-size)
(global-set-key (kbd "M-j") 'join-line)
;; (global-set-key (kbd "RET") 'newline-and-indent)

;; (global-set-key (kbd "C-x M-c") 'nrepl-jack-in)
;; (global-set-key (kbd "C-x M-q") 'nrepl-quit)

;; behave like */# in vim, jumping to symbols under point.
(global-set-key (kbd "C-x *") 'highlight-symbol-next)
(global-set-key (kbd "C-*") 'highlight-symbol-prev)

(put 'narrow-to-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'set-goal-column 'disabled nil)


;;
;; registers
;;
(let ((emacs-dir (expand-file-name "~/.emacs.d/"))
      (home-dir (expand-file-name "~/")))
  (dolist (r `((?i (file . ,(concat emacs-dir "init.el")))
               (?c (file . ,(concat emacs-dir "custom.el")))
               (?j (file . ,(concat home-dir "notes/clojure.org")))
               (?r (file . ,(concat emacs-dir "init.el")))
               (?l (file . ,(concat (expand-file-name "~/.lein/profiles.clj"))))))
    (set-register (car r) (cadr r))))


;;
;; cider
;;
(require 'ac-nrepl)
(add-hook 'cider-repl-mode-hook
          'paredit-mode
          'subword-mode
          'ac-nrepl-setup)

(add-hook 'cider-mode-hook
          'cider-turn-on-eldoc-mode
          'ac-nrepl-setup)

(eval-after-load "auto-complete"
  '(add-to-list 'ac-modes 'cide-repl-mode))

(eval-after-load "cider"
  '(define-key cider-mode-map (kbd "C-c C-d") 'ac-nrepl-popup-doc))

(setq cider-popup-stacktraces nil)
(setq cider-repl-popup-stacktraces nil)

;;; find-file-in-project

(setq ffip-patterns '("*")
      ffip-use-project-cache nil
      ffip-project-file '("project.clj" ".git"))

(defun ffip-toggle-use-project-cache ()
  "toggles project file caching for find-file-in-project.el."
  (interactive)
  (setq ffip-use-project-cache (not ffip-use-project-cache))
  (message (concat "project caching "
                   (if ffip-use-project-cache
                       "enabled."
                     "disabled."))))

(global-set-key (kbd "C-x M-f") 'find-file-in-project)
(global-set-key (kbd "C-x M-f") 'ffip-toggle-use-project-cache)

;; paredit
(defvar paredit-modes
  '(clojure
    emacs-lisp
    lisp
    lisp-interaction
    cider
    cider-interaction
    ielm
    repl))

(dolist (mode paredit-modes)
  (add-hook (intern (concat (symbol-name mode) "-mode-hook"))
            (lambda ()
              (paredit-mode +1)
              (define-key paredit-mode-map (kbd "M-)")
                'paredit-forward-slurp-sexp)
              (define-key paredit-mode-map (kbd "C-(")
                'paredit-backward-slurp-sexp)
              (define-key paredit-mode-map (kbd "M-(")
                'paredit-wrap-round)
              (define-key paredit-mode-map (kbd "M-{")
                'paredit-wrap-curly)
              (define-key paredit-mode-map (kbd "M-[")
                'paredit-wrap-square))))

;;; ibuffer
(global-set-key (kbd "C-x C-b") 'ibuffer)
(setq ibuffer-expert t)
(setq ibuffer-show-empty-filter-groups nil)
(add-hook 'ibuffer-mode-hook
          '(lambda ()
             (ibuffer-auto-mode 1)
             (ibuffer-switch-to-saved-filter-groups "home")))