Gee, what're we gonna do tonight, Brain?

Cask

@@ -10,30 +10,42 @@
 (depends-on "f")
 (depends-on "deferred")
 (depends-on "exec-path-from-shell")
+(depends-on "fuzzy")
 (depends-on "use-package")
+(depends-on "smex")
+(depends-on "auto-async-byte-compile")
 
 ;; Editing
+(depends-on "smooth-scrolling")
 (depends-on "smart-mode-line")
 (depends-on "shut-up")
 (depends-on "dired+")
 (depends-on "expand-region")
 (depends-on "flycheck")
 (depends-on "flyspell")
-(depends-on "multiple-cursors")
 (depends-on "rainbow-delimiters")
 (depends-on "smartparens")
 (depends-on "anzu")
 (depends-on "key-chord")
-(depends-on "saveplace")
 (depends-on "yasnippet")
-(depends-on "git-gutter")
+(depends-on "git-gutter-fringe+")
 (depends-on "popwin")
 (depends-on "dash-at-point")
 (depends-on "auto-complete")
 (depends-on "auto-complete-clang")
 (depends-on "auto-complete-c-headers")
-(depends-on "ace-jump-mode")
 (depends-on "ac-etags")
+(depends-on "xcscope")
+(depends-on "ac-ispell")
+(depends-on "ace-jump-mode")
+(depends-on "ace-window")
+(depends-on "smart-forward")
+(depends-on "regex-tool")
+(depends-on "perspective")
+(depends-on "persp-projectile")
+;;(depends-on "multiple-cursors")
+;;(depends-on "git-gutter")
+;;(depends-on "saveplace")
 
 ;; Eeeevil
 (depends-on "evil")
@@ -43,54 +55,64 @@
 (depends-on "evil-exchange")
 (depends-on "evil-space")
 (depends-on "evil-visualstar")
-;; evil-nerd-commenter chokes if it's installed via cask for some reason...
-;;(depends-on "evil-nerd-commenter")
 (depends-on "evil-indent-textobject")
 (depends-on "evil-jumper")
 (depends-on "evil-god-state")
 (depends-on "god-mode")
+;; evil-nerd-commenter chokes if it's installed via cask for some reason...
+;;(depends-on "evil-nerd-commenter")
 
 ;; Project management
+(depends-on "ag")
 (depends-on "projectile")
 (depends-on "helm")
-(depends-on "smex")
+(depends-on "helm-ag")
-(depends-on "ag")
+(depends-on "helm-css-scss")
-(depends-on "grizzl")
+(depends-on "helm-projectile")
 (depends-on "neotree")
 (depends-on "ido-ubiquitous")
 (depends-on "ido-vertical-mode")
 (depends-on "flx-ido")
+;;(depends-on "grizzl")
 
 ;; Modes/mode-specific
 (depends-on "org-plus-contrib")
 (depends-on "org-opml" :git "https://github.com/edavis/org-opml")
 
 (depends-on "rainbow-mode")
-(depends-on "web-mode")
 (depends-on "lua-mode")
 (depends-on "php-mode")
-(depends-on "emmet-mode")
 (depends-on "haml-mode")
 (depends-on "scss-mode")
+(depends-on "sass-mode")
 (depends-on "sws-mode")
 (depends-on "json-mode")
 (depends-on "yaml-mode")
 (depends-on "markdown-mode")
 (depends-on "glsl-mode")
-(depends-on "haxe-mode")
+(depends-on "groovy-mode")
-(depends-on "go-mode" :git "https://github.com/dominikh/go-mode.el")
+(depends-on "swift-mode")
+;; (depends-on "haxe-mode")
+;; (depends-on "go-mode" :git "https://github.com/dominikh/go-mode.el")
 
+(depends-on "web-mode")
+(depends-on "emmet-mode")
+(depends-on "web-beautify")
+
+(depends-on "js2-mode")
+(depends-on "js2-refactor")
 (depends-on "tern")
 (depends-on "tern-auto-complete")
 
 (depends-on "rspec-mode")
 (depends-on "inf-ruby")
-(depends-on "ac-inf-ruby")
+;;(depends-on "ac-inf-ruby")
+(depends-on "robe")
 
 (depends-on "jedi")
 
 ;;(depends-on "omnisharp")
-(depends-on "csharp-mode")
+;;(depends-on "csharp-mode")
 (depends-on "emacs-eclim")
 
 (depends-on "git-commit-mode")

cleanup.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-rm -f init.elc init/*.elc init/defuns/*.elc elisp/*.elc &> /dev/null
+rm -f init.elc init/*.elc elisp/*.elc &> /dev/null

elisp/hl-todo.el

@@ -0,0 +1,117 @@
+;;; hl-todo.el --- highlight TODO keywords
+
+;; Copyright (C) 2013-2014  Jonas Bernoulli
+
+;; Author: Jonas Bernoulli <jonas@bernoul.li>
+;; Created: 20130310
+;; Homepage: http://github.com/tarsius/hl-todo
+;; Keywords: convenience
+
+;; This file is not part of GNU Emacs.
+
+;; This file is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; This file is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; For a full copy of the GNU General Public License
+;; see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Hightlight TODO keywords.  There are many minor modes like it
+;; but this one is mine.  It also happens to be simpler than the
+;; alternatives.
+
+;; For now at least -- I might extend it.  Or I might abandon it
+;; in favor of one of the following -- so you might be better of
+;; going straight for one of these:
+
+;; - [[http://emacswiki.org/fic-ext-mode.el][fic-ext-mode]]
+;; - [[https://github.com/lewang/fic-mode][fic-mode]]
+;; - [[http://emacswiki.org/FixmeMode][fixme-mode]]
+;; - [[https://github.com/rolandwalker/fixmee][fixmee]]
+;; - see http://emacswiki.org/FixmeMode for more alternatives
+
+;; If you like this you might also like [[https://github.com/tarsius/orglink][orglink]].
+
+;;; Code:
+
+(defgroup hl-todo nil
+  "Highlight TODO keywords in comments."
+  :group 'font-lock-extra-types)
+
+(defface hl-todo
+  '((t (:bold t :foreground "#cc9393")))
+  "Face used to highlight TODO keywords."
+  :group 'hl-todo)
+
+(defcustom hl-todo-activate-in-modes '(emacs-lisp-mode)
+  "Major modes in which `hl-todo-mode' should be activated.
+This is used by `global-hl-todo-mode'."
+  :group 'hl-todo
+  :type '(repeat function))
+
+(defvar hl-todo-keywords nil)
+
+(defcustom hl-todo-keyword-faces
+  '(("HOLD" . "#d0bf8f")
+    ("TODO" . "#cc9393")
+    ("NEXT" . "#dca3a3")
+    ("THEM" . "#dc8cc3")
+    ("PROG" . "#7cb8bb")
+    ("OKAY" . "#7cb8bb")
+    ("DONT" . "#5f7f5f")
+    ("FAIL" . "#8c5353")
+    ("DONE" . "#afd8af")
+    ("FIXME" . "#cc9393")
+    ("XXX"   . "#cc9393")
+    ("XXXX"  . "#cc9393")
+    ("???"   . "#cc9393"))
+  "Faces used to highlight specific TODO keywords."
+  :group 'hl-todo
+  :type '(repeat (cons (string :tag "Keyword")
+                       (choice :tag "Face   "
+                               (string :tag "Color")
+                               (sexp :tag "Face"))))
+  :set (lambda (symbol value)
+         (set-default symbol value)
+         (setq hl-todo-keywords
+               `((,(concat "\\_<\\("
+                           (mapconcat 'car value "\\|")
+                           "\\)\\_>")
+                  (1 (hl-todo-get-face) t))))))
+
+(defun hl-todo-get-face ()
+  (let ((f (cdr (assoc (match-string 1) hl-todo-keyword-faces))))
+    (if (stringp f) (list :inherit 'hl-todo :foreground f) f)))
+
+;;;###autoload
+(define-minor-mode hl-todo-mode
+  "Highlight TODO tags in comments."
+  :lighter ""
+  :group 'hl-todo
+  (if hl-todo-mode
+      (font-lock-add-keywords  nil hl-todo-keywords 'append)
+    (font-lock-remove-keywords nil hl-todo-keywords))
+  (when (called-interactively-p 'any)
+    (font-lock-fontify-buffer)))
+
+;;;###autoload
+(define-globalized-minor-mode global-hl-todo-mode
+  hl-todo-mode turn-on-hl-todo-mode-if-desired)
+
+(defun turn-on-hl-todo-mode-if-desired ()
+  (when (apply 'derived-mode-p hl-todo-activate-in-modes)
+    (hl-todo-mode 1)))
+
+(provide 'hl-todo)
+;; Local Variables:
+;; indent-tabs-mode: nil
+;; End:
+;;; hl-todo.el ends here

init.el

@@ -10,61 +10,70 @@
 
 ;; instead of /
 (cd "~")
-;; (setq use-package-verbose t) ; for debug purposes
+(setq use-package-verbose t) ; for debug purposes
 
 (require 'cask)
 (cask-initialize)
 
+(setq user-mail-address "henrik@lissner.net")
+
 (defconst *dir           (file-name-directory load-file-name))
 (defconst *init-dir      (concat *dir "init/"))
 (defconst *themes-dir    (concat *dir "themes/"))
 (defconst *elisp-dir     (concat *dir "elisp/"))
 (defconst *snippets-dir  (concat *dir "snippets/"))
-(defconst *ac-dicts-dir  (concat *dir "ac-dict"))
+(defconst *ac-dicts-dir  (concat *dir "ac-dict/"))
-(defconst *tmp-dir       "/tmp/emacs/")
+(defconst *tmp-dir       (concat *dir "tmp/"))
 
 (defconst *theme  'brin)
-(defconst *font   "Inconsolata-14")
+(defconst *font
+  (if (string-equal system-name "ganymede.local")
+      "Ubuntu Mono-12"      ; Use smaller font on my laptop
+    "Ubuntu Mono-14"))      ; And larger font everywhere else
 
 (add-to-list 'load-path *init-dir)
 
 ;; Just the... bear necessities...
 (mapc 'require
   '(core
-    my-defuns               ; Personal library
+    core-defuns             ; Defun library
-
+    core-editor             ; Global editor behavior (w/ evil)
-    ;; Tailoring emacs
-    core-editor             ; Internal config for global editor behavior
     core-ui                 ; User interface layout & behavior
     core-osx                ; Mac-specific config
 
-    ;; Plugins & modules
+    ;; Essential plugins & modules
     init-ido                ; Ido setup
-    init-project            ; Project navigation tools & settings
+    init-project            ; Project nav+search tools (projectile, helm, ag)
-    init-ac                 ; Auto-complete engine & settings
     init-snippets           ; Snippet engine
     init-git                ; GIT tools/settings
     init-fly                ; Syntax & spell checker
-    init-etags
+    init-auto-complete      ; Auto-complete engine
+    init-auto-insert        ; File auto-insert templates
+    init-cscope             ; Global code indexing
 
     ;; Modes & environments
     init-text               ; Plain text editing (markdown, text)
+    init-sh                 ; Shell script editing (sh, zsh)
     init-org                ; Org-mode: personal gtd/notes
     init-dev                ; Generic dev tools & environment for all programming
     init-ruby
     init-python
-    init-webdev             ; Environment for webdev (SCSS, PHP, Rails, Jekyll)
+    ;;init-php
+    init-webdev             ; Environment for webdev (SCSS, PHP, Rails, Javascript)
     init-love               ; Love.app gamedev
     init-cpp                ; C++ gamedev
-    init-eclim              ; Integration into eclipse (for Java)
+    init-java               ; Java-specific settings (including eclim)
+    ;; init-go                 ; Go-lang
+    ;; init-swift              ; iOS/Mac dev environment for swift
     ;; init-csharp             ; Emacs as a Csharp/Unity IDE
 
+    ;; My homebaked packages
+    my-commands             ; Ex commands & evil operators/commands
+    my-coderunner           ; Code/REPL runners
+
+    ;; Personal settings (must be last!)
     my-settings             ; Any other custom settings
-    my-commands             ; Interactive defuns & evil operators/commands
     my-keymaps              ; My keybindings
     ))
 
-;; (require 'server)
-;; (unless (server-running-p) (server-start))
-
 ;; I've created a monster!

init/core-defuns.el

@@ -0,0 +1,237 @@
+(provide 'core-defuns)
+
+;;;; Convenience ;;;;;;;;;;;;;;;;;;;
+(defun associate-mode (match mode)
+  (add-to-list 'auto-mode-alist (cons match mode)))
+(defun associate-minor-mode (match mode)
+  (add-to-list 'auto-minor-mode-alist (cons match mode)))
+
+(defmacro λ (&rest body)
+  `(lambda () (interactive) ,@body))
+(defmacro λ! (&rest body)
+  `(lambda () ,@body))
+(defmacro add-hook! (hook &rest body)
+  `(add-hook ,hook (lambda() ,@body)))
+
+;; Backwards compatibility
+(unless (fboundp 'with-eval-after-load)
+  (defmacro with-eval-after-load (file &rest body)
+    `(eval-after-load ,file
+       `(funcall (function ,(lambda () ,@body))))))
+
+(defmacro after (feature &rest forms)
+  `(,(if (or (not (boundp 'byte-compile-current-file))
+             (not byte-compile-current-file)
+             (if (symbolp feature)
+                 (require feature nil :no-error)
+               (load feature :no-message :no-error)))
+         'progn
+       (message "after: cannot find %s" feature)
+       'with-no-warnings)
+    (with-eval-after-load ',feature ,@forms)))
+
+;; vimmish keymapping shortcuts
+(defalias 'defcmd 'evil-ex-define-cmd)
+
+(defmacro ibind (key command)
+  `(key-chord-define evil-insert-state-map ,key ,command))
+
+(defun bind (state &rest keys)
+  (let ((state-list state)
+        (is-global (or (stringp state)
+                       (vectorp state)))
+        keymap)
+
+    (if is-global
+        (setq keys (-insert-at 0 state keys))
+      (progn
+        (if (keymapp (first keys))
+            (setq keymap (pop keys)))
+
+        (if (or (keymapp state)
+                (not (listp state)))
+            (setq state-list (list state)))))
+
+    (while keys
+      (let ((-key (pop keys))
+            (-def (pop keys)))
+
+        (if is-global
+            (global-set-key -key -def)
+          (dolist (-state state-list)
+            (cond ((evil-state-p -state)
+                   (define-key
+                     (if keymap
+                         (evil-get-auxiliary-keymap keymap -state t)
+                       (evil-state-property -state :keymap t)) -key -def))
+                  ((keymapp -state)
+                   (define-key -state -key -def)))))))))
+
+
+;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun enable-comment-hard-wrap ()
+  (set (make-local-variable 'comment-auto-fill-only-comments) t)
+  (turn-on-auto-fill))
+
+(defun enable-tab-width-2 ()
+  (setq tab-width 2
+        evil-shift-width 2))
+
+(defun disable-final-newline ()
+  (set (make-local-variable 'require-final-newline) nil))
+
+
+;;; Text Defuns ;;;;;;;;;;;;;;;;;;;;;;;;
+(defun my/surrounded-p ()
+  (and (looking-back "[[{(]\\(\s+\\|\n\\)?\\(\s\\|\t\\)*")
+       (let* ((whitespace (match-string 1))
+              (match-str (concat whitespace (match-string 2) "[])}]")))
+         (looking-at-p match-str))))
+
+(defun my/empty-line-p ()
+  (zerop (length (s-trim (my/get-line)))))
+
+(defun my/get-line ()
+  (buffer-substring (line-beginning-position) (line-end-position)))
+
+(defun my.backward-kill-to-bol-and-indent ()
+  "Kill line to the first non-blank character. If invoked again
+afterwards, kill line to column 1."
+  (interactive)
+  (let ((empty-line (my/empty-line-p)))
+    (evil-delete (point-at-bol) (point))
+    (if (not empty-line)
+        (indent-according-to-mode))))
+
+(defun my.point-at-first-non-blank()
+  (save-excursion (evil-first-non-blank) (point)))
+
+(defun my.move-to-bol ()
+  "Moves cursor to the first non-blank character on the line. If
+already there, move it to the true bol."
+  (interactive)
+  (evil-save-goal-column
+    (let ((point-at-bol (my.point-at-first-non-blank))
+          (point (point)))
+      (if (= point-at-bol point)
+          (evil-move-beginning-of-line)
+        (unless (= (point-at-bol) point)
+          (evil-first-non-blank))))))
+
+(defun my.move-to-eol ()
+  (interactive)
+  (evil-save-goal-column
+    (let ((old-point (point)))
+      (when (comment-search-forward (point-at-eol) t)
+        (goto-char (match-beginning 0))
+        (skip-syntax-backward " ^<*" (my.point-at-first-non-blank))
+
+        (if (eq old-point (point)) ;
+            (evil-move-end-of-line))))))
+
+;; Mimic expandtab in vim
+(defun my.backward-delete-whitespace-to-column ()
+  "Delete back to the previous column of whitespace, or as much
+whitespace as possible, or just one char if that's not possible."
+  (interactive)
+  (cond ;; If in a string
+        ((sp-point-in-string)
+         (call-interactively 'backward-delete-char-untabify))
+        ;; If using tabs (or at bol), just delete normally
+        ((or indent-tabs-mode
+             (= (point-at-bol) (point)))
+         (call-interactively 'backward-delete-char))
+        ;; Otherwise, delete up to the nearest tab column
+        (t (let ((movement (% (current-column) tab-width))
+                 (p (point)))
+             (when (= movement 0)
+               (setq movement tab-width))
+             (save-match-data
+               (if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p))
+                   (backward-delete-char (- (match-end 1) (match-beginning 1)))
+                 (call-interactively 'backward-delete-char-untabify)))))))
+
+(defun my.dumb-indent ()
+  "Inserts a tab character (or spaces x tab-width). Checks if the
+auto-complete window is open."
+  (interactive)
+  (if indent-tabs-mode
+      (insert "\t")
+    (let* ((movement (% (current-column) tab-width))
+           (spaces (if (zerop movement) tab-width (- tab-width movement))))
+      (insert (s-repeat spaces " ")))))
+
+(defun my.inflate-space-maybe ()
+  "Checks if point is surrounded by {} [] () delimiters and adds a
+space on either side of the point if so."
+  (interactive)
+  (if (my/surrounded-p)
+      (progn (call-interactively 'self-insert-command)
+             (save-excursion (call-interactively 'self-insert-command)))
+    (call-interactively 'self-insert-command)))
+
+(defun my.deflate-space-maybe ()
+  "Checks if point is surrounded by {} [] () delimiters, and deletes
+spaces on either side of the point if so. Resorts to
+`my.backward-delete-whitespace-to-column' otherwise."
+  (interactive)
+  (save-match-data
+    (if (my/surrounded-p)
+        (let ((whitespace-match (match-string 1)))
+          (cond ((not whitespace-match)
+                 (call-interactively 'delete-backward-char))
+                ((string-match "\n" whitespace-match)
+                 (evil-delete (point-at-bol) (point))
+                 (delete-char -1)
+                 (save-excursion (delete-char 1)))
+                (t
+                 (just-one-space 0))))
+      (my.backward-delete-whitespace-to-column))))
+
+(defun my.newline-and-indent ()
+  "Newline and indent; if in a comment, auto-comment and properly
+indent the next line."
+  (interactive)
+  (cond ((sp-point-in-string)
+         (evil-ret))
+        ((evil-in-comment-p)
+         (if (eq major-mode 'js2-mode)
+             (js2-line-break)
+           (call-interactively 'indent-new-comment-line)))
+        (t
+         (evil-ret-and-indent))))
+
+(defun s-lines? (s) (length (s-lines s)))
+
+
+;; Utility ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun what-face (pos)
+  "Tells you the name of the face (point) is on."
+  (interactive "d")
+  (let ((face (or (get-char-property (point) 'read-face-name)
+                  (get-char-property (point) 'face))))
+    (if face (message "Face: %s" face) (message "No face at %d" pos))))
+
+(defun what-col ()
+  (interactive)
+  (message "Column %d" (current-column)))
+
+(defun my/append-to-list (list-var elements)
+  "Append ELEMENTS to the end of LIST."
+  (unless (consp elements)
+    (error "ELEMENTS must be a list"))
+  (let ((list (symbol-value list-var)))
+    (if list
+        (setcdr (last list) elements)
+      (set list-var elements)))
+  (symbol-value list-var))
+
+(defun my/project-root (&optional force-pwd)
+  (if (and (not force-pwd)
+           (projectile-project-p))
+      (projectile-project-root)
+    default-directory))
+
+(defmacro f--exists? (file dir)
+  `(f-exists? (expand-file-name ,file ,dir)))

init/core-editor.el

@@ -2,134 +2,112 @@
 
 ;;;; Editor behavior ;;;;;;;;;;;;;;;;
 (setq sentence-end-double-space nil)
-(setq require-final-newline t)
+;; (setq require-final-newline nil)
+;; (setq mode-require-final-newline nil)
+(setq-default fill-column 80)
+(electric-indent-mode -1)   ; In case of emacs 24.4
+(setq-default tab-width 4
+              tab-always-indent nil
+              indent-tabs-mode nil)     ; spaces instead of tabs
 
-(setq-default tab-width 4)
+;; Show tab characters
-(setq-default indent-tabs-mode nil)
+(global-whitespace-mode 1)
-(setq-default tab-always-indent nil)
+(setq whitespace-style '(face tabs tab-mark) ; needs to be re-set in every buffer
-
+      whitespace-display-mappings
-;; In case of emacs 24.4
+      '((tab-mark   ?\t   [?| ?\t] [?\\ ?\t])
-(electric-indent-mode -1)
+        (newline-mark 10 [36 10])))
-
-;; Remember undo history
-(setq undo-tree-auto-save-history t)
-(setq undo-tree-history-directory-alist `((".*" . ,*tmp-dir-undo)))
-
-;; Save cursor location across sessions
-(require 'saveplace)
-(setq-default save-place t)
-(setq save-place-file (f-expand "saveplace" *tmp-dir))
-
-;; Save history across sessions
-(setq savehist-additional-variables
-      ;; search entries
-      '(search ring regexp-search-ring)
-      ;; keep the home clean
-      savehist-file (f-expand "savehist" *tmp-dir))
-(savehist-mode 1)
 
 ;;;; Modes 'n hooks ;;;;;;;;;;;;;;;;;
-(associate-mode "\\.plist$" nxml-mode)
+(associate-mode "/LICENSE[^/]*$"                     'text-mode)
-(associate-mode "zsh\\(env\\|rc\\)?$" shell-script-mode)
+(associate-mode "zsh\\(env\\|rc\\)?$"                'sh-mode)
-(associate-mode "z\\(profile\\|login\\|logout\\)?$" shell-script-mode)
+(associate-mode "z\\(profile\\|login\\|logout\\)?$"  'sh-mode)
-(associate-mode "zsh/" shell-script-mode)
+(associate-mode "zsh/"                               'sh-mode)
-(associate-mode "\\.applescript$" applescript-mode)
+(associate-mode "\\.applescript$"                    'applescript-mode)
-(associate-mode "Cask$" emacs-lisp-mode)
+(associate-mode "Cask$"                              'emacs-lisp-mode)
-(associate-mode "\\.el\\.gz$" emacs-lisp-mode)
+(associate-mode "\\.el\\.gz$"                        'emacs-lisp-mode)
+(associate-mode "/Makefile$"                         'makefile-gmake-mode)
+(associate-mode "\\.plist$"                          'nxml-mode)
 
-(add-hook 'text-mode-hook 'enable-hard-wrap)
-(add-hook 'prog-mode-hook 'enable-comment-hard-wrap)
 (add-hook 'before-save-hook 'delete-trailing-whitespace)
+;; Kill special (\\*.+\\*) buffers that are buried
+(run-with-idle-timer 10 t 'my:kill-other-buffers)
 
-;;;; Evil-mode ;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;; Evil ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (use-package evil
-  :diminish undo-tree-mode
+  :pre-load (defvar evil-want-C-u-scroll t)
-  :config
+  :init
   (progn
     (evil-mode 1)
 
+    (setq evil-want-visual-char-semi-exclusive t
+          evil-search-module 'evil-search
+          evil-magic 'very-magic
+
+          ;; Color-coded state cursors
+          evil-normal-state-cursor '("white" box)
+          evil-visual-state-cursor '("cyan" box)
+          evil-god-state-cursor '("orange" box))
+
+    ;; Fixes C-i's synonymity with TAB
+    (keyboard-translate ?\C-i ?\H-i)
+
     (add-hook! 'find-file-hook (setq evil-shift-width tab-width))
 
-    (setq evil-search-module 'evil-search)
+    ;; modes to map to different default states
-    (setq evil-magic 'very-magic)
+    (dolist (mode-map '((cider-repl-mode . emacs)
-    ;; Color-coded state cursors
+                        (comint-mode . emacs)
-    (setq evil-normal-state-cursor '("white" box))
+                        (eshell-mode . emacs)
-    (setq evil-visual-state-cursor '("cyan" box))
+                        (fundamental-mode . normal)
-    (setq evil-god-state-cursor '("orange" box))
+                        (git-commit-mode . insert)
-
+                        (git-rebase-mode . emacs)
-    (evil-set-initial-state 'comint-mode 'insert)
+                        (help-mode . normal)
+                        (term-mode . emacs)))
+      (evil-set-initial-state `,(car mode-map) `,(cdr mode-map)))
 
     (use-package evil-ex-registers)
     (use-package evil-exchange)
-    (use-package evil-indent-textobject)
+    (use-package evil-indent-textobject)    ; vii/vai/vaI
     (use-package evil-numbers)
     (use-package evil-visualstar)
-
+    (use-package evil-nerd-commenter  :pre-load (setq evilnc-hotkey-comment-operator "g/"))
-    (use-package evil-nerd-commenter
+    (use-package evil-space           :init (evil-space-default-setup))
-      :pre-load (setq evilnc-hotkey-comment-operator "g/"))
+    (use-package evil-matchit         :init (global-evil-matchit-mode 1))
-
+    (use-package evil-surround        :init (global-evil-surround-mode 1))
+    (use-package evil-god-state)
     (use-package evil-jumper
-      :pre-load
+      :pre-load (defvar evil-jumper-file (expand-file-name "jumplist" *tmp-dir))
-      (defvar evil-jumper-file (expand-file-name "jumplist" *tmp-dir))
-      :config
-      (setq evil-jumper-auto-center t
-            evil-jumper-auto-save-interval 3600))
-
-    (use-package evil-space
-      :init (evil-space-default-setup))
-    (use-package evil-matchit
-      :init (global-evil-matchit-mode 1))
-    (use-package evil-surround
-      :init (global-evil-surround-mode 1)
       :config
       (progn
-        ;; Adds escaped delimiters to evil-surround
+        (setq evil-jumper-auto-center t
-        (defun my.evil-surround-escaped-pair ()
+              evil-jumper-auto-save-interval 3600)
-          "Evil-surround function to allow escaped delimiters. e.g. \"...\""
-          (let* ((input (format "\\%s" (char-to-string (read-char "\\")))))
-            ;; Type \\ to simply surround in single backslashes
-            (if (= input "\\\\")
-                (cons "\\" "\\")
-              (cons input input))))
-        (setq-default evil-surround-pairs-alist (cons '(?\\ . my.evil-surround-escaped-pair) evil-surround-pairs-alist))))
 
-    (use-package god-mode)
+        (define-key evil-motion-state-map (kbd "H-i") 'evil-jumper/forward)))
-    (use-package evil-god-state :diminish god-local-mode)
-
-    (defmap evil-ex-completion-map
-      (kbd "C-r")           #'evil-ex-paste-from-register   ; registers in ex-mode
-      (kbd "C-a")            'move-beginning-of-line
-      (kbd "<s-left>")       'move-beginning-of-line
-      (kbd "<s-right>")      'move-beginning-of-line
-      (kbd "<s-backspace>")  'evil-delete-whole-line)
 
+    ;;;; ace-jump ;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Enable half-cursor blink when using ace-jump
-    (defadvice evil-ace-jump-char-mode (before evil-ace-jump-char-mode-operator-mode activate)
+    (defadvice evil-ace-jump-char-mode (before evil-ace-jump-char-mode-op activate) (evil-half-cursor))
-      (evil-half-cursor))
+    (defadvice evil-ace-jump-word-mode (before evil-ace-jump-word-mode-op activate) (evil-half-cursor))
-    (defadvice evil-ace-jump-word-mode (before evil-ace-jump-word-mode-operator-mode activate)
+    (setq ace-jump-mode-scope 'global) ; limit ace-jump to current window
-      (evil-half-cursor))
+    (setq ace-jump-mode-move-keys      ; use a-z, 0-9
+          (nconc (loop for i from ?a to ?z collect i)
+                 (loop for i from ?A to ?Z collect i)))
+    ;; (setq ace-jump-mode-move-keys      ; use a-z
+    ;;       (loop for i from ?a to ?z collect i))
 
     ;; Exit evil-exchange mode with <Esc> (silently) -- and close
     ;; minibuffer remotely if it happens to be left open
     (defadvice evil-force-normal-state (before evil-esc-quit-exchange activate)
       (shut-up (evil-exchange-cancel)
-               (if (minibufferp)
+               (if (minibuffer-window-active-p (minibuffer-window))
                    (my:minibuffer-quit))))
 
-    ;; Shut up beginning/end of buffer/line messages in minibuffer
+    (defadvice evil-visual-line (before spc-for-line-jump activate)
-    (defun my.minibuffer-bolp ()
+      (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-line-mode))
-      "Return t if (point) is truly at the beginning of the
+    (defadvice evil-visual-char (before spc-for-char-jump activate)
-minibuffer/evil-ex (first character after the prompt), otherwise
+      (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-char-mode))
-returns nil."
+    (defadvice evil-visual-block (before spc-for-char-jump activate)
-      (<= (- (point) (minibuffer-prompt-end)) 0))
+      (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-char-mode))
-    (defadvice left-char (around left-char-move-on-edges activate)
-      (if (minibufferp)
-          (unless (my.minibuffer-bolp) ad-do-it)
-        ad-do-it))
-    (defadvice right-char (around right-char-move-on-edges activate)
-      (if (minibufferp)
-          (unless (eolp) ad-do-it)
-        ad-do-it))
 
     ;; Switch to new splits after splitting
     (defadvice evil-window-split (after evil-window-split-then-switch activate)
@@ -174,69 +152,12 @@ returns nil."
                                         "\\1" file-name t)))
       file-name)))
 
-;;;; Keymap Fixes ;;;;;;;;;;;;;;;;;;;;;;
-;; This section is dedicated to keymaps that "fix" certain keys to
-;; behave to be more like vim (or how I like it).
-
-;; Restores "dumb" indentation to the tab key. This rustles a lot of
-;; peoples' jimmies, apparently, but it's how I like it.
-(-imap (kbd "TAB") 'my.dumb-indent)
-;; Except for lisp
-(imap lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command)
-(imap emacs-lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command)
-
-;; Highjacks backspace and space to:
-;;   a) expand spaces between delimiters intelligently: (|) -> ( | )
-;;   b) the reverse of A: ( | ) -> (|)
-;;   c) allow backspace to delete indented blocks intelligently
-;;   d) and not do any of this magic when inside a string
-(-imap (kbd "SPC")                              'my.inflate-space-maybe
-       [remap backward-delete-char-untabify]    'my.deflate-space-maybe
-       [remap newline]                          'my.newline-and-indent
-
-       ;; Smarter move-to-beginning-of-line
-       [remap move-beginning-of-line]           'my.move-to-bol
-
-       ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist
-       "\C-e" 'my.move-to-eol
-       "\C-u" 'my.backward-kill-to-bol-and-indent
-
-       ;; Fix osx keymappings
-       (kbd "<s-left>")      'my.move-to-bol
-       (kbd "<s-right>")     'my.move-to-eol
-       (kbd "<s-backspace>") 'my.backward-kill-to-bol-and-indent
-
-       ;; Fixes delete
-       (kbd "<kp-delete>")   'delete-char
-
-       ;; Textmate-esque insert-line before/after
-       (kbd "<s-return>")    'evil-open-below
-       (kbd "<S-s-return>")  'evil-open-above)
-
-(add-hook! 'ido-setup-hook
-           (defmap ido-completion-map
-             (kbd "<backspace>")  'ido-delete-backward-updir
-             "\C-w"               'ido-delete-backward-word-updir))
-
-;; Make ESC quit all the things
-(global-set-key [escape] 'keyboard-escape-quit)
-(mapc (lambda (map)
-    (defmap map [escape] 'my:minibuffer-quit))
-      (list minibuffer-local-map
-            minibuffer-local-ns-map
-            minibuffer-local-completion-map
-            minibuffer-local-must-match-map
-            minibuffer-local-isearch-map))
-(defmap isearch-mode-map [escape] 'isearch-abort)
-(defmap evil-god-state-map [escape] 'evil-god-state-bail)
-(defmap evil-ex-search-keymap [escape] 'evil-ex-search-exit)
-;; Close help/compilation windows with escape
-(defmap help-mode-map [escape] 'kill-buffer-and-window)
-(defmap compilation-mode-map [escape] 'kill-buffer-and-window)
-(emap debugger-mode-map [remap evil-exit-emacs-state] 'kill-buffer-and-window)
 
 ;;;; Editing plugins ;;;;;;;;;;;;;;;;;;;
-(use-package expand-region)
+(use-package anzu :init (global-anzu-mode))
+(use-package expand-region :commands (er/expand-region er/contract-region))
+(use-package rotate-text :commands (rotate-word-at-point rotate-region))
+(use-package smart-forward)
 
 (use-package smartparens
   :config
@@ -255,49 +176,82 @@ returns nil."
     (sp-with-modes '(emacs-lisp-mode lisp-mode)
       (sp-local-pair "[" nil :post-handlers '(("|" "RET"))))
 
-    (sp-pair "[" nil :unless '(sp-point-before-word-p))
+    (sp-pair "[" nil :unless '(sp-point-before-word-p sp-point-before-same-p))
-    (sp-pair "(" nil :unless '(sp-point-before-word-p))
+    (sp-pair "(" nil :unless '(sp-point-before-word-p sp-point-before-same-p))
-    (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p))
+    (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p))
-    (sp-pair "'" nil :unless '(sp-point-after-word-p sp-point-before-word-p))
+    (sp-pair "'" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p))
+    (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p))
 
     (after yasnippet
            (defadvice yas-expand (before advice-for-yas-expand activate)
              (sp-remove-active-pair-overlay)))))
 
-(use-package anzu
-  :diminish anzu-mode
-  :init
-  (global-anzu-mode))
 
-;;;; Utility plugins ;;;;;;;;;;;;;;;;;;
+;;;; Keymap Fixes ;;;;;;;;;;;;;;;;;;;;;;
-(use-package key-chord
+;; This section is dedicated to keymaps that "fix" certain keys so
-  :init
+;; that they behave more like vim (or how I like it).
-  (progn (key-chord-mode 1)
-         (setq key-chord-two-keys-delay 0.5)))
 
-(use-package smex
+;; Restores "dumb" indentation to the tab key. This rustles a lot of
-  :commands (smex smex-major-mode-commands)
+;; peoples' jimmies, apparently, but it's how I like it.
-  :config
+(bind 'insert (kbd "TAB") 'my.dumb-indent)
-  (progn (smex-initialize)
+;; Except for lisp
-         ;; Hook up smex to auto-update, rather than update on every run
+(bind 'insert lisp-mode-map        [remap my.dumb-indent] 'indent-for-tab-command)
-         (defun smex-update-after-load (unused)
+(bind 'insert emacs-lisp-mode-map  [remap my.dumb-indent] 'indent-for-tab-command)
-           (when (boundp 'smex-cache) (smex-update)))
-         (add-hook 'after-load-functions 'smex-update-after-load)))
 
-(use-package recentf
+;; Highjacks backspace and space to:
-  :init
+;;   a) expand spaces between delimiters intelligently: (|) -> ( | )
-  (progn (recentf-mode 1)
+;;   b) the reverse of A: ( | ) -> (|)
-         (setq recentf-max-menu-items 0
+;;   c) allow backspace to delete indented blocks intelligently
-               recentf-max-saved-items 100
+;;   d) and not do any of this magic when inside a string
-               recentf-auto-cleanup 'never
+(bind 'insert
-               recentf-exclude '("/tmp/" "/ssh:" "\\.ido\\.last\\'" "\\.revive\\'", "TAGS", "GEMTAGS"))))
+      (kbd "SPC")                              'my.inflate-space-maybe
+      [remap backward-delete-char-untabify]    'my.deflate-space-maybe
+      [remap newline]                          'my.newline-and-indent
 
-(use-package re-builder
+      ;; Smarter move-to-beginning-of-line
-  :defer t
+      [remap move-beginning-of-line]           'my.move-to-bol
-  :config
+
-  (progn (setq reb-re-syntax 'string)
+      ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist
-         (defadvice evil-force-normal-state (before evil-esc-quit-reb-mode activate)
+      "\C-e" 'my.move-to-eol
-           (when (eq 'reb-mode major-mode)
+      "\C-u" 'my.backward-kill-to-bol-and-indent
-             (if reb-subexp-mode
+
-                 (reb-quit-subexp-mode)
+      ;; Fixes delete
-               (reb-quit))))))
+      (kbd "<kp-delete>")   'delete-char
+
+      ;; Textmate-esque insert-line before/after
+      (kbd "<s-return>")    'evil-open-below
+      (kbd "<S-s-return>")  'evil-open-above)
+
+;; Fix osx keymappings and then some
+(bind (kbd "<s-left>")      'my.move-to-bol
+      (kbd "<s-right>")     'my.move-to-eol
+      (kbd "<s-up>")        'smart-up
+      (kbd "<s-down>")      'smart-down
+      (kbd "<s-backspace>") 'my.backward-kill-to-bol-and-indent)
+
+(add-hook! 'ido-setup-hook
+           (bind ido-completion-map
+             (kbd "<backspace>")  'ido-delete-backward-updir
+             "\C-w"               'ido-delete-backward-word-updir))
+
+;; Make ESC quit all the things
+(bind [escape] 'keyboard-escape-quit)
+(bind (list minibuffer-local-map
+              minibuffer-local-ns-map
+              minibuffer-local-completion-map
+              minibuffer-local-must-match-map
+              minibuffer-local-isearch-map) [escape] 'my:minibuffer-quit)
+
+(bind 'god [escape] 'evil-god-state-bail)
+(bind 'normal special-mode-map [escape] 'popwin:close-popup-window)
+(bind isearch-mode-map "\C-w" 'isearch-abort)
+;; Close help/compilation windows with escape
+(bind messages-buffer-mode-map [escape] 'kill-this-buffer)
+(bind special-mode-map [escape] 'popwin:close-popup-window)
+;;(bind 'normal diff-mode-map
+;;  [escape] 'kill-this-buffer
+;;  "q" 'kill-this-buffer)
+; (bind 'normal c
+; scope-minor-mode-keymap
+;   [escape] 'kill-this-buffer
+;   "q" 'kill-this-buffer)

init/core-osx.el

@@ -11,4 +11,11 @@
   ;; fix emacs PATH on OSX (GUI only)
   (use-package exec-path-from-shell
     :if (memq window-system '(mac ns))
-    :init (exec-path-from-shell-initialize)))
+    :init (exec-path-from-shell-initialize))
+
+  ;; On OSX, stop copying each visual state move to the clipboard:
+  ;; https://bitbucket.org/lyro/evil/issue/336/osx-visual-state-copies-the-region-on
+  ;; Most of this code grokked from:
+  ;; http://stackoverflow.com/questions/15873346/elisp-rename-macro
+  (defadvice evil-visual-update-x-selection (around clobber-x-select-text activate)
+    (unless (featurep 'ns) ad-do-it)))

init/core-ui.el

@@ -1,30 +1,43 @@
 (provide 'core-ui)
 
-;; (global-linum-mode t)   ; line numbers for everybody!
+;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;;
-(blink-cursor-mode -1)
+(setq ring-bell-function 'ignore)
-(global-hl-line-mode 1)
+(add-to-list 'default-frame-alist `(font . ,*font))
+(add-to-list 'default-frame-alist '(alpha . 100))   ; *slightly* transparent window
 
+(when (functionp 'scroll-bar-mode) (scroll-bar-mode -1))    ; no scrollbar
+(when (functionp 'tool-bar-mode) (tool-bar-mode -1))        ; no toolbar
+(when (functionp 'menu-bar-mode) (menu-bar-mode -1))        ; no menubar
+(when (fboundp 'fringe-mode) (fringe-mode '(5 . 10)))       ; no nonsense
+
+(defun toggle-transparency ()
+  (interactive)
+  (let ((frame (selected-frame)))
+    (if (= (frame-parameter frame 'alpha) 0)
+        (set-frame-parameter frame 'alpha 100)
+      (set-frame-parameter frame 'alpha 0))))
+
+
+;;;; Other Settings ;;;;;;;;;;;;;;;;;;;;
+(blink-cursor-mode 1)       ; blink cursor
+(global-hl-line-mode -1)    ; highlight line
+(line-number-mode 1)        ; hide line no in modeline
+(column-number-mode 1)      ; hide col no in modeline
+(show-paren-mode -1)         ; highlight matching delimiters
 (setq show-paren-delay 0)
-(show-paren-mode 1)
 
-;; Multiple cursors across buffers cause a strange redraw delay for
+(setq linum-format (quote "%4d "))
-;; some things, like auto-complete or evil-mode's cursor color
+;; (add-hook 'text-mode-hook 'linum-mode)
-;; switching.
+;; (add-hook 'prog-mode-hook 'linum-mode)
-(setq-default cursor-in-non-selected-windows nil)
-
-;; Show line/col-no in mode-line
-(line-number-mode t)
-(column-number-mode t)
-;; make the fringe unintrusive
-(when (fboundp 'fringe-mode)
-  (fringe-mode '(0 . 10)))
 
 ;; Show full path in window title
 (setq frame-title-format
       '(:eval (if (buffer-file-name) (abbreviate-file-name (buffer-file-name)) "%b")))
 
-;; Whitespaces (activate whitespace-mode to see)
+;; Multiple cursors across buffers cause a strange redraw delay for
-(setq whitespace-style '(face trailing tab-mark))
+;; some things, like auto-complete or evil-mode's cursor color
+;; switching.
+(setq-default cursor-in-non-selected-windows nil)
 
 ;; do not soft-wrap lines
 (setq-default truncate-lines t)
@@ -32,40 +45,82 @@
 (add-hook! 'help-mode-hook (setq truncate-lines nil))
 
 (setq ediff-window-setup-function 'ediff-setup-windows-plain)
-
 (setq indicate-buffer-boundaries nil)
 (setq indicate-empty-lines nil)
+(setq-default visible-bell nil)   ; silence of the bells
+(setq-default use-dialog-box nil) ; avoid GUI
 
-(setq-default visible-bell nil)
-(setq-default use-dialog-box nil)
-
-;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;;
-(setq ring-bell-function 'ignore)
-(add-to-list 'default-frame-alist `(font . ,*font))
-(add-to-list 'default-frame-alist '(alpha 98 95))   ; *slightly* transparent window
-
-(when (functionp 'scroll-bar-mode) (scroll-bar-mode -1))
-(when (functionp 'tool-bar-mode) (tool-bar-mode -1))
-(when (functionp 'menu-bar-mode) (menu-bar-mode -1))
 
 ;;;; Modeline ;;;;;;;;;;;;;;;;;;;;;;;;;;
+(use-package uniquify
+  :config (setq uniquify-buffer-name-style 'post-forward
+                uniquify-separator ":"
+                uniquify-ignore-buffers-re "^\\*"))
+
 (use-package smart-mode-line
   :config
-  (mapc (lambda(mode) (add-to-list 'rm-excluded-modes mode))
+  (setq rm-blacklist
+        (mapconcat 'identity
                    '(" SP"
                      " Fill"
                      " yas"
                      " Fly"
                      " EvilOrg"
                      " Abbrev"
-          ))
+                     " WS"
+                     " GitGutter"
+                     " Anzu"
+                     " Undo-Tree"
+                     " AC"
+                     " Projectile\\[.+\\]"
+                     ) "\\|"))
   :init
   (progn
     (setq sml/no-confirm-load-theme t
           sml/mode-width      'full
+          sml/extra-filler    2
           sml/show-remote     nil
+          sml/modified-char   "*"
           sml/encoding-format nil)
-    (add-to-list 'sml/replacer-regexp-list '("^:DB:projects/" "PR:") t)
 
+    (setq sml/replacer-regexp-list '(("^~/Dropbox/Projects/" "PROJECTS:")
+                                     ("^~/.emacs.d/" "EMACS.D:")))
+
+    (after evil (setq evil-mode-line-format nil))
+
+    (setq-default mode-line-misc-info
+      '((which-func-mode ("" which-func-format ""))
+        (global-mode-string ("" global-mode-string ""))))
+
+    (add-hook! 'after-change-major-mode-hook
+               (setq mode-line-format
+                     '(" "
+                       "%e"
+                       ;; anzu--mode-line-format
+                       mode-line-mule-info
+                       mode-line-client
+                       mode-line-remote
+                       mode-line-frame-identification
+                       mode-line-buffer-identification
+                       mode-line-modified
+                       mode-line-modes
+                       mode-line-misc-info
+                       (vc-mode vc-mode)
+                       " "
+                       mode-line-position
+                       " "
+                       mode-line-front-space
+                       ))
+
+               (add-to-list 'mode-line-modes
+                            '(sml/buffer-identification-filling
+                              sml/buffer-identification-filling
+                              (:eval (setq sml/buffer-identification-filling
+                                           (sml/fill-for-buffer-identification))))))
+
+    (let ((-linepo mode-line-position))
       (sml/setup)
-    (sml/apply-theme 'respectful)))
+      (sml/apply-theme 'respectful)
+
+      (setq mode-line-position -linepo)
+      (sml/filter-mode-line-list 'mode-line-position))))

init/core.el

@@ -1,78 +1,91 @@
 (provide 'core)
 
-(require 'f)
-
 (defconst is-mac   (eq system-type 'darwin))
 (defconst is-linux (eq system-type 'gnu/linux))
 
-;; Setup theme
+;;;; Load theme ;;;;;;;;;;;;;;;;;;;;;;;;;;
 (add-to-list 'custom-theme-load-path *themes-dir)
 (load-theme *theme t)
 
-;; Emacs under-the-hood
-(global-auto-revert-mode 1)         ; revert buffers for changed files
-(fset 'yes-or-no-p 'y-or-n-p)       ; y/n instead of yes/no
 
+;;;; Emacs under the hood ;;;;;;;;;;;;;;;;
 (prefer-coding-system 'utf-8)
-(setq-default load-prefer-newer t           ; load newer .el over older .elc
+(fset 'yes-or-no-p 'y-or-n-p)            ; y/n instead of yes/no
+(setq-default
+      load-prefer-newer t                ; load newer .el over older .elc
       gc-cons-threshold 50000000         ; avoid garbage collection (default is 400k)
       enable-recursive-minibuffers nil
       redisplay-dont-pause t
       confirm-kill-emacs nil
       compilation-scroll-output t)
 
-;; Show keystrokes
-(setq echo-keystrokes 0.02)
-
 ;; Sane scroll settings
-(setq scroll-margin 3
+(setq scroll-margin 5
       scroll-conservatively 100000
-      scroll-preserve-screen-position 1)
+      scroll-preserve-screen-position 1
-
+      echo-keystrokes 0.02               ; Show keystrokes
-(setq inhibit-startup-screen t      ; don't show EMACs start screen
+      inhibit-startup-screen t           ; don't show EMACs start screen
       inhibit-splash-screen t
       inhibit-startup-buffer-menu t
-      inhibit-startup-echo-area-message t
       initial-major-mode 'text-mode
       initial-scratch-message nil
       initial-scratch-buffer nil)        ; empty scratch buffer
 
-;;; Backups
+;; Make sure undo/backup folders exist
+(require 'f)
 (defconst *tmp-dir-undo     (f-expand "undo" *tmp-dir))
 (defconst *tmp-dir-backup   (f-expand "backup" *tmp-dir))
+(defconst *tmp-dir-autosave (f-expand "autosave" *tmp-dir))
 (unless (f-dir? *tmp-dir)
-  (f-mkdir *tmp-dir *tmp-dir-undo *tmp-dir-backup))
+  (f-mkdir *tmp-dir
-
+           *tmp-dir-undo
-(setq make-backup-files         nil       ; Don't want any backup
+           *tmp-dir-backup
-      auto-save-list-file-name  nil       ; Don't want any .saves
+           *tmp-dir-autosave))
-      auto-save-default         nil       ; Don't want any auto saving
-      create-lockfiles          nil)
 
+;; Disable all backups (that's what git/dropbox are for)
+(setq make-backup-files         nil
+      create-lockfiles          nil
+      auto-save-default         nil
+      auto-save-list-file-name  (concat *tmp-dir-autosave ".auto-save")
       ;; In case I want to reactivate backup files
-(setq backup-directory-alist `((".*" . ,*tmp-dir-backup)))
+      backup-directory-alist `((".*" . ,*tmp-dir-backup))
+      auto-save-file-name-transforms `((".*" ,*tmp-dir-autosave t)))
 
-;; window layout undo/redo, keymaps in core-keymaps.el
+;; Remember undo history
-(when (fboundp 'winner-mode) (winner-mode 1))
+(setq-default undo-tree-history-directory-alist `(("." . ,*tmp-dir-undo)))
+(setq-default undo-tree-auto-save-history t)
 
-;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Save history across sessions
+;; search entries
+(defvar savehist-additional-variables '(search ring regexp-search-ring))
+;; keep the home clean
+(defvar savehist-file (f-expand "savehist" *tmp-dir))
+(savehist-mode 1)
+
+
+;;;; My personal global mode ;;;;;;;;;;;;;
+(defvar my-mode-map (make-sparse-keymap))
+(define-minor-mode my-mode
+  "My personal global mode."
+  :global t
+  :keymap my-mode-map)
+
+
+;;;; Behavior adjustments ;;;;;;;;;;;;;;;;
 ;; Make next/previous-buffer skip special buffers
-(defadvice next-buffer (after avoid-messages-buffer-in-next-buffer activate)
+(defadvice next-buffer (after void-messages-buffer-in-next-buffer activate)
   "Advice around `next-buffer' to avoid going into the *Messages* buffer."
   (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (next-buffer)))
 (defadvice previous-buffer (after avoid-messages-buffer-in-previous-buffer activate)
   "Advice around `previous-buffer' to avoid going into the *Messages* buffer."
   (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (previous-buffer)))
 
-;;;; My personal minor mode ;;;;;;;;
-(defvar my-mode-map (make-sparse-keymap))
-(define-minor-mode my-mode :global t :keymap my-mode-map)
 
-;; Automatic minor modes
+;;;; Automatic minor modes ;;;;;;;;;;;;;;;
 (defvar auto-minor-mode-alist ()
   "Alist of filename patterns vs correpsonding minor mode functions,
 see `auto-mode-alist' All elements of this alist are checked, meaning
 you can enable multiple minor modes for the same regexp.")
-
 (defun enable-minor-mode-based-on-extension ()
   "check file name against auto-minor-mode-alist to enable minor modes
 the checking happens for all pairs in auto-minor-mode-alist"
@@ -93,17 +106,54 @@ the checking happens for all pairs in auto-minor-mode-alist"
 
 (add-hook 'find-file-hook 'enable-minor-mode-based-on-extension)
 
-;;;; Load the rest ;;;;;;;;;;;;;;;;;;
+(global-auto-revert-mode 1)              ; revert buffers for changed files
 (require 'shut-up)
-(when noninteractive
+(when noninteractive (shut-up-silence-emacs))
-  (shut-up-silence-emacs))
 
+;; What we do every night, Pinkie...
+(defun my/greeter () (message "What're we gonna do tonight, Brain?"))
+(defalias 'display-startup-echo-area-message 'my/greeter)
+
+(when (fboundp 'winner-mode) (winner-mode 1))  ; window layout undo/redo
+
+
+;;;; Utility plugins ;;;;;;;;;;;;;;;;;;
 ;; Package management bootstrap
+(require 'use-package)
 (setq package-enable-at-startup nil
       delete-old-versions t)
-
+;; Add ./elisp/* to load-path
 (let ((default-directory *elisp-dir))
     (normal-top-level-add-to-load-path '("."))
     (normal-top-level-add-subdirs-to-load-path))
 
-(require 'use-package)
+(use-package key-chord
+  :init (key-chord-mode 1)
+  :config (setq key-chord-two-keys-delay 0.5))
+
+(use-package recentf
+  :init
+  (progn (setq recentf-max-menu-items 0
+               recentf-max-saved-items 100
+               recentf-auto-cleanup 'never
+               recentf-save-file (concat *tmp-dir "recentf")
+               recentf-exclude '("/tmp/" "/ssh:" "\\.?ido\\.last\\'" "\\.revive\\'", "/TAGS\\'"))
+         (recentf-mode 1)))
+
+(use-package smex
+  :commands (smex smex-major-mode-commands)
+  :config
+  (progn (smex-initialize)
+         ;; Hook up smex to auto-update, rather than update on every run
+         (defun smex-update-after-load (unused)
+           (when (boundp 'smex-cache) (smex-update)))
+         (add-hook 'after-load-functions 'smex-update-after-load)))
+
+(use-package popwin
+  :init (popwin-mode 1)
+  :config
+  (progn (setq popwin:popup-window-height 0.45)
+         (push '(diff-mode :position bottom :stick t) popwin:special-display-config)
+         (push '("*Backtrace*") popwin:special-display-config)
+         (push '("*Warnings*") popwin:special-display-config)
+         (push '("*Process List*") popwin:special-display-config)))

init/defuns/config.el

@@ -1,93 +0,0 @@
-;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;;
-(defmacro λ (&rest body)
-  `(lambda () (interactive) ,@body))
-
-(defmacro associate-mode (match mode)
-  `(add-to-list 'auto-mode-alist '(,match . ,mode)))
-
-(defmacro associate-minor-mode (match minor-mode)
-  `(add-to-list 'auto-minor-mode-alist '(,match . ,minor-mode)))
-
-(defmacro add-hook! (hook &rest body)
-  `(add-hook ,hook (lambda() ,@body)))
-
-;; Backwards compatibility
-(unless (fboundp 'with-eval-after-load)
-  (defmacro with-eval-after-load (file &rest body)
-    `(eval-after-load ,file
-       `(funcall (function ,(lambda () ,@body))))))
-
-(defmacro after (feature &rest forms)
-  `(,(if (or (not (boundp 'byte-compile-current-file))
-             (not byte-compile-current-file)
-             (if (symbolp feature)
-                 (require feature nil :no-error)
-               (load feature :no-message :no-error)))
-         'progn
-       (message "after: cannot find %s" feature)
-       'with-no-warnings)
-    (with-eval-after-load ',feature ,@forms)))
-
-;; vimmish keymapping shortcuts
-(defalias 'exmap 'evil-ex-define-cmd)
-(defmacro ichmap (key command)
-  `(key-chord-define evil-insert-state-map ,key ,command))
-(defmacro defmap (map &rest body)
-  `(evil-define-key nil ,map ,@body))
-
-(defmacro nmap (map &rest body)
-  `(evil-define-key 'normal ,map ,@body))
-(defmacro vmap (map &rest body)
-  `(evil-define-key 'visual ,map ,@body))
-(defmacro imap (map &rest body)
-  `(evil-define-key 'insert ,map ,@body))
-(defmacro emap (map &rest body)
-  `(evil-define-key 'emacs ,map ,@body))
-(defmacro gmap (map &rest body)
-  `(evil-define-key 'god ,map ,@body))
-(defmacro mmap (map &rest body)
-  `(evil-define-key 'motion ,map ,@body))
-(defmacro omap (map &rest body)
-  `(evil-define-key 'operator ,map ,@body))
-(defmacro nvmap (map &rest body)
-  (macroexpand
-   `(progn (nmap ,map ,@body)
-           (vmap ,map ,@body))))
-
-(defmacro nmap! (&rest body)
-  `(evil-define-key 'normal my-mode-map ,@body))
-(defmacro vmap! (&rest body)
-  `(evil-define-key 'visual my-mode-map ,@body))
-(defmacro imap! (&rest body)
-  `(evil-define-key 'insert my-mode-map ,@body))
-(defmacro emap! (&rest body)
-  `(evil-define-key 'emacs my-mode-map ,@body))
-(defmacro gmap! (&rest body)
-  `(evil-define-key 'god my-mode-map ,@body))
-(defmacro mmap! (&rest body)
-  `(evil-define-key 'motion my-mode-map ,@body))
-(defmacro omap! (&rest body)
-  `(evil-define-key 'operator my-mode-map ,@body))
-(defmacro nvmap! (&rest body)
-  (macroexpand
-   `(progn (nmap! ,@body)
-           (vmap! ,@body))))
-
-(defmacro -nmap (&rest body)
-  `(evil-define-key nil evil-normal-state-map ,@body))
-(defmacro -vmap (&rest body)
-  `(evil-define-key nil evil-visual-state-map ,@body))
-(defmacro -imap (&rest body)
-  `(evil-define-key nil evil-insert-state-map ,@body))
-(defmacro -emap (&rest body)
-  `(evil-define-key nil evil-emacs-state-map ,@body))
-(defmacro -gmap (&rest body)
-  `(evil-define-key nil evil-god-state-map ,@body))
-(defmacro -mmap (&rest body)
-  `(evil-define-key nil evil-motion-state-map ,@body))
-(defmacro -omap (&rest body)
-  `(evil-define-key nil evil-operator-state-map ,@body))
-(defmacro -nvmap (&rest body)
-  (macroexpand
-   `(progn (-nmap ,@body)
-           (-vmap ,@body))))

init/defuns/hooks.el

@@ -1,9 +0,0 @@
-(defun enable-hard-wrap()
-  (auto-fill-mode 1))
-
-(defun enable-comment-hard-wrap ()
-  (set (make-local-variable 'comment-auto-fill-only-comments) t)
-  (auto-fill-mode 1))
-
-(defun enable-tab-width-2 ()
-  (setq tab-width 2))

init/defuns/text.el

@@ -1,105 +0,0 @@
-;;; Library Defuns ;;;;;;;;;;;;;;;;;;;;;
-(defun my/surrounded-p ()
-  (and (looking-back "[[{(]\\(\s+\\|\n\\)?\\(\s\\|\t\\)*")
-       (let* ((whitespace (match-string 1))
-              (match-str (concat whitespace (match-string 2) "[])}]")))
-         (looking-at-p match-str))))
-
-(defun my/empty-line-p ()
-  (zerop (length (s-trim (my/get-line)))))
-
-(defun my/get-line ()
-  (buffer-substring (line-beginning-position) (line-end-position)))
-
-;;; Text Defuns ;;;;;;;;;;;;;;;;;;;;;;;;
-(defun my.backward-kill-to-bol-and-indent ()
-  "Kill line to the first non-blank character. If invoked again
-afterwards, kill line to column 1."
-  (interactive)
-  (let ((empty-line (my/empty-line-p)))
-    (evil-delete (point-at-bol) (point))
-    (if (not empty-line)
-        (indent-according-to-mode))))
-
-(defun my.move-to-bol ()
-  "Moves cursor to the first non-blank character on the line. If
-already there, move it to the true bol."
-  (interactive)
-  (let ((point-at-bol (save-excursion (evil-first-non-blank) (point))))
-    (if (= point-at-bol (point))
-        (evil-move-beginning-of-line)
-      (evil-first-non-blank))))
-
-(defun my.move-to-eol ()
-  (interactive)
-  (evil-move-end-of-line))
-
-;; Mimic expandtab in vim
-(defun my.backward-delete-whitespace-to-column ()
-  "Delete back to the previous column of whitespace, or as much
-whitespace as possible, or just one char if that's not possible."
-  (interactive)
-  (cond ;; If in a string
-        ((sp-point-in-string)
-         (call-interactively 'backward-delete-char-untabify))
-        ;; If using tabs (or at bol), just delete normally
-        ((or indent-tabs-mode
-             (= (point-at-bol) (point)))
-         (call-interactively 'backward-delete-char))
-        ;; Otherwise, delete up to the nearest tab column
-        (t (let ((movement (% (current-column) tab-width))
-                 (p (point)))
-             (when (= movement 0)
-               (setq movement tab-width))
-             (save-match-data
-               (if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p))
-                   (backward-delete-char (- (match-end 1) (match-beginning 1)))
-                 (call-interactively 'backward-delete-char-untabify)))))))
-
-(defun my.dumb-indent ()
-  "Inserts a tab character (or spaces x tab-width). Checks if the
-auto-complete window is open."
-  (interactive)
-  (if indent-tabs-mode
-      (insert "\t")
-    (let* ((movement (% (current-column) tab-width))
-           (spaces (if (zerop movement) tab-width (- tab-width movement))))
-      (insert (s-repeat spaces " ")))))
-
-(defun my.inflate-space-maybe ()
-  "Checks if point is surrounded by {} [] () delimiters and adds a
-space on either side of the point if so."
-  (interactive)
-  (if (my/surrounded-p)
-      (progn (insert " ")
-             (save-excursion (insert " ")))
-    (insert " ")))
-
-(defun my.deflate-space-maybe ()
-  "Checks if point is surrounded by {} [] () delimiters, and deletes
-spaces on either side of the point if so. Resorts to
-`my.backward-delete-whitespace-to-column' otherwise."
-  (interactive)
-  (save-match-data
-    (if (my/surrounded-p)
-        (let ((whitespace-match (match-string 1)))
-          (cond ((not whitespace-match)
-                 (call-interactively 'delete-backward-char))
-                ((string-match "\n" whitespace-match)
-                 (evil-delete (point-at-bol) (point))
-                 (delete-char -1)
-                 (save-excursion (delete-char 1)))
-                (t
-                 (just-one-space 0))))
-      (my.backward-delete-whitespace-to-column))))
-
-(defun my.newline-and-indent ()
-  "Newline and indent; if in a comment, auto-comment and properly
-indent the next line."
-  (interactive)
-  (cond ((sp-point-in-string)
-         (evil-ret))
-        ((evil-in-comment-p)
-         (indent-new-comment-line))
-        (t
-         (evil-ret-and-indent))))

init/defuns/utility.el

@@ -1,25 +0,0 @@
-(defun what-face (pos)
-  "Tells you the name of the face (point) is on."
-  (interactive "d")
-  (let ((face (or (get-char-property (point) 'read-face-name)
-                  (get-char-property (point) 'face))))
-    (if face (message "Face: %s" face) (message "No face at %d" pos))))
-
-(defun my/append-to-list (list-var elements)
-  "Append ELEMENTS to the end of LIST."
-  (unless (consp elements)
-    (error "ELEMENTS must be a list"))
-  (let ((list (symbol-value list-var)))
-    (if list
-        (setcdr (last list) elements)
-      (set list-var elements)))
-  (symbol-value list-var))
-
-(defun my/project-root (&optional force-pwd)
-  (if (and (not force-pwd)
-           (projectile-project-p))
-      (projectile-project-root)
-    default-directory))
-
-(defmacro f--exists? (file dir)
-  `(f-exists? (expand-file-name ,file ,dir)))

init/init-ac.el

@@ -1,31 +0,0 @@
-(provide 'init-ac)
-
-;;
-(use-package auto-complete
-  :diminish auto-complete-mode
-  :init
-  (progn
-    (require 'auto-complete-config)
-
-    (setq ac-auto-start nil
-          ac-auto-show-menu t        ; Suggestions box must be invoked manually (see core-keymaps.el)
-          ac-use-menu-map t          ; Enable ac-menu-map map when menu is open
-          ac-use-quick-help t        ; Don't show tooltips unless invoked (see core-keymaps.el)
-          ac-use-fuzzy nil
-          ac-candidate-limit 25)
-    (setq ac-comphist-file (concat *tmp-dir "ac-comphist.dat"))
-
-    (setq-default ac-sources '(ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers))
-    (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup)
-    (add-hook 'css-mode-hook 'ac-css-mode-setup)
-    (add-hook 'shell-script-mode-hook 'ac-add-files)
-    ;; (add-hook 'auto-complete-mode-hook 'ac-common-setup)
-    (global-auto-complete-mode t))
-  :config
-  (progn
-    (add-to-list 'ac-dictionary-files (expand-file-name "global" *ac-dicts-dir))
-    (add-to-list 'ac-dictionary-directories *ac-dicts-dir)
-    (add-to-list 'ac-modes 'nxml-mode)
-
-    ;; Tell ido not to care about case
-    (setq completion-ignore-case t)))

init/init-auto-complete.el

@@ -0,0 +1,68 @@
+(provide 'init-auto-complete)
+
+(setq tags-case-fold-search nil)
+
+(use-package auto-complete
+  :init
+  (progn
+    (require 'auto-complete-config)
+
+    (setq ac-auto-start nil
+          ac-auto-show-menu t        ; Suggestions box must be invoked manually (see core-keymaps.el)
+          ac-use-menu-map t          ; Enable ac-menu-map map when menu is open
+          ac-use-quick-help t        ; Don't show tooltips unless invoked (see core-keymaps.el)
+          ac-use-fuzzy t
+          ac-candidate-limit 25)
+    (setq ac-comphist-file (concat *tmp-dir "ac-comphist.dat"))
+
+    (setq-default ac-sources '(ac-source-yasnippet ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers))
+
+    (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup)
+    (add-hook 'css-mode-hook 'ac-css-mode-setup)
+    (add-hook 'shell-script-mode-hook 'ac-add-files)
+    ;; (add-hook 'auto-complete-mode-hook 'ac-common-setup)
+    )
+  :config
+  (progn
+    ;; Redefine this function so auto-complete is available [almost] everywhere
+    (defun auto-complete-mode-maybe ()
+      (unless (minibufferp (current-buffer))
+        (auto-complete-mode 1)))
+
+    (global-auto-complete-mode t)
+
+    (add-to-list 'ac-dictionary-files (expand-file-name "global" *ac-dicts-dir))
+    (add-to-list 'ac-dictionary-directories *ac-dicts-dir)
+
+    ;; Tell ido not to care about case
+    (setq completion-ignore-case t)
+
+    (bind 'insert ac-mode-map
+          (kbd "C-x C-k")   'ac-complete-dictionary
+          (kbd "C-x C-f")   'ac-complete-filename
+          (kbd "C-x C-]")   'ac-complete-etags
+          (kbd "C-x s")     'ac-complete-ispell
+          (kbd "C-x C-s")   'ac-complete-ispell-fuzzy
+          (kbd "C-x C-y")   'ac-complete-yasnippet
+          (kbd "C-x C-o")   'auto-complete
+          (kbd "C-SPC")     'auto-complete)
+
+    (bind ac-completing-map
+            (kbd "<tab>")  'ac-complete
+            (kbd "C-n")    'ac-next
+            (kbd "C-p")    'ac-previous
+            (kbd "<f1>")   'ac-quick-help
+            (kbd "C-<f1>") 'ac-help
+            (kbd "ESC")    'ac-stop
+            (kbd "RET")    'ac-complete)
+
+    (use-package ac-etags
+      :commands (ac-complete-etags)
+      :config (ac-etags-setup))
+
+    (use-package ac-ispell
+      :commands (ac-complete-ispell ac-complete-ispell-fuzzy)
+      :config
+      (progn (ac-ispell-setup)
+             (setq ac-ispell-requires 1
+                   ac-ispell-fuzzy-limit 25)))))

init/init-auto-insert.el

@@ -0,0 +1,82 @@
+(provide 'init-auto-insert)
+
+(use-package autoinsert)
+;; (setq auto-insert-directory "%/.emacs.d/templates/")
+(setq auto-insert-query nil)    ; Don't prompt before insertion
+(setq auto-insert-alist (list))    ; Don't prompt before insertion
+(auto-insert-mode 1)
+
+(after yasnippet
+    (defun template (file-regexp uuid mode &optional project-only)
+      (define-auto-insert file-regexp `(lambda () (template-insert ,uuid ',mode ,project-only))))
+    (defun template-insert (uuid mode &optional project-only)
+      "Expand snippet template in MODE by its UUID"
+      (unless (and project-only
+                   (not (projectile-project-p)))
+        (yas-expand-snippet
+         (yas--template-content
+          (yas--get-template-by-uuid mode uuid)) (point-min) (point-max))
+        (evil-insert-state)))
+
+    (template "/\\.gitignore$"                                          "%%"               'gitignore-mode)
+
+    ;; C/C++
+    (template "/Makefile$"                                              "%%"               'makefile-gmake-mode)
+    (template "/main\\.\\([Cc]\\|cc\\|cpp\\)$"                          "%main.cpp%"       'c++-mode)
+    (template "/win32_\\.\\([Cc]\\|cc\\|cpp\\)$"                        "%winmain.cpp%"    'c++-mode)
+    (template "\\.\\([Hh]\\|hpp\\)$"                                    "%.h%"             'c++-mode)
+    (template "\\.\\([Cc]\\|cc\\|cpp\\)$"                               "%.cpp%"           'c++-mode)
+
+    ;; Shell scripts
+    (template "\\.z?sh$"                                                "%%"               'sh-mode)
+
+    ;; ;; ;; Ruby
+    (template "/spec_helper\\.rb$"                                      "%helper%"         'rspec-mode t)
+    (template "_spec\\.rb$"                                             "%%"               'rspec-mode t)
+    (template "/\\.rspec$"                                              "%.rspec%"         'rspec-mode t)
+    (template "/Rakefile$"                                              "%Rakefile%"       'ruby-mode t)
+    (template "/Gemfile$"                                               "%Gemfile%"        'ruby-mode t)
+    ;; (template "\\.gemspec$"                                          "%.gemspec%"       'ruby-mode t)
+    (template "/lib/.+\\.rb$"                                           "%module%"         'ruby-mode t)
+    (template "\\.rb$"                                                  "%%"               'ruby-mode)
+
+    ;; ;; ;; Python
+    ;; ;; (template "tests?/test_.+\\.py$"                              "%%"               'nose-mode)
+    ;; ;; (template "/setup\\.py$"                                      "%setup%"          'python-mode)
+    (template "\\.py$"                                                  "%%"               'python-mode)
+
+    ;; ;; ;; PHP
+    ;; ;; (template "\\.class\\.php$"                                   "%class%"          'php-mode)
+    ;; ;; (template "\\.php$"                                           "%%"               'php-mode)
+
+    ;; ;; ;; Markdown
+    ;; (template "/README\\.md$"                                        "%README.md%"      'markdown-mode)
+    ;; ;; (template "/_posts/.+\\.md$"                                  "%jekyll-post"     'markdown-mode)
+    ;; ;; (template "/_layouts/.+\\.html$"                              "%jekyll-layout%"  'web-mode)
+
+    ;; ;; ;; Javascript
+    ;; ;; (template "\\.lbaction/Contents/Info.plist$"                  "%lb6%"            'nxml-mode)
+    ;; ;; (template "\\.lbaction/.+/\\(default\\|suggestions\\)\\.js$"  "%lb6%"            'js-mode)
+    ;; ;; (template "/package\\.json$"                                  "%package.json%"   'json-mode)
+    ;; ;; (template "\\.\\(json\\|jshintrc\\)$"                         "%%"               'json-mode)
+
+    ;; ;; ;; SCSS
+    ;; ;; (template "/master\\.scss$"                                   "%master%"         'scss-mode)
+    ;; ;; (template "/normalize\\.scss$"                                "%normalize%"      'scss-mode)
+    ;; ;; (template "\\.scss$"                                          "%%"               'scss-mode)
+
+    ;; ;; ;; HTML
+    ;; ;; (template "\\.html$"                                          "%%"               'web-mode)
+
+    ;; ;; ;; Lua
+    ;; ;; (template "\\.love/main\\.lua$"                               "%love.main%"      'lua-mode)
+    ;; ;; (template "\\.love/conf\\.lua$"                               "%love.conf%"      'lua-mode)
+    ;; ;; (template "\\.lua$"                                           "%%"               'lua-mode)
+
+    ;; ;; ;; Java
+    ;; ;; (template "/src/.+/.+\\.java$                                 "%%"               'java-mode)
+    ;; ;; (template "\\.gradle$"                                        "%%"               'groovy-mode)
+
+    ;; ;; ;; Elisp
+    (template "\\.emacs\\.d/init/.+\\.el$"                              "%initfile%"       'emacs-lisp-mode)
+    (template "\\.emacs\\.d/snippets/.+$"                               "%%"               'snippet-mode))

init/init-cpp.el

@@ -38,7 +38,7 @@
            (c-toggle-auto-newline -1)
 
            ;; DEL mapping interferes with smartparens and my.deflate-maybe
-           (defmap c-mode-map (kbd "DEL") nil)
+           (bind c-mode-map (kbd "DEL") nil)
 
            (c-set-offset 'substatement-open '0) ; brackets should be at same indentation level as the statements they open
            (c-set-offset 'inline-open '+)

init/init-cscope.el

@@ -0,0 +1,9 @@
+(provide 'init-cscope)
+
+(use-package xcscope
+  :config
+  (progn
+    (cscope-setup)
+    (add-hook 'ruby-mode-hook (function cscope-minor-mode))
+
+    (push '("*cscope*" :position bottom) popwin:special-display-config)))

init/init-csharp.el

@@ -12,7 +12,7 @@
 ;; (use-package csharp-mode
 ;;   :mode "\\.cs$"
 ;;   :config
-;;   (imap csharp-mode-map (kbd "C-SPC") 'omnisharp-auto-complete))
+;;   (bind 'insert csharp-mode-map (kbd "C-SPC") 'omnisharp-auto-complete))
 ;;   :init
 ;;   (add-hook! 'csharp-mode-hook (omnisharp-mode t) (flycheck-mode t)))
 

init/init-dev.el

@@ -2,32 +2,24 @@
 
 (use-package dash-at-point
   :commands (dash-at-point dash-at-point-with-docset)
-  :if is-mac
+  :if is-mac)
-  :config
-  (progn
-    (add-to-list 'dash-at-point-mode-alist '(ruby-mode . "rb"))
-    (add-to-list 'dash-at-point-mode-alist '(python-mode . "py3"))))
 
 (use-package rainbow-delimiters
   :commands rainbow-delimiters-mode
-  :init
+  :init (add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode))
-  (add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode))
-
-(use-package rotate-text
-  :commands (rotate-word-at-point rotate-region))
-
-;;;; Syntax modes
-(use-package go-mode
-  :mode "\\.go\\'"
-  :interpreter "go"
-  :init
-  (require 'go-autocomplete))
 
 ;;; Config modes
 (use-package yaml-mode :defer t
-  :config
+  :config (add-hook 'yaml-mode-hook 'enable-tab-width-2))
-  (add-hook 'yaml-mode-hook 'enable-tab-width-2))
 
 (use-package json-mode
   :mode (("\\.json\\'" . json-mode)
          ("\\.jshintrc\\'" . json-mode)))
+
+(use-package hl-todo
+  :init (add-hook 'find-file-hook 'hl-todo-mode))
+
+(use-package regex-tool
+  :commands regex-tool
+  :config (setq regex-tool-backend 'perl)
+  :init (add-hook 'regex-tool-mode-hook 'whitespace-newline-mode))

init/init-etags.el

@@ -1,5 +0,0 @@
-(provide 'init-etags)
-
-;; (use-package ac-etags :config (ac-etags-setup))
-
-;; Load etags solely for project navigation

init/init-fly.el

@@ -6,13 +6,9 @@
     (setq-default flycheck-indication-mode 'right-fringe
                   ;; Removed checks on idle/change for snappiness
                   flycheck-check-syntax-automatically
-                  '(save new-line mode-enabled)
+                  '(save mode-enabled)
                   flycheck-disabled-checkers
-                  '(emacs-lisp emacs-lisp-checkdoc))
+                  '(emacs-lisp-checkdoc make))
     (add-hook 'after-init-hook #'global-flycheck-mode)))
 
-(use-package flyspell
+(use-package flyspell :commands flyspell-mode)
-  :commands flyspell-mode
-  :config
-  (setq ispell-program-name "aspell"
-        ispell-list-command "--list"))

init/init-git.el

@@ -13,15 +13,61 @@
 (use-package gitconfig-mode
   :mode (("/\\.?git/?config\\'"      . gitconfig-mode)
          ("/\\.gitmodules\\'"        . gitconfig-mode))
-  :config
+  :config (add-hook 'gitconfig-mode-hook 'flyspell-mode))
-  (add-hook 'gitconfig-mode-hook 'flyspell-mode))
 
 (use-package gitignore-mode
   :mode (("/\\.gitignore\\'"         . gitignore-mode)
          ("/\\.git/info/exclude\\'"  . gitignore-mode)
          ("/git/ignore\\'"           . gitignore-mode)))
 
-(use-package git-gutter
+(use-package git-gutter-fringe+
-  :diminish git-gutter-mode
+  :init (global-git-gutter+-mode +1)
-  :init
+  :config
-  (global-git-gutter-mode 1))
+  (progn
+    (fringe-helper-define 'git-gutter-fr+-added nil
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X.......")
+
+    (fringe-helper-define 'git-gutter-fr+-deleted nil
+      "X......."
+      "XXXXXXXX"
+      "X......."
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........"
+      "........")
+
+    (fringe-helper-define 'git-gutter-fr+-modified nil
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X......."
+      "X.......")))

init/init-go.el

@@ -0,0 +1,7 @@
+(provide 'init-go)
+
+(use-package go-mode
+  :mode "\\.go\\'"
+  :interpreter "go"
+  :init
+  (require 'go-autocomplete))

init/init-ido.el

@@ -23,7 +23,6 @@
 (ido-ubiquitous-mode 1)
 (flx-ido-mode 1)
 
-(add-to-list 'ido-ignore-files "\\`.DS_Store\\'")
 (setq ido-use-faces nil
       ido-confirm-unique-completion t
       ido-case-fold t
@@ -31,4 +30,11 @@
       ido-enable-flex-matching t
       ido-create-new-buffer 'always
       ido-enable-tramp-completion t
-      ido-enable-last-directory-history t)
+      ido-enable-last-directory-history t
+      ido-save-directory-list-file (concat *tmp-dir "ido.last"))
+
+(add-to-list 'ido-ignore-files "\\`.DS_Store$")
+(setq ido-ignore-buffers
+      '("\\` " "^\\*ESS\\*" "^\\*Messages\\*" "^\\*Help\\*" "^\\*Buffer"
+        "^\\*.*Completions\\*$" "^\\*Ediff" "^\\*tramp" "^\\*cvs-"
+        "_region_" " output\\*$" "^TAGS$" "^\*Ido"))

init/init-java.el

@@ -1,4 +1,4 @@
-(provide 'init-eclim)
+(provide 'init-java)
 
 (use-package eclim
   :commands (eclim-mode global-eclim-mode)
@@ -16,8 +16,15 @@
     (use-package eclimd)
 
     (require 'ac-emacs-eclim-source)
-    (add-hook 'java-mode-hook 'ac-emacs-eclim-java-setup)
+    (add-hook! 'java-mode-hook
+               (setq ac-sources '(ac-source-emacs-eclim ac-source-yasnippet ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers)))
 
     (setq help-at-pt-display-when-idle t)
     (setq help-at-pt-timer-delay 0.1)
-    (help-at-pt-set-timer)))
+    (help-at-pt-set-timer)
+
+    (bind 'motion java-mode-map "gd" 'eclim-java-find-declaration)))
+
+(use-package groovy-mode :mode "\\.gradle$"
+  :config
+  (add-to-list 'ac-modes 'groovy-mode))

init/init-love.el

@@ -4,7 +4,7 @@
   (shell-command (format "open -a love.app %s" (my/project-root))))
 
 (use-package lua-mode
-  :mode "\\.lua\\'"
+  :mode "\\.lua$"
   :interpreter "lua"
   :init
   (progn
@@ -12,8 +12,7 @@
       "Buffer local minor mode for Love2D"
       :init-value nil
       :lighter " <3"
-      :keymap (make-sparse-keymap) ; defines love-mode-map
+      :keymap (make-sparse-keymap))
-      :group lua)
 
     (add-hook! 'lua-mode-hook
                (setq my-run-code-interpreter "lua")

init/init-org.el

@@ -40,10 +40,10 @@
   :keymap (make-sparse-keymap) ; defines evil-org-mode-map
   :group 'evil-org)
 
-;; Reset evil to ensure certain evil keybindings are prioritized
 (add-hook 'org-mode-hook 'evil-org-mode)
-(add-hook 'org-mode-hook 'flyspell-mode)
+(add-hook 'org-mode-hook 'turn-on-auto-fill)
-(add-hook 'org-mode-hook 'enable-hard-wrap)
+
+;; Reset evil to ensure evil-org-mode's maps work
 (add-hook! 'org-mode-hook (evil-mode nil) (evil-mode 1))
 
 (shut-up (load-library "ox-opml"))
@@ -114,3 +114,82 @@
         ("tp" tags "+Projects")
         ("tg" tags-todo "+gamedev")
         ("tw" tags-tree "+webdev")))
+
+
+;; Keymaps
+(bind 'insert org-mode-map [remap my.inflate-space-maybe] 'self-insert-command)
+(bind org-mode-map (kbd "RET") nil
+                     (kbd "C-j") nil
+                     (kbd "C-k") nil)
+
+(mapc (lambda (state)
+        (evil-define-key state evil-org-mode-map
+          (kbd "M-l") 'org-metaright
+          (kbd "M-h") 'org-metaleft
+          (kbd "M-k") 'org-metaup
+          (kbd "M-j") 'org-metadown
+          (kbd "M-L") 'org-shiftmetaright
+          (kbd "M-H") 'org-shiftmetaleft
+          (kbd "M-K") 'org-shiftmetaup
+          (kbd "M-J") 'org-shiftmetadown
+          (kbd "M-o") '(lambda () (interactive)
+                         (evil-org-eol-call
+                          '(lambda()
+                             (org-insert-heading)
+                             (org-metaright))))
+          (kbd "M-t") '(lambda () (interactive)
+                         (evil-org-eol-call
+                          '(lambda()
+                             (org-insert-todo-heading nil)
+                             (org-metaright))))
+          ))
+      '(normal insert))
+
+;; Formatting shortcuts
+(bind 'insert evil-org-mode-map
+      (kbd "s-b") (λ (my/org-surround "*"))     ; bold
+      (kbd "s-u") (λ (my/org-surround "_"))     ; underline
+      (kbd "s-i") (λ (my/org-surround "/"))     ; italics
+      (kbd "s-`") (λ (my/org-surround "+"))     ; strikethrough
+
+      (kbd "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading))
+      (kbd "<s-return>") (λ (org-insert-heading-after-current)))
+
+(bind '(normal visual) evil-org-mode-map
+       ",l" 'org-insert-link)
+
+(bind 'visual evil-org-mode-map
+      (kbd "s-b") "s*"          ; bold
+      (kbd "s-i") "s/")         ; italics
+
+(bind 'normal evil-org-mode-map
+      ",d" 'org-time-stamp
+      ",D" 'org-time-stamp-inactive
+      ",s" 'org-schedule
+      ",a" 'org-attach
+      ",A" 'org-attach-open
+      ",t" 'org-todo
+      ",T" 'org-show-todo-tree
+      ",/" 'org-sparse-tree
+      ",?" 'org-tags-view
+      ",+" 'org-align-all-tags
+      ",r" 'org-refile
+      "gh" 'outline-up-heading
+      "gj" 'org-forward-heading-same-level
+      "gk" 'org-backward-heading-same-level
+      "gl" 'outline-next-visible-heading
+      "go" 'org-open-at-point
+      "ga" 'org-agenda
+      "gt" 'org-show-todo-tree
+      "H" 'org-beginning-of-line
+      "L" 'org-end-of-line
+      "$" 'org-end-of-line
+      "^" 'org-beginning-of-line
+      "<" 'org-metaleft
+      ">" 'org-metaright
+      "-" 'org-cycle-list-bullet
+      (kbd ", SPC") 'org-archive-subtree
+      (kbd "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading) (evil-insert-state))
+      (kbd "<s-return>") (λ (org-insert-heading-after-current) (evil-insert-state))
+      (kbd "RET") (λ (if (org-entry-is-todo-p) (org-todo 'done)))
+      (kbd "TAB") 'org-cycle)

init/init-project.el

@@ -1,32 +1,127 @@
 (provide 'init-project)
 
-(add-hook! 'dired-load-hook
-           (use-package dired+)
-           (setq dired-recursive-deletes 'always
-                 dired-recursive-copies 'always
-
-                 ;; if there is a dired buffer displayed in the next window, use its
-                 ;; current subdir, instead of the current subdir of this dired buffer
-                 dired-dwim-target t))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(use-package helm :defer t)
-(use-package grizzl :defer t)
-
 (use-package neotree
   :commands (neotree-show neotree-hide neotree-toggle))
 
-(use-package projectile
-  :diminish projectile-mode
-  :config
-  (progn (projectile-global-mode)
-         (setq projectile-completion-system 'grizzl)))
-
 (use-package ag
   :commands (ag ag-search ag-regexp)
   :config
-  (setq ag-reuse-window t
+  (progn (setq ;ag-reuse-window nil
-        ag-reuse-buffers t
+               ag-reuse-buffers nil
-        ag-highlight-search t))
+               ag-highlight-search t)
+
+         (push '(ag-mode :position bottom :height 0.5 :stick t) popwin:special-display-config)
+
+         ;; Close Ag on ESC
+         (bind ag-mode-map [escape] "q")))
+
+(use-package dired
+  :init
+  (progn (setq dired-recursive-deletes 'always
+               dired-recursive-copies 'always
+               dired-auto-revert-buffer t
+
+               ;; if there is a dired buffer displayed in the next
+               ;; window, use its current subdir, instead of the
+               ;; current subdir of this dired buffer
+               dired-dwim-target t)
+
+         (push '(dired-mode :position bottom :height 0.5 :stick t) popwin:special-display-config)
+
+         (add-hook! 'dired-mode-hook
+                    (use-package 'dired+ :config (toggle-diredp-find-file-reuse-dir 1)))))
+
+(use-package projectile
+  :init
+  (progn (setq-default projectile-cache-file (concat *tmp-dir "projectile.cache"))
+         (setq-default projectile-known-projects-file (concat *tmp-dir "projectile.projects"))
+         (setq-default projectile-enable-caching t)
+
+         (add-to-list 'projectile-globally-ignored-files "ido.last")
+         (add-to-list 'projectile-globally-ignored-directories "assets")
+         (add-to-list 'projectile-other-file-alist '("scss" "css"))
+         (add-to-list 'projectile-other-file-alist '("css" "scss"))
+
+         (projectile-global-mode +1)
+
+         (defvar persp-modestring-dividers '("" " |" ","))
+         (use-package perspective)
+         (use-package persp-projectile)
+         (persp-mode 1)))
+
+(use-package helm
+  :pre-load (defvar helm-mode-line-string "")
+  :init
+  (progn
+    (use-package helm-ag :commands (helm-do-ag))
+    (use-package helm-projectile)
+    (add-hook! 'scss-mode-hook (use-package helm-css-scss))
+
+    (push '("^\\*helm.+\\*$" :position bottom :regexp t :height 18) popwin:special-display-config)
+
+    (setq helm-quick-update t
+          helm-idle-delay 0.01
+          helm-input-idle-delay 0.01)
+
+    (bind helm-map (kbd "C-w") 'evil-delete-backward-word)
+
+    ;; All this for a smaller prompt (it was redundant with helm headers)
+    (defmacro helm-projectile-command (command source prompt)
+      `(defun ,(intern (concat "helm-projectile-" command)) (&optional arg)
+         (interactive "P")
+         (if (projectile-project-p)
+             (projectile-maybe-invalidate-cache arg))
+         (let ((helm-ff-transformer-show-only-basename nil)
+               ;; for consistency, we should just let Projectile take care of ignored files
+               (helm-boring-file-regexp-list nil))
+           (helm :sources ,source
+                 :buffer "*helm projectile*"
+                 :prompt ">>> "))))
+
+    (helm-projectile-command "switch-project" 'helm-source-projectile-projects ">>> ")
+    (helm-projectile-command "find-file" helm-source-projectile-files-and-dired-list ">>> ")
+    (helm-projectile-command "find-file-in-known-projects" 'helm-source-projectile-files-in-all-projects-list ">>> ")
+    (helm-projectile-command "find-file-dwim" 'helm-source-projectile-files-dwim-list ">>> ")
+    (helm-projectile-command "find-dir" helm-source-projectile-directories-and-dired-list ">>> ")
+    (helm-projectile-command "recentf" 'helm-source-projectile-recentf-list ">>> ")
+    (helm-projectile-command "switch-to-buffer" 'helm-source-projectile-buffers-list ">>> ")
+
+    ;; Hide the mode-line in helm (<3 minimalism)
+    (defun helm-display-mode-line (source &optional force)
+      "Setup mode-line and header-line for `helm-buffer'."
+      (set (make-local-variable 'helm-mode-line-string)
+           (helm-interpret-value (or (and (listp source) ; Check if source is empty.
+                                          (assoc-default 'mode-line source))
+                                     (default-value 'helm-mode-line-string))
+                                 source))
+      (let ((follow (and (eq (cdr (assq 'follow source)) 1) "(HF) ")))
+        ;; Setup mode-line.
+        (if helm-mode-line-string
+            (setq mode-line-format nil)
+          (setq mode-line-format (default-value 'mode-line-format)))
+        ;; Setup header-line.
+        (let* ((hlstr (helm-interpret-value
+                       (and (listp source)
+                            (assoc-default 'header-line source))
+                       source))
+               (hlend (make-string (max 0 (- (window-width) (length hlstr))) ? )))
+          (setq header-line-format
+                (propertize (concat " " hlstr hlend) 'face 'helm-header))))
+      (when force (force-mode-line-update)))
+
+    ;; No persistent header
+    (defadvice helm-display-mode-line (after undisplay-header activate)
+      (setq header-line-format nil))))
+
+;; For setting project-specific settings
+(defmacro project-settings (name &rest body)
+  (declare (indent 1))
+  `(progn
+     (add-hook 'find-file-hook
+               (lambda ()
+                 (when (string-match-p ,name (buffer-file-name))
+                   ,@body)))
+     (add-hook 'dired-after-readin-hook
+               (lambda ()
+                 (when (string-match-p ,name (dired-current-directory))
+                   ,@body)))))

init/init-python.el

@@ -3,30 +3,41 @@
 (use-package python
   :mode ("\\.py\\'" . python-mode)
   :interpreter ("python" . python-mode)
-  :init
+  :init (setq python-indent-offset 4)
-  (setq python-indent-offset 4)
   :config
   (progn
-    (use-package jedi)
+    (setq python-environment-directory *tmp-dir)
-
-    (unless (file-directory-p "~/.emacs.d/.python-environments/default/")
-        (jedi:install-server))
-
-    (add-hook 'python-mode-hook 'jedi:ac-setup)
     (setq python-shell-interpreter "ipython")
 
-    ;; Interferes with smartparens
-    (defmap python-mode-map (kbd "DEL") nil)
-
     (add-hook! 'python-mode-hook
                (setq my-switch-to-repl-func 'python-shell-switch-to-shell
                      my-send-region-to-repl-func 'python-shell-send-region
                      my-run-code-interpreter "python"))
 
+    ;; Interferes with smartparens
+    (bind python-mode-map (kbd "DEL") nil)
+    (bind 'motion python-mode-map "gd" 'jedi:goto-definition)
+
+    (use-package jedi
+      :config
+      (progn
+        (unless (file-directory-p python-environment-directory)
+          (jedi:install-server))
+        (add-hook 'python-mode-hook 'jedi:ac-setup)))
+
     (use-package nose
       :commands (nose-mode)
       :init
       (progn
         ;; Reset nose keymap, we'll set new ones in my-keymaps.el
         (defvar nose-mode-map (make-sparse-keymap))
-        (associate-minor-mode "/test_.+\\.py\\'" nose-mode)))))
+        (associate-minor-mode "/test_.+\\.py\\'" nose-mode))
+      :config
+      (bind 'normal nose-mode-map
+            ",tr" 'nosetests-again
+            ",ta" 'nosetests-all
+            ",ts" 'nosetests-one
+            ",tv" 'nosetests-module
+            ",tA" 'nosetests-pdb-all
+            ",tO" 'nosetests-pdb-one
+            ",tV" 'nosetests-pdb-module))))

init/init-ruby.el

@@ -1,8 +1,5 @@
 (provide 'init-ruby)
 
-(defun ac-add-ruby-rsense ()
-  (setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources)))
-
 ;;
 (use-package ruby-mode
   :mode (("\\.rb$" . ruby-mode)
@@ -17,14 +14,18 @@
   :interpreter "ruby"
   :config
   (progn
+    (define-minor-mode rake-mode
+      "Buffer local minor mode for rake files"
+      :lighter " Rake")
+
     (use-package inf-ruby
       :config
       (progn
         (evil-set-initial-state 'inf-ruby-mode 'insert)
-        (use-package ac-inf-ruby)
+        ;; (use-package ac-inf-ruby)
-        (add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable))
+        ;; (add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable)
-      :init
+
-      (add-to-list 'ac-modes 'inf-ruby-mode))
+        (push '(inf-ruby-mode :position bottom :stick t) popwin:special-display-config)))
 
     (use-package rspec-mode
       :defer t
@@ -38,15 +39,34 @@
           (("task" "namespace") () "end")
           ))
       :init
-      (associate-minor-mode "_spec\\.rb\\'" rspec-mode))
+      (progn (associate-minor-mode "\\(/spec_helper\\|_spec\\)\\.rb$" rspec-mode)
+             (associate-minor-mode "/\\.rspec$" rspec-mode)
+             (associate-minor-mode "/\\.rake$" rake-mode)
+             (associate-mode "/\\.rspec$" text-mode))
+      :config
+      (progn (bind 'normal rspec-mode-verifiable-keymap
+                   ",tr" 'rspec-rerun
+                   ",ta" 'rspec-verify-all
+                   ",ts" 'rspec-verify-single
+                   ",tv" 'rspec-verify)
+             (bind 'normal rspec-dired-mode-keymap
+                   ",tv" 'rspec-dired-verify
+                   ",ts" 'rspec-dired-verify-single
+                   ",ta" 'rspec-verify-all
+                   ",tr" 'rspec-rerun)))
 
-	;;; Auto-completion
+    (use-package robe
-    ;; Remember to install rsense w/ homebrew!
+      :config
-    (setq rsense-home "/usr/local/Cellar/rsense/0.3/libexec")
+      (progn
-    (when (file-directory-p rsense-home)
+        (add-hook! 'after-save-hook
-      (add-to-list 'load-path (concat rsense-home "/etc"))
+                   (when (and (eq major-mode 'ruby-mode)
-      (require 'rsense)
+                              (bound-and-true-p robe-running))
-      (add-hook 'ruby-mode-hook 'ac-add-ruby-rsense))
+                     (ruby-load-file (buffer-file-name))))
+        (add-hook! 'ruby-mode-hook
+                   (robe-mode 1)
+                   (ac-robe-setup)
+                   (unless robe-running (robe-start 1))
+                   (ruby-load-file (buffer-file-name)))))
 
     (add-hook! 'ruby-mode-hook
                (setq my-switch-to-repl-func 'ruby-switch-to-inf
@@ -57,11 +77,3 @@
     (setq ruby-indent-level 2)
     (setq ruby-deep-indent-paren t)
 	(add-hook 'ruby-mode-hook 'enable-tab-width-2)))
-
-;; (add-hook! 'find-file-hook
-;;            (let ((rake-path
-;;                   (f--traverse-upwards (f--exists? "Rakefile" it))))
-;;              (when rake-path
-;;                (use-package rake-mode)
-;;                (rake-mode t)
-;;                (rake-mode/visit-rakefile (expand-file-name "Rakefile" rake-path) t))))

init/init-sh.el

@@ -0,0 +1,4 @@
+(provide 'init-sh)
+
+;; Make shell scrips executable on save. Good!
+(add-hook 'after-save-hook 'executable-make-buffer-file-executable-if-script-p)

init/init-snippets.el

@@ -1,7 +1,7 @@
 (provide 'init-snippets)
 
 (use-package yasnippet
-    :mode (("emacs.+/snippets/" . snippet-mode))
+  :mode (("emacs\\.d/.+/snippets/" . snippet-mode))
   :pre-load
   (progn
     ;; Fix yasnippet keymaps so they only work in insert mode (why they
@@ -9,8 +9,9 @@
     ;; BEFORE we include yasnippet.
     (defvar yas-minor-mode-map
       (let ((map (make-sparse-keymap)))
-          (imap map [(tab)]     'yas-expand)
+        (bind 'insert map [(tab)] 'yas-expand)
-          (imap map (kbd "TAB") 'yas-expand)
+        (bind 'insert map (kbd "TAB") 'yas-expand)
+        (bind 'visual map (kbd "<backtab>") 'yas-insert-snippet)
         map)))
   :config
   (progn
@@ -20,21 +21,24 @@
     ;; Only load personal snippets
     (setq yas-snippet-dirs `(,*snippets-dir))
     (setq yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
+    (setq yas-also-auto-indent-first-line t)
 
     (after auto-complete
-             (add-hook! 'yas-before-expand-snippet-hook (auto-complete-mode -1))
+           ;; (add-hook! 'yas-before-expand-snippet-hook (auto-complete-mode -1))
-             (add-hook! 'yas-after-exit-snippet-hook (auto-complete-mode t))
+           ;; (add-hook! 'yas-after-exit-snippet-hook (auto-complete-mode t))
            (defadvice ac-expand (before advice-for-ac-expand activate)
              (when (yas-expand) (ac-stop))))
 
-      (defmap yas-keymap (kbd "DEL") 'my/yas-clear-field)
+    (bind yas-keymap (kbd "DEL") 'my/yas-clear-field)
 
     (yas-reload-all))
   :init
   (progn
+    (add-hook 'snippet-mode-hook 'disable-final-newline)
+    (add-hook 'text-mode-hook 'yas-minor-mode)
     (add-hook 'prog-mode-hook 'yas-minor-mode)
     (add-hook 'snippet-mode-hook 'yas-minor-mode)
-      (add-hook 'markdown-mode-hook 'yas-minor-mode)
+    ;; (add-hook 'markdown-mode-hook 'yas-minor-mode)
     (add-hook 'org-mode-hook 'yas-minor-mode)))
 
 ;; Prevents Yas from stepping on my toes when I use backspace
@@ -49,3 +53,10 @@
                 (eq (point) (marker-position (yas--field-start field))))
            (yas--skip-and-clear field))
           (t (delete-char -1)))))
+
+;; yas snippet helpers
+(defvaralias '% 'yas-selected-text)
+(defun %! () (if % (s-trim-right %)))
+(defun !% () (if % (s-trim-left %)))
+(defun !%! () (if % (s-trim %)))
+(defun --newline-maybe () (if % "\n"))

init/init-swift.el

@@ -0,0 +1,5 @@
+(provide 'init-swift)
+
+;; (use-package swift-mode)
+
+;; TODO: Set up emacs task runners for fruitstrap

init/init-text.el

@@ -1,5 +1,8 @@
 (provide 'init-text)
 
+(add-hook 'text-mode-hook 'turn-on-auto-fill)
+(add-hook 'prog-mode-hook 'enable-comment-hard-wrap)
+
 (use-package markdown-mode
   :mode (("\\.md\\'" . markdown-mode)
          ("/README\\'" . markdown-mode))
@@ -19,4 +22,28 @@
           ;; Bold markup removal, bold word at point, or empty markup insertion
           (if (thing-at-point-looking-at markdown-regex-del)
               (markdown-unwrap-thing-at-point nil 2 4)
-            (markdown-wrap-or-insert delim delim 'word nil nil)))))))
+            (markdown-wrap-or-insert delim delim 'word nil nil))))))
+  :config
+  (let ((map markdown-mode-map))
+    (bind '(normal visual) map
+          ",i" 'markdown-insert-image
+          ",l" 'markdown-insert-link
+          ",L" 'markdown-insert-reference-link-dwim
+          ",b" 'markdown-preview)
+
+    (bind 'normal map
+          "[p" 'markdown-promote
+          "]p" 'markdown-demote)
+
+    (bind 'insert map
+          (kbd "M--") 'markdown-insert-hr)
+
+    (bind map
+          (kbd "<backspace>")  nil
+          (kbd "<M-left>")     nil
+          (kbd "<M-right>")    nil
+
+          (kbd "s-*") 'markdown-insert-list-item
+          (kbd "s-b") 'markdown-insert-bold
+          (kbd "s-i") 'markdown-insert-italic
+          (kbd "s-`") 'markdown-insert-del)))

init/init-webdev.el

@@ -3,53 +3,85 @@
 (use-package rainbow-mode
   :defer t
   :init
-  (add-hook 'scss-mode 'rainbow-mode))
+  (progn
+    (add-hook 'scss-mode-hook 'rainbow-mode)
+    (add-hook 'sass-mode-hook 'rainbow-mode)))
+
+(use-package sass-mode
+  :mode "\\.sass$"
+  :init (add-hook 'sass-mode-hook 'enable-tab-width-2)
+  :config
+  (progn
+    (add-hook 'sass-mode-hook 'ac-css-mode-setup)
+
+    (add-to-list 'ac-modes 'sass-mode)
+    (setq-default css-indent-offset 2)))
 
 (use-package scss-mode
-  :mode "\\.scss\\'"
+  :mode "\\.scss$"
+  :init (add-hook 'scss-mode-hook 'enable-tab-width-2)
   :config
   (progn
-    (setq scss-compile-at-save nil)
+    (add-hook 'scss-mode-hook 'ac-css-mode-setup)
-    (add-hook 'scss-mode-hook 'ac-css-mode-setup)))
 
-(use-package haml-mode :mode "\\.haml\\'")
+    (add-to-list 'ac-modes 'scss-mode)
+    (setq-default css-indent-offset 2)
+    (setq scss-compile-at-save nil)
+
+    (bind '(normal visual) scss-mode-map "gQ" 'web-beautify-css)))
 
 ;;; HTML/Markup
-(use-package emmet-mode
+(use-package haml-mode :mode "\\.haml$")
-  :defer t
-  :config
-  (setq emmet-move-cursor-between-quotes t)
-  :init
-  (progn
-    (add-hook 'scss-mode-hook   'emmet-mode)
-    (add-hook 'web-mode-hook    'emmet-mode)
-    (add-hook 'html-mode-hook   'emmet-mode)
-    (add-hook 'haml-mode-hook   'emmet-mode)
-    (add-hook 'nxml-mode-hook   'emmet-mode)))
 
 (use-package web-mode
-  :mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
+  :mode (("\\.\\(p\\)?htm\\(l\\)?$" . web-mode)
-         ("\\.tpl\\(\\.php\\)?\\'" . web-mode)
+         ("\\.tpl\\(\\.php\\)?$" . web-mode)
-         ("\\.erb\\'" . web-mode)
+         ("\\.erb$" . web-mode)
-         ("wp-content/themes/.+/.+\\.php\\'" . web-mode))
+         ("wp-content/themes/.+/.+\\.php$" . web-mode))
   :config
   (progn
-    (setq web-mode-ac-sources-alist
+    (add-hook 'web-mode-hook 'enable-tab-width-2)
-          '(("css" . (ac-source-css-property))))
 
-    (setq web-mode-markup-indent-offset  2
+    (setq web-mode-ac-sources-alist
+          '(("css" . (ac-source-css-property)))
+          web-mode-markup-indent-offset  2
           web-mode-code-indent-offset    2
           web-mode-css-indent-offset     2
           web-mode-style-padding         2
           web-mode-script-padding        2
           web-mode-block-padding         2)
 
-    (add-hook 'web-mode-hook 'enable-tab-width-2)))
+    (bind web-mode-map (kbd "s-/") 'web-mode-comment-or-uncomment)
+    (bind 'normal  web-mode-map
+          "zf" 'web-mode-fold-or-unfold
+          ",t" 'web-mode-element-rename)
+    (bind '(normal visual) web-mode-map
+           "gQ" 'web-beautify-html
+           "]a" 'web-mode-attribute-next
+           "]t" 'web-mode-tag-next
+           "[t" 'web-mode-tag-previous
+           "]T" 'web-mode-element-child
+           "[T" 'web-mode-element-parent)))
+
+(use-package emmet-mode
+  :defer t
+  :init
+  (progn
+    (add-hook 'scss-mode-hook   'emmet-mode)
+    (add-hook 'web-mode-hook    'emmet-mode)
+    (add-hook 'html-mode-hook   'emmet-mode)
+    (add-hook 'haml-mode-hook   'emmet-mode)
+    (add-hook 'nxml-mode-hook   'emmet-mode))
+  :config
+  (progn
+    (setq emmet-move-cursor-between-quotes t)
+
+    (bind 'insert emmet-mode-keymap
+          (kbd "s-e") 'emmet-expand-yas
+          (kbd "s-E") 'emmet-expand-line)))
 
 (use-package php-mode
-  :mode (("\\.php\\'" . php-mode)
+  :mode "\\.\\(php\\|inc\\)$"
-         ("\\.inc\\'" . php-mode))
-  :interpreter "php"
   :config
   (progn
     (add-hook! 'php-mode-hook (setq my-run-code-interpreter "php"))
@@ -60,18 +92,36 @@
   :commands tern-mode
   :config
   (progn
-    (use-package tern-auto-complete
+    (require 'tern-auto-complete)
-      :config (setq tern-ac-on-dot nil)))
+
-  :init
+    (setq tern-ac-on-dot nil)))
+
+(use-package js2-mode :mode "\\.js$"
+  :config
+  (progn
+    (use-package js2-refactor
+      :config
+      ;; TODO Set up keymaps
+      )
+    (setq-default js2-show-parse-errors nil)
+    (setq-default js2-global-externs '("module" "require" "buster" "sinon" "assert" "refute" "setTimeout" "clearTimeout" "setInterval" "clearInterval" "location" "__dirname" "console" "JSON" "jQuery" "$"
+                                       ;; Launchbar API
+                                       "LaunchBar" "File" "Action" "HTTP" "include"))
+
+    (bind 'insert js2-mode-map [remap auto-complete] 'tern-ac-complete)
+    (bind 'motion js2-mode-map "gd" 'tern-find-definition)
+    (bind '(normal visual) js2-mode-map "gQ" 'web-beautify-js))
+
   ;; replace auto-complete with tern-ac-complete only in js-mode
-  (add-hook! 'js-mode-hook
+  :init (add-hook! 'js2-mode-hook
                    (tern-mode t)
                    (tern-ac-setup)
                    (setq my-run-code-interpreter "node")))
 
-;; Jekyll support
+(use-package web-beautify
-(define-minor-mode jekyll-mode
+  :commands (web-beautify-js web-beautify-css web-beautify-html)
-  :init-value nil
+  :config
-  :lighter " :{")
+  (progn
-
+    (add-hook! 'scss-mode-hook (setenv "jsbeautify_indent_size" "2"))
-(associate-minor-mode "[.-]jekyll/" jekyll-mode)
+    (add-hook! 'web-mode-hook  (setenv "jsbeautify_indent_size" "4"))
+    (add-hook! 'js2-mode-hook  (setenv "jsbeautify_indent_size" "4"))))

init/my-coderunner.el

@@ -1,3 +1,5 @@
+(provide 'my-coderunner)
+
 ;; Variables
 (defvar my-run-code-interpreter      nil)
 (defvar my-run-code-func             'my/run-code-shell)
@@ -27,6 +29,7 @@
       (shell-command-on-region beg end my-run-code-interpreter)
     (message "No interpreter set for %s. See `my-run-code-interpreter'" (symbol-name major-mode))))
 
+;;
 (defun my:switch-to-repl ()
   (interactive)
   (if (functionp my-switch-to-repl-func)

init/my-commands.el

@@ -1,10 +1,6 @@
 (provide 'my-commands)
 
 ;;;; Defun Commands ;;;;;;;;;;;;;;;;;;;;
-(defun my:git-gutter-refresh ()
-  (interactive)
-  (git-gutter+-refresh))
-
 (defun my:minibuffer-quit ()
   "Abort recursive edit. In Delete Selection mode, if the mark is
 active, just deactivate it; then it takes a second \\[keyboard-quit]
@@ -15,63 +11,33 @@ to abort the minibuffer."
     (when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
     (abort-recursive-edit)))
 
-;; File navigation defuns
-(defun my:goto-symbol (&optional symbol-list)
-  "Refresh imenu and jump to a place in the buffer using Ido."
-  (interactive)
-  (unless (featurep 'imenu)
-    (require 'imenu nil t))
-  (cond
-   ((not symbol-list)
-    (let ((ido-mode ido-mode)
-          (ido-enable-flex-matching
-           (if (boundp 'ido-enable-flex-matching)
-               ido-enable-flex-matching t))
-          name-and-pos symbol-names position)
-      (unless ido-mode
-        (ido-mode 1)
-        (setq ido-enable-flex-matching t))
-      (while (progn
-               (imenu--cleanup)
-               (setq imenu--index-alist nil)
-               (my:goto-symbol (imenu--make-index-alist))
-               (setq selected-symbol
-                     (ido-completing-read "Symbol? " symbol-names))
-               (string= (car imenu--rescan-item) selected-symbol)))
-      (unless (and (boundp 'mark-active) mark-active)
-        (push-mark nil t nil))
-      (setq position (cdr (assoc selected-symbol name-and-pos)))
-      (cond
-       ((overlayp position)
-        (goto-char (overlay-start position)))
-       (t
-        (goto-char position)))))
-   ((listp symbol-list)
-    (dolist (symbol symbol-list)
-      (let (name position)
-        (cond
-         ((and (listp symbol) (imenu--subalist-p symbol))
-          (my:goto-symbol symbol))
-         ((listp symbol)
-          (setq name (car symbol))
-          (setq position (cdr symbol)))
-         ((stringp symbol)
-          (setq name symbol)
-          (setq position
-                (get-text-property 1 'org-imenu-marker symbol))))
-        (unless (or (null position) (null name)
-                    (string= (car imenu--rescan-item) name))
-          (add-to-list 'symbol-names name)
-          (add-to-list 'name-and-pos (cons name position))))))))
-
 ;; Buffer defuns
-(defun my:kill-dired-buffers ()
+(defun my:kill-other-buffers ()
+  "Kill left-over temporary, dired or buried special buffers"
   (interactive)
   (mapc (lambda (buffer)
-           (when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
+          (let ((buffer-name (buffer-name buffer)))
-             (kill-buffer buffer)))
+            (when (and (not (s-matches? buffer-name "\\*\\(scratch\\|Messages\\)\\*"))
+                       (or (eq 'dired-mode (buffer-local-value 'major-mode buffer))
+                           (s-matches? "^ ?\\*.+\\*$" buffer-name))
+                       (not (get-buffer-window buffer)))
+              (kill-buffer buffer))))
           (buffer-list)))
 
+;; Inspired by http://demonastery.org/2013/04/emacs-evil-narrow-region/
+(defun my: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)))
+
+(defun my:kill-persp ()
+  (interactive)
+  (persp-kill (persp-name persp-curr)))
+
 ;;;; Tmux defuns ;;;;;;;;;;;;;;;;;
 (defun my:tmux-send (command)
   (interactive "sSend to Tmux: ")
@@ -86,7 +52,7 @@ to abort the minibuffer."
              (stringp appName)
              (not (string= "" appName)))
         (setq appName (concat "-a " appName ".app")))
-    (shell-command (concat "open " appName " " (shell-quote-argument path))))
+    (async-shell-command (concat "open " appName " " (shell-quote-argument path))))
 
   (defun my:open-with (appName)
     (interactive "sApp name: ")
@@ -102,58 +68,44 @@ to abort the minibuffer."
 ;; Ex-commands                        ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(evil-define-command my:ex:msg-buffer () :repeat nil
+(evil-define-command ex:kill-buffers (&optional bang) :repeat nil
-  (interactive)
-  (view-echo-area-messages)
-  (switch-to-buffer-other-window "*Messages*")
-  ;; Force text-mode for unfettered evil-mode & my keymappings
-  (text-mode))
-
-(evil-define-command my:ex:kill-buffers (&optional bang) :repeat nil
   (interactive "<!>")
-  (let ((buffers (if bang
+  (if (and bang (projectile-project-p))
-                     (cdr (buffer-list (current-buffer)))
+      (projectile-kill-buffers)
-                   (buffer-list))))
+    (mapc 'kill-buffer (buffer-list)))
-    (delete-other-windows)
+  (delete-other-windows))
-    (tags-reset-tags-tables)
-    (mapc 'kill-buffer buffers)))
 
-(evil-define-command my:ex:init-files (&optional bang) :repeat nil
+(evil-define-command ex:init-files (&optional bang) :repeat nil
   (interactive "<!>")
   (if bang
       (ido-find-file-in-dir *init-dir)
     (ido-find-file-in-dir *dir)))
 
-(evil-define-command my:ex:notes () :repeat nil
+(evil-define-command ex:notes () :repeat nil
   (interactive)
   (ido-find-file-in-dir org-directory))
 
-(evil-define-command my:ex:snippets (&optional bang) :repeat nil
-  (interactive "<!>")
-  (if bang
-      (yas-new-snippet)
-    (yas-visit-snippet-file)))
-
 ;; Projects
-(evil-define-command my:ex:ag-search (search &optional bang) :repeat nil
+(evil-define-command ex:ag-search (search &optional bang regex) :repeat nil
   (interactive "<a><!>")
   (let ((root (my/project-root bang)))
-    (ag search root)))
+    (if search
+        (if regex (ag-regexp search root) (ag search root))
+      (helm-do-ag root))))
 
-(evil-define-command my:ex:ag-regex-search (search &optional bang) :repeat nil
+(evil-define-command ex:ag-regex-search (search &optional bang) :repeat nil
   (interactive "<a><!>")
-  (let ((root (my/project-root bang)))
+  (ex:ag-search search bang t))
-    (ag-regexp search root)))
 
 ;; Run a command. If <bang>, then only type command into tmux
-(evil-define-command my:ex:tmux-send (command &optional bang) :repeat nil
+(evil-define-command ex:tmux-send (command &optional bang) :repeat nil
   (interactive "<sh><!>")
   (let ((cmd-format (if bang "%s" "C-u %s Enter")))
     (my:tmux-send (format cmd-format (shell-quote-argument command)))
     (when (evil-ex-p)
       (message "[Tmux] %s" command))))
 
-(evil-define-command my:ex:tmux-chdir (&optional path bang) :repeat nil
+(evil-define-command ex:tmux-chdir (&optional path bang) :repeat nil
   (interactive "<f><!>")
   (let ((dir (shell-quote-argument
               (if (and path
@@ -161,36 +113,65 @@ to abort the minibuffer."
                        (file-directory-p path))
                   (file-truename path)
                 (my/project-root bang)))))
-    (my:ex:tmux-run (format "cd %s" dir))
+    (ex:tmux-send (format "cd %s" dir))
     (when (evil-ex-p)
       (message "[Tmux] cd %s" dir))))
 
-(evil-define-command my:ex:byte-compile-all (&optional bang) :repeat nil
+(evil-define-command ex:byte-compile-all (&optional bang) :repeat nil
   (interactive "<!>")
-  (byte-recompile-file (expand-file-name "init.el" *dir) bang 0)
+  (require 'async-bytecomp)
-  (byte-recompile-directory *init-dir 0 bang)
+  ;; (async-byte-recompile-directory *dir 0 bang)
-  (byte-recompile-directory *elisp-dir 0 bang))
+  (byte-recompile-directory *dir 0 bang))
 
-(evil-define-command my:ex:mru () :repeat nil
+(evil-define-command ex:build (arguments &optional bang) :repeat nil
-  "Find a recent file using ido."
-  (interactive)
-  (let ((file (ido-completing-read "Choose recent file: " recentf-list nil t)))
-    (when file (find-file file))))
-
-(evil-define-command my:ex:build (arguments &optional bang) :repeat nil
   (interactive "<a><!>")
   (my:build arguments))
 
-(evil-define-command my:ex:cd (dir) :repeat nil
+(evil-define-command ex:cd (dir) :repeat nil
   (interactive "<f>")
   (cd (if (zerop (length dir)) "~" dir)))
 
+(defun --save-exit() (save-buffer) (kill-buffer) (remove-hook 'yas-after-exit-snippet-hook '--save-exit))
+(evil-define-command ex:create-file (path &optional bang) :repeat nil
+  "Deploy files (and their associated templates) quickly. Will prompt
+you to fill in each snippet field before buffer closes unless BANG is
+provided."
+  (interactive "<f><!>")
+  (let ((dir (f-dirname path))
+        (fullpath (f-full path))
+        (is-auto t))
+    (when (and bang (not (f-exists? dir))) (f-mkdir dir))
+    (if (f-exists? dir)
+        (if (f-exists? fullpath)
+            (error "File already exists: %s" path)
+          (find-file fullpath)
+          (add-hook 'yas-after-exit-snippet-hook '--save-exit)
+          (if bang (--save-exit)))
+      (error "Directory doesn't exist: %s" dir))))
+
+(evil-define-command ex:rename-this-file (new-name &optional bang) :repeat nil
+  "Renames current buffer and file it is visiting."
+  (interactive "<f><!>")
+  (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 (if new-name new-name (read-file-name "New name: " filename))))
+        (if (get-buffer new-name)
+            (error "A buffer named '%s' already exists!" new-name)
+          (rename-file filename new-name 1)
+          (rename-buffer new-name)
+          (set-visited-file-name new-name)
+          (set-buffer-modified-p nil)
+          (when bang
+            (delete-file filename))
+          (message "File '%s' successfully renamed to '%s'"
+                   name (file-name-nondirectory new-name)))))))
+
 ;;;
-(evil-define-operator my:ex:scratch-buffer (beg end)
+(evil-define-operator ex:scratch-buffer (beg end)
-  :motion nil
   :move-point nil
   :type inclusive
-  :repeat nil
   (interactive "<r>")
   (let ((mode major-mode)
         (text (when (and beg end) (buffer-substring beg end))))
@@ -198,11 +179,9 @@ to abort the minibuffer."
     (if text (insert text))
     (funcall mode)))
 
-(evil-define-operator my:ex:org-capture (beg end)
+(evil-define-operator ex:org-capture (beg end)
-  :motion nil
   :move-point nil
   :type inclusive
-  :repeat nil
   (interactive "<r>")
   (let ((mode major-mode)
         (text (when (and beg end) (buffer-substring beg end))))
@@ -210,7 +189,7 @@ to abort the minibuffer."
         (org-capture-string text)
       (org-capture))))
 
-(evil-define-operator my:ex:retab (beg end)
+(evil-define-operator ex:retab (beg end)
   :motion nil
   :move-point nil
   :type line
@@ -224,18 +203,15 @@ spaces-to-tabs, depending on `indent-tab-mode'. Untested."
       (tabify beg end)
     (untabify beg end)))
 
-(evil-define-operator my:ex:run-code (beg end) :repeat nil
+(evil-define-operator ex:run-code (beg end)
-  :motion nil
   :move-point nil
-  :type exclusive
-  :repeat nil
   (interactive "<r>")
   (cond ((and beg end)
          (my:run-code-region beg end))
         (t
          (my:run-code-buffer))))
 
-(evil-define-operator my:ex:send-region-to-repl (beg end &optional bang) :repeat nil
+(evil-define-operator ex:send-region-to-repl (beg end &optional bang)
   :motion nil
   :move-point nil
   :type exclusive
@@ -245,3 +221,28 @@ spaces-to-tabs, depending on `indent-tab-mode'. Untested."
          (my:send-region-to-repl beg end))
         (t
          (my:switch-to-repl))))
+
+(evil-define-operator ex:snippets (beg end &optional name)
+  :motion nil
+  :move-point nil
+  :type exclusive
+  :repeat nil
+  "Create a new snippet (called `name'), or select from all the
+  current mode's snippets to edit."
+  (interactive "<r><a>")
+  (cond ((and beg end)
+         (yas-insert-snippet))
+        (t
+         (if name
+             (find-file (concat *snippets-dir (symbol-name major-mode) "/" name))
+           (yas-visit-snippet-file)))))
+
+(evil-define-operator ex:narrow-indirect (beg end)
+  :motion nil
+  :move-point nil
+  :type exclusive
+  :repeat nil
+  "Indirectly narrow the region from BEG to END."
+  (interactive "<r>")
+  (evil-normal-state)
+  (narrow-to-region-indirect beg end))

init/my-defuns.el

@@ -1,8 +0,0 @@
-(provide 'my-defuns)
-
-(shut-up
-  (load "defuns/utility")
-  (load "defuns/config")
-  (load "defuns/text")
-  (load "defuns/hooks")
-  (load "defuns/coderunner"))

init/my-keymaps.el

@@ -4,95 +4,93 @@
 ;; Global keymaps                     ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(global-set-key (kbd "M-x") 'smex)
+(bind (kbd "M-x") 'smex
-(global-set-key (kbd "M-X") 'smex-major-mode-commands)
+      (kbd "M-X") 'smex-major-mode-commands
-(global-set-key (kbd "C-:") 'eval-expression)
+      (kbd "C-;") 'eval-expression
-(global-set-key (kbd "C-j") "5j")
+      (kbd "C-`") 'popwin:popup-last-buffer
-(global-set-key (kbd "C-k") "5k")
 
-(when is-mac
+      (kbd "s-=")     'text-scale-increase
-  (when window-system
+      (kbd "s--")     'text-scale-decrease
-    (global-set-key (kbd "s-=")     'text-scale-increase)
+      (kbd "s-w")     'evil-window-delete
-    (global-set-key (kbd "s--")     'text-scale-decrease)
+      (kbd "s-/")     'evilnc-comment-or-uncomment-lines
-    (global-set-key (kbd "s-w")     'evil-window-delete)
+      (kbd "s-<f12>") 'toggle-frame-fullscreen)
-    (global-set-key (kbd "s-/")     'evilnc-comment-or-uncomment-lines)
-    (global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
 
 ;; Faster scrolling
-    (mapc (lambda(map)
+(bind '(normal visual)
-            (evil-define-key map my-mode-map (kbd "s-j") "5j")
+      (kbd "s-j")   "7j"
-            (evil-define-key map my-mode-map (kbd "s-k") "5k"))
+      (kbd "s-k")   "7k"
-          '(emacs normal visual))
+      (kbd "s-r")   'my:run-code-buffer
+      (kbd "s-R")   'my:switch-to-repl)
 
-    (nmap!  (kbd "s-t")   'projectile-find-file
+(bind 'normal  (kbd "s-t")   'projectile-find-file
+      (kbd "s-T")   'projectile-find-tag
       (kbd "s-p")   'projectile-switch-project
-            (kbd "s-m")   'my:ex:mru
+      (kbd "s-P")   'persp-switch
-            (kbd "s-M")   'projectile-recentf
+      (kbd "s-f")   'projectile-ag
+      (kbd "s-S-f") 'helm-do-ag
+      (kbd "s-m")   ",m"
+      (kbd "s-M")   ",M"
       (kbd "s-o")   'ido-find-file
-            (kbd "s-d")   'dash-at-point
+      (kbd "s-d")   'dash-at-point)
-            (kbd "s-b")   'my:ex:build)
 
-    (nvmap! (kbd "s-r")   ",r"
-            (kbd "s-R")   ",R")))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Local keymaps                      ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use
+(bind 'god
-;; define-key instead of n/vmap for this one to register.
+      ;; <localleader>
-(-nvmap ";" 'evil-ex)
+      ":"    'linum-mode
-(-nvmap "X" 'evil-exchange)
+      "\\"   'neotree-toggle
+      "="    'toggle-transparency
 
-;;;; <Leader> ;;;;;;;;;;;;;;;;;;;;;;;;;;
+      "of"   'my:send-dir-to-finder
-(nmap!  ",r"   'my:run-code-buffer
-        ",R"   'my:switch-to-repl
-        ",b"   'my:build
-        ",a"   'projectile-find-other-file
-        ",e"   'ido-find-file
-        ",E"   'my:ex:init-files
-        ",m"   'my:ex:mru                ; recent GLOBAL files
-        ",M"   'projectile-recentf       ; recent PROJECT files
-        ",p"   'projectile-switch-project
-        ",g"   'git-gutter+-show-hunk
-        ",;"   'helm-imenu
-        ",:"   'my:goto-symbol
-        ",,"   'ido-switch-buffer
-        ",."   'projectile-find-file)
-
-(vmap!  ",r"   'my:run-code-region
-        ",R"   'my:send-region-to-repl)
-
-(nvmap! ",="   'align-regexp)
-
-;;;; <localleader> ;;;;;;;;;;;;;;;;;;;;;
-(-nmap  "\\"   'evil-execute-in-god-state)
-(gmap!  ":"    'linum-mode
-        "\\"   'neotree-show
-        "|"    'neotree-hide
-
-        "oo"   'my:send-dir-to-finder
       "ou"   'my:send-to-transmit
       "ol"   'my:send-to-launchbar
       "oL"   'my:send-dir-to-launchbar
 
       ;; tmux: cd (default-directory)
-        "ot"   (λ (my:ex:tmux-chdir nil t))
+      "ot"   (λ (ex:tmux-chdir nil t))
       ;; tmux: cd [project root]
-        "oT"   'my:ex:tmux-chdir)
+      "oT"   'ex:tmux-chdir)
 
-;;;; Keybindings ;;;;;;;;;;;;;;;;;;;;;;;
+(bind '(normal visual)
-(nvmap! "gc"   'evil-ace-jump-char-mode
+      ";"    'evil-ex ; Remap ; to : - SPC and shift-SPC replace ; and ,
+      "\\"   'evil-execute-in-god-state ; localleader
+      "X"    'evil-exchange
+
+      "gc"   'evil-ace-jump-char-mode
       "gw"   'evil-ace-jump-word-mode  ; overwrites evil-fill
       "gl"   'evil-ace-jump-line-mode
+      "gt"   'ace-window
+      "gT"   (λ (ace-window 4))
+
+      "]e"   'next-error
+      "[e"   'previous-error
+      "]g"   'git-gutter+-next-hunk
+      "[g"   'git-gutter+-previous-hunk
 
       "]\\"  'er/expand-region
-        "[\\"  'er/contract-region
+      "[\\"  'er/contract-region)
 
-        "]g"   'git-gutter+-stage-hunks
+(bind 'normal
-        "[g"   'git-gutter+-revert-hunks)
+      ",r"   'my:run-code-buffer
+      ",R"   'my:switch-to-repl
+      ",a"   'helm-projectile-find-other-file
+      ",e"   'ido-find-file
+      ",E"   'ex:init-files
+      ",m"   'helm-recentf
+      ",M"   'helm-projectile-recentf ; recent PROJECT files
+      ",p"   'helm-projectile-switch-project
+      ",g"   'git-gutter+-show-hunk
+      ",;"   'helm-imenu
+      ",,"   'helm-projectile-switch-to-buffer
+      ",<"   'helm-buffers-list
+      ",]"   'helm-etags-select
+      ",/"   'helm-projectile-find-file
+      ",."   'helm-projectile-find-file-dwim
 
-(nmap!  ;; Moving rows rather than lines (in case of wrapping)
+      ;; Moving rows rather than lines (in case of wrapping)
       "j"    'evil-next-visual-line
       "k"    'evil-previous-visual-line
 
@@ -104,10 +102,8 @@
 
       "]b"   'next-buffer
       "[b"   'previous-buffer
-        "]e"   'next-error
+      "]p"   'persp-next
-        "[e"   'previous-error
+      "[p"   'persp-prev
-        "]h"   'git-gutter+-next-hunk
-        "[h"   'git-gutter+-previous-hunk
 
       ;; winner-mode: window layout undo/redo (see init-core.el)
       (kbd "C-w u")     'winner-undo
@@ -117,7 +113,12 @@
       (kbd "C--")       'evil-numbers/inc-at-pt
       (kbd "C-+")       'evil-numbers/dec-at-pt)
 
-(vmap!  ;; vnoremap < <gv
+(bind 'visual
+      ",="   'align-regexp
+      ",r"   'my:run-code-region
+      ",R"   'my:send-region-to-repl
+
+      ;; vnoremap < <gv
       "<"    (λ (evil-shift-left (region-beginning) (region-end))
                 (evil-normal-state)
                 (evil-visual-restore))
@@ -126,12 +127,13 @@
                 (evil-normal-state)
                 (evil-visual-restore)))
 
-(imap!  ;; Join lines from insert mode
+(bind 'insert
-        (kbd "<M-kp-delete>") 'evil-join
+      ;; Join lines from insert mode
+      (kbd "<M-kp-delete>") (λ (evil-forward-word) (evil-delete-backward-word))
 
       ;; Newline magic
-        (kbd "<S-backspace>") 'backward-delete-char
       (kbd "<backspace>")   'backward-delete-char-untabify
+      (kbd "<S-backspace>") 'backward-delete-char
       (kbd "<C-return>")    'evil-ret-and-indent
       (kbd "<M-return>")    (kbd "<return> DEL") ; newline and dedent
 
@@ -140,7 +142,8 @@
       (kbd "s-]")           (λ (evil-shift-right (point-at-bol) (point-at-eol)))
       (kbd "<backtab>")     (kbd "s-["))
 
-(emap!  ;; Preserve buffer-movement in emacs mode
+(bind 'emacs
+      ;; Preserve buffer-movement in emacs mode
       "\C-j"        'evil-next-line
       "\C-k"        'evil-previous-line
 
@@ -150,14 +153,19 @@
       (kbd "C-w k") 'evil-window-up)
 
 ;; Rotate-text (see elisp/rotate-text.el)
-(nmap!  "!" 'rotate-word-at-point)
+(bind 'normal "!" 'rotate-word-at-point)
-(vmap!  "!" 'rotate-region)
+(bind 'visual "!" 'rotate-region)
 
 ;; Easy escape from insert mode
-(ichmap "jj" 'evil-normal-state)
+(ibind "jj" 'evil-normal-state)
 
 ;; Enable TAB to do matchit
-(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
+(bind '(normal visual) evil-matchit-mode-map [tab] 'evilmi-jump-items)
+
+;; Additional operators
+(bind '(normal motion) "gr" 'ex:run-code)            ; code eval
+(bind '(normal motion) "gR" 'ex:send-region-to-repl) ; eval in repl
+(bind '(normal motion) "gx" 'ex:scratch-buffer)      ; send to scratch buffer
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -165,217 +173,64 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Real go-to-definition for elisp
-(mmap emacs-lisp-mode-map "gd"
+(bind 'motion emacs-lisp-mode-map "gd"
       (λ (let ((func (function-called-at-point)))
            (if func (find-function func)))))
+(bind 'motion emacs-lisp-mode-map "gD"
+      (λ (let ((func (function-called-at-point)))
+           (if func (find-function-other-window func)))))
 
-(after ag
+;; Peek at file from dired
-       (defmap ag-mode-map
+(bind dired-mode-map "o" (λ (popwin:find-file (dired-get-file-for-visit))))
-               [escape] 'ag-kill-buffers
-               "h"      nil))
 
-(after auto-complete
+;; Evil registers ;;;;;;;;;;;;;;;;;;;;;;
-       (imap ac-mode-map
+(bind evil-ex-completion-map
-             (kbd "C-x C-f")   'ac-complete-filename
+      (kbd "C-r")           #'evil-ex-paste-from-register   ; registers in ex-mode
-             (kbd "C-SPC")     'auto-complete)
+      (kbd "C-a")            'move-beginning-of-line
+      (kbd "<s-left>")       'move-beginning-of-line
+      (kbd "<s-right>")      'move-beginning-of-line
+      (kbd "<s-backspace>")  'evil-delete-whole-line)
+;; Quickly close/kill the command window
+(bind 'normal evil-command-window-mode-map
+      [escape]  'kill-buffer-and-window
+      "q"       'kill-buffer-and-window)
 
-       (defmap ac-completing-map
+;; Make C-g work like <esc>
-             (kbd "<tab>") 'ac-complete
+(bind '(normal visual insert) (kbd "C-g") 'evil-normal-state)
-             (kbd "C-n") 'ac-next
-             (kbd "C-p") 'ac-previous
-             (kbd "S-C-SPC") 'ac-quick-help
-             (kbd "ESC") 'ac-stop
-             (kbd "RET") 'ac-complete))
-
-(after emmet-mode
-       (imap emmet-mode-keymap
-             (kbd "s-e") 'emmet-expand-yas
-             (kbd "s-E") 'emmet-expand-line))
-
-(after js-mode
-       (imap js-mode-map [remap auto-complete] 'tern-ac-complete))
-
-(after markdown-mode
-       (let ((map markdown-mode-map))
-         (nvmap map
-                (kbd ",i") 'markdown-insert-image
-                (kbd ",l") 'markdown-insert-link
-                (kbd ",L") 'markdown-insert-reference-link-dwim)
-
-         (nmap map
-               "[p" 'markdown-promote
-               "]p" 'markdown-demote)
-
-         (imap map (kbd "M--") 'markdown-insert-hr)
-
-         (defmap map
-           (kbd "<backspace>")  nil
-           (kbd "<M-left>")     nil
-           (kbd "<M-right>")    nil
-
-           (kbd "s-*") 'markdown-insert-list-item
-           (kbd "s-b") 'markdown-insert-bold
-           (kbd "s-i") 'markdown-insert-italic
-           (kbd "s-`") 'markdown-insert-del)))
-
-(after multiple-cursors
-       (imap mc/keymap
-             (kbd "s-'")   'mc/mark-next-like-this
-             (kbd "s-\"")  'mc/mark-previous-like-this
-             (kbd "C-s-'") 'mc/mark-all-like-this)
-
-       (vmap mc/keymap
-             (kbd "s-'")   'mc/mark-next-like-this
-             (kbd "s-\"")  'mc/mark-previous-like-this
-             (kbd "C-s-'") 'mc/mark-all-like-this))
-
-(after nose
-       (nmap nose-mode-map
-             ",tr" 'nosetests-again
-             ",ta" 'nosetests-all
-             ",ts" 'nosetests-one
-             ",tv" 'nosetests-module
-             ",tA" 'nosetests-pdb-all
-             ",tO" 'nosetests-pdb-one
-             ",tV" 'nosetests-pdb-module))
-
-(after org
-       (imap org-mode-map [remap my.inflate-space-maybe] 'self-insert-command)
-       (define-key org-mode-map (kbd "RET") nil)
-       (define-key org-mode-map (kbd "C-j") nil)
-       (define-key org-mode-map (kbd "C-k") nil)
-
-       (mapc (lambda (state)
-               (evil-define-key state evil-org-mode-map
-                 (kbd "M-l") 'org-metaright
-                 (kbd "M-h") 'org-metaleft
-                 (kbd "M-k") 'org-metaup
-                 (kbd "M-j") 'org-metadown
-                 (kbd "M-L") 'org-shiftmetaright
-                 (kbd "M-H") 'org-shiftmetaleft
-                 (kbd "M-K") 'org-shiftmetaup
-                 (kbd "M-J") 'org-shiftmetadown
-                 (kbd "M-o") '(lambda () (interactive)
-                                (evil-org-eol-call
-                                 '(lambda()
-                                    (org-insert-heading)
-                                    (org-metaright))))
-                 (kbd "M-t") '(lambda () (interactive)
-                                (evil-org-eol-call
-                                 '(lambda()
-                                    (org-insert-todo-heading nil)
-                                    (org-metaright))))
-                 ))
-             '(normal insert))
-
-       ;; Formatting shortcuts
-       (imap evil-org-mode-map
-             (kbd "s-b") (λ (my/org-surround "*"))     ; bold
-             (kbd "s-u") (λ (my/org-surround "_"))     ; underline
-             (kbd "s-i") (λ (my/org-surround "/"))     ; italics
-             (kbd "s-`") (λ (my/org-surround "+"))     ; strikethrough
-
-             (kbd "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading))
-             (kbd "<s-return>") (λ (org-insert-heading-after-current))
-             )
-
-       (nvmap evil-org-mode-map
-              ",l" 'org-insert-link)
-
-       (vmap evil-org-mode-map
-             (kbd "s-b") "s*"          ; bold
-             (kbd "s-i") "s/")         ; italics
-
-       (nmap evil-org-mode-map
-             ",d" 'org-time-stamp
-             ",D" 'org-time-stamp-inactive
-             ",s" 'org-schedule
-             ",a" 'org-attach
-             ",A" 'org-attach-open
-             ",t" 'org-todo
-             ",T" 'org-show-todo-tree
-             ",/" 'org-sparse-tree
-             ",?" 'org-tags-view
-             ",+" 'org-align-all-tags
-             ",r" 'org-refile
-             "gh" 'outline-up-heading
-             "gj" 'org-forward-heading-same-level
-             "gk" 'org-backward-heading-same-level
-             "gl" 'outline-next-visible-heading
-             "go" 'org-open-at-point
-             "ga" 'org-agenda
-             "gt" 'org-show-todo-tree
-             "H" 'org-beginning-of-line
-             "L" 'org-end-of-line
-             "$" 'org-end-of-line
-             "^" 'org-beginning-of-line
-             "<" 'org-metaleft
-             ">" 'org-metaright
-             "-" 'org-cycle-list-bullet
-             (kbd ", SPC") 'org-archive-subtree
-             (kbd "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading) (evil-insert-state))
-             (kbd "<s-return>") (λ (org-insert-heading-after-current) (evil-insert-state))
-             (kbd "RET") (λ (if (org-entry-is-todo-p) (org-todo 'done)))
-             (kbd "TAB") 'org-cycle)
-       )
-
-(after ruby-mode
-       (nmap ruby-mode-map "gd" 'rsense-jump-to-definition))
-
-(after rspec-mode
-       (nmap rspec-mode-verifiable-keymap
-             ",tr" 'rspec-rerun
-             ",ta" 'rspec-verify-all
-             ",ts" 'rspec-verify-single
-             ",tv" 'rspec-verify)
-       (nmap rspec-dired-mode-keymap
-             ",tv" 'rspec-dired-verify
-             ",ts" 'rspec-dired-verify-single
-             ",ta" 'rspec-verify-all
-             ",tr" 'rspec-rerun))
-
-(after web-mode
-       (defmap web-mode-map (kbd "s-/") 'web-mode-comment-or-uncomment)
-
-       (nvmap web-mode-map
-              "]a" 'web-mode-attribute-next
-              "]t" 'web-mode-tag-next
-              "[t" 'web-mode-tag-previous
-              "]T" 'web-mode-element-child
-              "[T" 'web-mode-element-parent)
-
-       (nmap web-mode-map
-             "zf" 'web-mode-fold-or-unfold
-             ",t" 'web-mode-element-rename))
-
-(after re-builder
-       (nmap reb-mode-map
-             ",r" 'reb-enter-subexp-mode
-             ",b" 'reb-copy
-             ",i" 'reb-change-syntax
-             "\C-n" 'reb-next-match
-             "\C-p" 'reb-prev-match))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Ex Commands                        ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(exmap "msg"         'my:ex:msg-buffer)
+(defcmd "msg"         'popwin:messages)
-(exmap "recompile"   'my:ex:byte-compile-all)
+(defcmd "recompile"   'ex:byte-compile-all)
-(exmap "n[otes]"     'my:ex:notes)
+(defcmd "n[otes]"     'ex:notes)
-(exmap "ini"         'my:ex:init-files)
+(defcmd "ini"         'ex:init-files)
-(exmap "snip[pets]"  'my:ex:snippets)
+(defcmd "rec[ent]"    'ex:recent-files)
-(exmap "mru"         'my:ex:mru)
+(defcmd "snip[pets]"  'ex:snippets)
+(defcmd "retab"       'ex:retab)
+(defcmd "ag"          'ex:ag-search)
+(defcmd "agr"         'ex:ag-regex-search)
+(defcmd "x"           'ex:scratch-buffer)
+(defcmd "X"           'ex:org-capture)
+(defcmd "a"           'helm-projectile-find-other-file)
+(defcmd "cd"          'ex:cd)
+(defcmd "tcd"         'ex:tmux-chdir)
+(defcmd "t[mux]"      'ex:tmux-send)
+(defcmd "r[ege]x"     'regex-tool)
+(defcmd "en[ew]"      'ex:create-file)
+(defcmd "l[ast]"      'popwin:popup-last-buffer)
+(defcmd "run"         'ex:run-code)
+(defcmd "build"       'ex:build)
+(defcmd "k[ill]"      'kill-this-buffer)      ; Kill current buffer
+(defcmd "k[ill]all"   'ex:kill-buffers)       ; Kill all buffers (bang = project buffers only)
+(defcmd "k[ill]persp" 'my:kill-persp)         ; Kill current perspective
+(defcmd "k[ill]o"     'my:kill-other-buffers) ; Kill current project buffers
+(defcmd "sq[uint]"    'ex:narrow-indirect)    ; Narrow buffer to selection
+(defcmd "ren[ame]"    'ex:rename-this-file)   ; Rename file . Bang: Delete old one
 
-(exmap "retab"       'my:ex:retab)
+(after git-gutter+
-(exmap "ag"          'my:ex:ag-search)
+       (defcmd "gstage"   'git-gutter+-stage-hunks)
-(exmap "agr"         'my:ex:ag-regex-search)
+       (defcmd "grevert"  'git-gutter+-revert-hunks)
-(exmap "x"           'my:ex:scratch-buffer)
+       (defcmd "gdiff"    'git-gutter+-show-hunk))
-(exmap "X"           'my:ex:org-capture)
-(exmap "a"           'projectile-find-other-file)
-(exmap "bx"          'my:ex:kill-buffers)
-(exmap "tcd"         'my:ex:tmux-chdir)
-(exmap "t[mux]"      'my:ex:tmux-send)
-(exmap "build"       'my:ex:build)
-(exmap "re[gex]"     're-builder)

init/my-settings.el

@@ -6,7 +6,10 @@
  ;; Your init file should contain only one such instance.
  ;; If there is more than one, they won't work right.
  '(git-gutter:lighter " !")
- )
+ ;; Make brin theme safe
+ '(custom-safe-themes
+   (quote
+    ("7fa3f2865322ee4e3fcf061efcf020465d691aed02e6756191fbf1cfb8648ccf" default))))
 
 (set-face-background 'show-paren-match-face "#1f1f1f")
 (set-face-foreground 'show-paren-match-face "orange")

themes/brin-theme.el

@@ -28,7 +28,7 @@
 
   (custom-theme-set-variables 'brin)
 
-  (let ((background       "#1f1f1f")
+  (let ((background       "#222222")
         ;; (gutters          "#262E34")
         (gutters          "#1f252a")
         (gutter-fg        "#55616A")
@@ -49,12 +49,18 @@
         (delimiters       "#c0c5ce")
         (operators        "#c0c5ce")
         (keywords         "#b48ead")
-        (variables        "#bf616a")
+        (variables        "#CBECFF")
         (functions        "#8fa1b3")
         (methods          "#8fa1b3")
         (strings          "#a3be8c")
         (constants        "#d08770")
-        (white            "#ffffff"))
+        (white            "#ffffff")
+
+        (git-modified     "#B4924E")
+        (git-added        "#91E331")
+        ;; (git-added        "#55811D")
+        (git-deleted      "#A12121")
+        )
 
   (custom-theme-set-faces
    'brin
@@ -67,7 +73,7 @@
    `(region               ((t (:background ,selection) )))
    `(cursor               ((t (:background ,white) )))
    `(fringe               ((t (:background ,background :foreground ,white) )))
-   `(linum                ((t (:background ,linum :foreground ,gutter-fg) )))
+   `(linum                ((t (:background ,background :foreground ,gutter-fg) )))
 
    `(vertical-border      ((t (:foreground ,gutters-active) )))
 
@@ -76,14 +82,19 @@
                                :box (:line-width 3 :color ,gutters-active) ))))
 
    `(mode-line-inactive       ((t (:foreground ,gutter-fg
-                               :background ,gutters
+                               :background ,background
                                :box (:line-width 3 :color ,gutters) ))))
 
-   `(highlight-indentation-face                   ((t (:background ,linum) )))
+   `(mode-line-modified-face           ((t (:foreground ,builtin))))
-   `(highlight-indentation-current-column-face    ((t (:background ,gutters-active) )))
+
+   ;; `(highlight-indentation-face                   ((t (:background ,linum) )))
+   ;; `(highlight-indentation-current-column-face    ((t (:background ,gutters-active) )))
 
    `(flyspell-incorrect   ((t (:underline "#ff5555" :inherit unspecified))))
 
+   `(helm-source-header       ((t (:background ,gutters-active :foreground ,strings :weight bold :height 1.0))))
+   `(helm-selection       ((t (:background ,selection))))
+
 ;; Font lock faces
 ;; *****************************************************************************************
 
@@ -96,15 +107,30 @@
    `(font-lock-comment-face            ((t (:foreground ,comments))))
    `(font-lock-comment-delimiter-face  ((t (:foreground ,comments))))
    `(font-lock-function-name-face      ((t (:foreground ,functions))))
-   `(font-lock-doc-string-face        ((t (:foreground ,strings))))
+   `(font-lock-doc-string-face         ((t (:foreground ,comments))))
+   `(font-lock-doc-face                ((t (:foreground ,comments))))
+
+   `(trailing-whitespace               ((t (:background "#884444"))))
+   `(whitespace-tab                    ((t (:foreground "#444444"))))
+   `(whitespace-newline                ((t (:foreground "#444444"))))
+
+   `(git-gutter+-modified              ((t (:foreground ,git-modified))))
+   `(git-gutter+-added                 ((t (:foreground ,git-added))))
+   `(git-gutter+-deleted               ((t (:foreground ,git-deleted))))
+
+;; js2-mode
+;; *****************************************************************************************
+
+   `(js2-function-param                ((t (:foreground ,variables))))
+   `(js2-jsdoc-tag                     ((t (:foreground ,comments :weight bold :bold t))))
 
-   `(my-carriage-return-face        ((t (:foreground "#555555"))))
-   `(my-tab-face                    ((t (:foreground "#555555"))))
-   `(trailing-whitespace            ((t (:background "#884444")))))
 
 ;; *****************************************************************************************
 
-   )
+   `(persp-selected-face               ((t (:foreground ,builtin))))
+
+   ))
+
 
 ;; *****************************************************************************************