Overhaul rcfiles; fast startup!

This commit is contained in:
Henrik Lissner 2014-08-07 18:35:22 -04:00
parent 3231a145e7
commit 0b5c7add55
31 changed files with 940 additions and 819 deletions

3
.gitmodules vendored
View file

@ -4,3 +4,6 @@
[submodule "elisp/emacs-neotree"]
path = elisp/emacs-neotree
url = https://github.com/jaypei/emacs-neotree
[submodule "elisp/use-package"]
path = elisp/use-package
url = https://github.com/jwiegley/use-package

View file

@ -2,6 +2,7 @@
(defvar rotate-text-rotations
'(("true" "false")
("True" "False")
("yes" "no")
("left" "right" "top" "bottom")
("width" "height"))

1
elisp/use-package Submodule

@ -0,0 +1 @@
Subproject commit 019d11383d10d39aafc7fe4faae101b01c147146

92
init.el
View file

@ -8,81 +8,41 @@
;;
;;; Code:
(cd "~") ; Default directory, instead of /
;; (setq debug-on-error t)
(cd "~") ; Default directory, instead of /
(setq skip-installs t) ; Don't check packages (for slightly speedier startup)
;; (setq use-package-verbose t)
(server-mode t)
(unless (server-running-p) (server-start))
(desktop-save-mode t)
;; Global vars
(defvar my-dir (file-name-directory load-file-name))
(defvar my-core-dir (expand-file-name "init" my-dir))
(defvar my-modules-dir (expand-file-name "modules" my-dir))
(defvar my-themes-dir (expand-file-name "themes" my-dir))
(defvar my-elisp-dir (expand-file-name "elisp" my-dir))
(defvar my-tmp-dir (expand-file-name "tmp" my-dir))
(defvar my/dir (file-name-directory load-file-name))
(defvar my/init-dir (expand-file-name "init" my/dir))
(defvar my/themes-dir (expand-file-name "themes" my/dir))
(defvar my/elisp-dir (expand-file-name "elisp" my/dir))
(defvar my/tmp-dir (expand-file-name "tmp" my/dir))
(defvar my/snippets-dir (expand-file-name "snippets" my/dir))
;; Setup loadpaths
(add-to-list 'load-path my-core-dir)
(add-to-list 'load-path my-modules-dir)
(add-to-list 'load-path my-elisp-dir)
(add-to-list 'custom-theme-load-path my-themes-dir)
(defvar my/theme 'brin)
(defvar my/font "Inconsolata-14")
;; Font & color scheme
(load-theme 'brin t)
(defvar my-font "Inconsolata-14")
(add-to-list 'load-path my/init-dir)
;;;;;;;;;;;;;;;;;;;;;;;
;; Bootstrap
;;;;;;;;;;;;;;;;;;;;;;;
(dolist (module '(
;; Just the... bear necessities...
core ; Emacs core settings
core-packages ; Package init & management
core-ui ; Look and behavior of the emacs UI
core-editor ; Text/code editor settings and behavior
core-osx ; OSX-specific settings & functions
core-project ; Project navigation settings & packages
(mapc 'require
'(core ; Just the... bear necessities...
;; Modules to improve on emacs' heresy
mod-ac ; Auto-complete engine & settings
mod-snippets ; Snippet engine
mod-git ; GIT tools/settings
mod-fly ; Syntax and spell checkers
mod-emmet ; Zen-coding for HTML+CSS
; mod-shell ; Terminal emulator settings
init-project ; Project navigation tools & settings
init-ac ; Auto-complete engine & settings
init-snippets ; Snippet engine
init-git ; GIT tools/settings
init-fly ; Syntax and spell checker
;; Must be last
core-keymaps ; Global & local keybindings for all modes
mod-text ; Plain text editing (markdown, text)
mod-org ; Org-mode: personal gtd/notes
mod-dev ; Generic environment for all programming
mod-webdev ; Environment for webdev (SCSS, PHP, Rails, Jekyll)
mod-gamedev ; Environment for gamedev (C++, Lua, HTML5, etc)
mod-eclim ; Integration into eclipse (for Java)
))
(require module))
;;;; Modes ;;;;;;;;;;;;;;;;;;;;;;;;
;; Associates a mode with a path regex. If the third parameter is t,
;; then don't try to install the mode (use for modes that are included
;; with emacs).
(associate-mode 'ruby-mode '("\\.rb\\'" "\\.rake\\'" "Rakefile\\'"))
(associate-mode 'markdown-mode '("\\.md\\'" "\\.markdown\\'" "/README"))
(associate-mode 'scss-mode '("\\.scss\\'"))
(associate-mode 'org-mode '("\\.org\\'" "\\.gtd\\'") t)
(associate-mode 'js-mode '("\\.js\\'") t)
(associate-mode 'json-mode '("\\.json\\'" "\\.jshintrc\\'"))
(associate-mode 'web-mode '("\\.\\(p\\)?htm\\(l\\)?\\'" "\\.tpl\\(\\.php\\)?\\'" "\\.erb\\'"))
(associate-mode 'lua-mode '("\\.lua\\'"))
(associate-mode 'yaml-mode '("\\.yml\\'"))
(associate-mode 'python-mode '("\\.py\\'"))
(associate-mode 'c++-mode '("\\.h\\'") t)
(associate-mode 'shell-script-mode '("\\.zsh\\(rc\\|env\\)?\\'") t)
;; Specific mode-configs: DON'T NEED TO REQUIRE THESE.
;; They're here for your gf-ing convenience.
; modules/env-js-mode.el
; modules/env-ruby-mode.el
; modules/env-python-mode.el
; modules/env-lua-mode.el
; modules/env-python-mode.el
;;

View file

@ -1,133 +1,154 @@
(require-package 'evil)
;; Has to be done this way to ensure special buffers have evil,
;; evil-leader, and all the various keymaps enabled.
(evil-mode nil)
(add-hook 'after-init-hook (lambda() (evil-mode 1)))
;; Now we can carry on with the rest...
(require-packages
'(evil-leader
evil-nerd-commenter ; auto commenting made easy
evil-matchit ; jumping between block delimiters
evil-surround ; surround-with delimiters
evil-numbers ; increment/decrement numbers
evil-exchange ; exchanging two text objects (gx/gX)
evil-space ; mimics ; and , for f, F, t, T w/ space
evil-visualstar ; visual-based * and #
evil-ex-registers ; paste from registers in ex commands
autopair ; delimiter auto-closing
rainbow-delimiters ; colored matching parenthesis
rainbow-mode ; highlight color codes
saveplace ; restore cursor position on buffer load
volatile-highlights ; temporarily highlight changes on undo/yank
anzu ; display current + total matches searching
smex ; less M-x cruft
rotate-text ; like vim-switch
recentf ; access to list of recent files
key-chord ; for mapping key chords in insert mode
multiple-cursors ; cursors, of the numerous variety
ediff
))
(mapc 'my/install-package
'(evil
evil-leader
evil-nerd-commenter ; auto commenting made easy
evil-matchit ; jumping between block delimiters
evil-surround ; surround-with delimiters
evil-numbers ; increment/decrement numbers
evil-exchange ; exchanging two text objects (gx/gX)
evil-space ; mimics ; and , for f, F, t, T w/ space
evil-visualstar ; visual-based * and #
autopair ; delimiter auto-closing
rainbow-delimiters ; colored matching parenthesis
saveplace ; restore cursor position on buffer load
anzu ; display current + total matches searching
smex ; less M-x cruft
recentf ; access to list of recent files
key-chord ; for mapping key chords in insert mode
multiple-cursors ; cursors, of the numerous variety
ediff
))
;;;; Editor behavior ;;;;;;;;;;;;;;;;
(setq initial-scratch-buffer nil) ; empty scratch buffer
(electric-indent-mode +1) ; auto-indent on RET
(global-hl-line-mode +1) ; highlight the line
(setq-default
tab-width 4 ; set tab width to 4 for all buffers
indent-tabs-mode nil ; use tabs, not spaces
tab-always-indent nil)
;; do not soft-wrap lines
(setq-default truncate-lines t)
(setq truncate-partial-width-windows nil)
;; Prettify code-related major modes
(add-hook 'prog-mode-hook 'rainbow-delimiters-mode)
;; Remove trailing whitespace
(add-hook 'before-save-hook 'delete-trailing-whitespace)
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
;;;; Plugins ;;;;;;;;;;;;;;;;;;;;;;;;
(use-package evil
:diminish undo-tree-mode
:config
(progn
;; (setq evil-want-C-i-jump t)
;; (setq evil-want-C-u-scroll t)
(evil-mode 1)
(use-package evil-leader)
(use-package evil-nerd-commenter)
(use-package evil-matchit)
(use-package evil-surround)
(use-package evil-numbers)
(use-package evil-exchange)
(use-package evil-space)
(use-package evil-visualstar)
(use-package evil-ex-registers)
;; To get evil-leader mappings to work in the messages buffer...
(kill-buffer "*Messages*")
(setq evil-leader/in-all-states t)
(global-evil-leader-mode 1)
(global-evil-matchit-mode 1)
(global-evil-surround-mode 1)
(evil-exchange-install)
(evil-space-setup "t" ";" ",") ; Repeat t with space
(evil-space-setup "f" ";" ",") ; Repeat f with space
(evil-space-setup "T" "," ";") ; Repeat T with space
(evil-space-setup "F" "," ";") ; Repeat F with space
(evil-define-operator evil-destroy (beg end type register yank-handler)
(evil-delete beg end type ?_ yank-handler))
(evil-set-initial-state 'comint-mode 'insert)
;; Enable registers in ex-mode
(define-key evil-ex-completion-map (kbd "C-r") #'evil-ex-paste-from-register)))
(use-package rainbow-mode :defer t)
(use-package rainbow-delimiters
:commands rainbow-delimiters-mode
:init
(add-hook 'prog-mode-hook 'rainbow-delimiters-mode))
(use-package rotate-text :commands (rotate-word-at-point rotate-region))
;;;; Init plugins ;;;;;;;;;;;;;;;;;;;
(diminish 'undo-tree-mode)
(use-package autopair
:diminish autopair-mode
:init
(progn (autopair-global-mode)
(setq autopair-blink nil)
;; disable blink-matching-paren
(setq blink-matching-paren nil)))
;;;#evil
(setq evil-want-C-i-jump t)
(setq evil-want-C-u-scroll t)
(setq evil-leader/in-all-states t)
(use-package anzu
:diminish anzu-mode
:init (global-anzu-mode))
(global-evil-leader-mode)
(global-evil-matchit-mode 1)
(global-evil-surround-mode 1)
(use-package key-chord
:init
(progn (key-chord-mode 1)
(setq key-chord-two-keys-delay 0.5)))
(evil-exchange-install)
(use-package saveplace
:idle
(progn (setq-default save-place t)
(setq save-place-file (expand-file-name "saveplace" my/tmp-dir))))
(evil-space-setup "t" ";" ",") ; Repeat t with space
(evil-space-setup "f" ";" ",") ; Repeat f with space
(evil-space-setup "T" "," ";") ; Repeat T with space
(evil-space-setup "F" "," ";") ; Repeat F with space
(evil-define-operator evil-destroy (beg end type register yank-handler)
(evil-delete beg end type ?_ yank-handler))
(use-package savehist
:idle
(progn (setq savehist-additional-variables
;; search entries
'(search ring regexp-search-ring)
;; save every 5 minutes
savehist-autosave-interval 300
;; keep the home clean
savehist-file (expand-file-name "savehist" my/tmp-dir))
(savehist-mode 1)))
(evil-set-initial-state 'comint-mode 'insert)
(use-package multiple-cursors
:commands (mc/mark-next-like-this mc/mark-previous-like-this mc/mark-all-like-this)
:config
(progn
;; I do it this way because hooking mc/keyboard-quit to insert mode's exit
;; hook breaks multiple-cursors!
(defadvice keyboard-quit (around mc-and-keyboard-quit activate)
(mc/keyboard-quit) ad-do-it)))
;; Enable registers in ex-mode
(define-key evil-ex-completion-map (kbd "C-r") #'evil-ex-paste-from-register)
(use-package smex
:bind (("M-x" . smex)
("M-X" . 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)))
;;;#autopair
(autopair-global-mode)
(setq autopair-blink nil)
(setq blink-matching-paren nil) ; disable blink-matching-paren
(diminish 'autopair-mode)
;;;#anzu
(global-anzu-mode)
(diminish 'anzu-mode)
;;;#ediff
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
;;;#key-chord
(key-chord-mode 1)
(setq key-chord-two-keys-delay 0.5)
;;;#volatile-highlights
(volatile-highlights-mode t)
(diminish 'volatile-highlights-mode)
;;;#saveplace
(setq-default save-place t)
(setq save-place-file (expand-file-name "saveplace" my-tmp-dir))
;;;#savehist
(setq savehist-additional-variables
;; search entries
'(search ring regexp-search-ring)
;; save every 5 minutes
savehist-autosave-interval 300
;; keep the home clean
savehist-file (expand-file-name "savehist" my-tmp-dir))
(savehist-mode 1)
;;;#smex
(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)
;;;#recentf
(recentf-mode 1)
(setq recentf-max-menu-items 25)
(add-to-list 'recentf-exclude "\\.ido\\.last\\'")
(add-to-list 'recentf-exclude "\\.revive\\'")
(setq recentf-auto-cleanup 'never)
(use-package recentf
:idle
(progn (recentf-mode 1)
(add-to-list 'recentf-exclude "\\.ido\\.last\\'")
(add-to-list 'recentf-exclude "\\.revive\\'")
(setq recentf-max-menu-items 10)
(setq recentf-auto-cleanup 'never)))
;;
(provide 'core-editor)

View file

@ -1,56 +1,73 @@
;; Global keymaps ;;;;;;;;;;;;;;;
(gmap (kbd "<C-escape>") 'open-scratch-buffer)
(gmap (kbd "M-x") 'smex)
(gmap (kbd "M-X") 'smex-major-mode-commands)
(gmap (kbd "C-c C-p") 'package-list-packages)
(global-set-key (kbd "<C-escape>") 'my/open-scratch)
(global-set-key (kbd "C-c C-p") 'package-list-packages)
(when (is-osx)
(nmap (kbd "C-c o") 'send-dir-to-finder)
(nmap (kbd "C-c u") 'send-to-transmit)
(nmap (kbd "C-c l") 'send-to-launchbar)
(nmap (kbd "C-c L") 'send-dir-to-launchbar)
(nmap (kbd "C-c t") (lambda() (interactive) (shell)))
(nmap (kbd "C-s-RET") 'send-to-iterm)
(when is-mac
;; Send current file to OSX apps
(defun open-file-with (path &optional appName)
(if (not (string= "" appName))
(setq appName (concat "-a " appName ".app")))
(shell-command (concat "open " appName " " path)))
;; Evaluating elisp
(nmap (kbd "C-c x") 'eval-buffer)
(vmap (kbd "C-c x") 'eval-region)
(defun open-with (appName)
(interactive)
(open-file-with (buffer-file-name) appName))
(when window-system
(gmap (kbd "s-+") 'text-scale-increase)
(gmap (kbd "s--") 'text-scale-decrease)
(gmap (kbd "s-<f12>") 'toggle-frame-fullscreen)
(defun send-to-transmit () (interactive) (open-with "Transmit"))
(defun send-to-launchbar () (interactive) (open-with "LaunchBar"))
(defun send-dir-to-launchbar () (interactive) (open-file-with default-directory "LaunchBar"))
(defun send-dir-to-finder () (interactive) (open-file-with default-directory "Finder"))
(gmap (kbd "s-/") 'evilnc-comment-or-uncomment-lines)
(gmap (kbd "s-w") 'kill-buffer-and-window)
(nmap my/mode-map
(kbd "C-c o") 'send-dir-to-finder
(kbd "C-c u") 'send-to-transmit
(kbd "C-c l") 'send-to-launchbar
(kbd "C-c L") 'send-dir-to-launchbar
;; TODO: Open in tmux
(kbd "C-c t") (lambda() (interactive) (shell))
)
;; Faster scrolling
(nmap (kbd "s-j") "5j")
(nmap (kbd "s-k") "5k")
;; Evaluating elisp
(nmap my/mode-map (kbd "C-c x") 'eval-buffer)
(vmap my/mode-map (kbd "C-c x") 'eval-region)
;; Newlines from insert mode
(imap (kbd "<s-return>") 'evil-open-below)
(imap (kbd "<S-s-return>") 'evil-open-above)
(when window-system
(global-set-key (kbd "s-+") 'text-scale-increase)
(global-set-key (kbd "s--") 'text-scale-decrease)
(global-set-key (kbd "s-/") 'evilnc-comment-or-uncomment-lines)
(global-set-key (kbd "s-w") 'kill-buffer-and-window)
(global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
;; Fix OSX text navigation shortcuts
(imap (kbd "<s-left>") 'move-beginning-of-line)
(imap (kbd "<s-right>") 'move-end-of-line)
(imap (kbd "<s-backspace>") 'backward-kill-line)
(nmap my/mode-map
;; Faster scrolling
(kbd "s-j") "5j"
(kbd "s-k") "5k"
;; Fixes delete
(imap (kbd "<kp-delete>") 'delete-char)
;; Leader alternatives
(kbd "s-f") 'projectile-find-file
(kbd "s-F") 'projectile-ag
(kbd "s-m") 'helm-recentf
(kbd "s-M") 'projectile-recentf
(kbd "s-o") 'ido-find-file
(kbd "s-O") 'open-major-mode-conf
(kbd "s-d") 'mc/mark-next-like-this
(kbd "s-D") 'mc/mark-previous-like-this
(kbd "C-s-d") 'mc/mark-all-like-this)
;; Leader alternatives
(nmap (kbd "s-f") 'projectile-find-file)
(nmap (kbd "s-F") 'projectile-ag)
(nmap (kbd "s-m") 'helm-recentf)
(nmap (kbd "s-M") 'projectile-recentf)
(nmap (kbd "s-o") 'ido-find-file)
(nmap (kbd "s-O") 'open-major-mode-conf)
(nmap (kbd "s-d") 'mc/mark-next-like-this)
(nmap (kbd "s-D") 'mc/mark-all-like-this)
)
;; Newlines from insert mode
(imap my/mode-map
(kbd "<s-return>") 'evil-open-below
(kbd "<S-s-return>") 'evil-open-above
;; Fix OSX text navigation shortcuts
(kbd "<s-left>") 'move-beginning-of-line
(kbd "<s-right>") 'move-end-of-line
(kbd "<s-backspace>") 'backward-kill-line
;; Fixes delete
(kbd "<kp-delete>") 'delete-char)
)
)
@ -58,11 +75,11 @@
(evil-leader/set-leader ",")
(evil-leader/set-key
"`" 'open-major-mode-conf
"`" 'my/notes
"d" 'mc/mark-next-like-this
"D" 'mc/mark-all-like-this
"e" 'ido-find-file
"E" 'my-init
"E" 'my/initfiles
"f" 'projectile-find-file
"F" 'projectile-ag
"m" 'helm-recentf ; recent GLOBAL files
@ -76,14 +93,15 @@
"=" 'align-regexp
"x" 'kill-other-buffers
"X" 'kill-all-buffers
(kbd "RET") 'org-capture
)
(nmap
";" 'evil-ex ; Remap ; to : - SPC and shift-SPC replace ; and ,
":" 'eval-expression ; Elisp command
(nmap my/mode-map
";" 'evil-ex ; Remap ; to : - SPC and shift-SPC replace ; and ,
(kbd "C-;") 'eval-expression ; Elisp command
;; Moving rows rather than lines (in case of wrapping)
"j" 'evil-next-visual-line'
"j" 'evil-next-visual-line
"k" 'evil-previous-visual-line
"X" 'evil-destroy ; Delete without yanking
@ -106,7 +124,7 @@
(kbd "<S-C-tab>") 'evil-numbers/dec-at-pt
)
(vmap
(vmap my/mode-map
; vnoremap < <gv
"<" (lambda ()
(interactive)
@ -121,88 +139,47 @@
(evil-visual-restore))
)
(imap
(imap my/mode-map
(kbd "s-j") 'evil-join
(kbd "M-SPC") 'expand-space
(kbd "<C-return>") 'indent-new-comment-line
)
;; Commenting lines
(nmap "gcc" 'evilnc-comment-or-uncomment-lines)
(vmap "gc" 'evilnc-comment-or-uncomment-lines)
(nmap my/mode-map "gcc" 'evilnc-comment-or-uncomment-lines)
(vmap my/mode-map "gc" 'evilnc-comment-or-uncomment-lines)
;; Rotate-text (see elisp/rotate-text.el)
(nmap "!" 'rotate-word-at-point)
(vmap "!" 'rotate-region)
(nmap my/mode-map "!" 'rotate-word-at-point)
(vmap my/mode-map "!" 'rotate-region)
;; Enable TAB to do matchit
(evil-define-key 'normal evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
;; Easy escape from insert mode
(ichmap "jj" 'evil-normal-state)
;;;; Org-Mode ;;;;;;;;;;;;;;;;;;;
(evil-define-key 'normal evil-org-mode-map
"gh" 'outline-up-heading
"gj" (if (fboundp 'org-forward-same-level) ;to be backward compatible with older org version
'org-forward-same-level
'org-forward-heading-same-level)
"gk" (if (fboundp 'org-backward-same-level)
'org-backward-same-level
'org-backward-heading-same-level)
"gl" 'outline-next-visible-heading
"t" 'org-todo
"T" '(lambda () (interactive) (evil-org-eol-call (lambda() (org-insert-todo-heading nil))))
"H" 'org-beginning-of-line
"L" 'org-end-of-line
";t" 'org-show-todo-tree
"o" '(lambda () (interactive) (evil-org-eol-call 'always-insert-item))
"O" '(lambda () (interactive) (evil-org-eol-call 'org-insert-heading))
"$" 'org-end-of-line
"^" 'org-beginning-of-line
"<" 'org-metaleft
">" 'org-metaright
";a" 'org-agenda
"-" 'org-cycle-list-bullet
(kbd "TAB") 'org-cycle)
;; normal & insert state shortcuts.
(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))
;; Preserve buffer-movement in emacs mode
(emap my/mode-map
(kbd "C-w h") 'evil-window-left
(kbd "C-w l") 'evil-window-right
(kbd "C-w j") 'evil-window-down
(kbd "C-w k") 'evil-window-up
(kbd "s-j") "5j"
(kbd "s-k") "5k")
;;;; Ex Commands ;;;;;;;;;;;;;;;;
(cmap "retab" 'indent-region) ; TODO: Implement proper retab defun
(cmap "msg" 'view-echo-area-messages)
(evil-ex-define-cmd "retab" 'untabify) ; TODO: Implement proper retab defun
(evil-ex-define-cmd "msg" 'view-echo-area-messages)
;;;; Keymap fixes ;;;;;;;;;;;;;;;
;; Make ESC quit all the things
(nmap [escape] 'keyboard-quit)
(vmap [escape] 'keyboard-quit)
(nmap my/mode-map [escape] 'keyboard-quit)
(vmap my/mode-map [escape] 'keyboard-quit)
(mapc (lambda (map)
(define-key map [escape] 'minibuffer-quit))
(list
@ -237,13 +214,31 @@
(define-key ido-completion-map " " 'ido-exit-minibuffer)
))
;; Preserve buffer-movement in emacs mode
(emap (kbd "C-w h") 'evil-window-left)
(emap (kbd "C-w l") 'evil-window-right)
(emap (kbd "C-w j") 'evil-window-down)
(emap (kbd "C-w k") 'evil-window-up)
(emap (kbd "s-j") "5j")
(emap (kbd "s-k") "5k")
;;
(defun backward-kill-line ()
(interactive)
(evil-delete (point-at-bol) (point)))
(defun minibuffer-quit ()
"Abort recursive edit.
In Delete Selection mode, if the mark is active, just deactivate it;
then it takes a second \\[keyboard-quit] to abort the minibuffer."
(interactive)
(if (and delete-selection-mode transient-mark-mode mark-active)
(setq deactivate-mark t)
(when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
(abort-recursive-edit)))
(defun kill-other-buffers ()
(interactive)
(mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
(message "All other buffers killed"))
(defun kill-all-buffers ()
(interactive)
(mapc 'kill-buffer (buffer-list))
(message "All buffers killed"))
;;
(provide 'core-keymaps)

View file

@ -1,39 +1,15 @@
;; OSX-specific functionality
(when (is-osx)
;; GNU Emacs won't respect the login shell's PATH on mac, it seems,
;; this is necessary to fix the problem! (Thanks to lunaryorn @
;; <https://github.com/flycheck/flycheck/issues/438#issuecomment-49543748>)
(require-package 'exec-path-from-shell)
(exec-path-from-shell-initialize)
;; Use a shared clipboard
(setq x-select-enable-clipboard t)
;; Curse you Lion-esque fullscreen mode!
(setq ns-use-native-fullscreen nil)
;; Don't open files from the workspace in a new frame
(setq ns-pop-up-frames nil)
;; Ignore .DS_Store files with ido mode
(add-to-list 'ido-ignore-files ".DS_Store")
;; Use a shared clipboard
(add-hook 'before-make-frame-hook
(lambda() (setq x-select-enable-clipboard t)))
;; Curse you Lion-esque fullscreen mode!
(setq ns-use-native-fullscreen nil)
;; Don't open files from the workspace in a new frame
(setq ns-pop-up-frames nil)
;; Send current file to OSX apps
(defun open-file-with (path &optional appName)
(if (not (string= "" appName))
(setq appName (concat "-a " appName ".app")))
(shell-command (concat "open " appName " " path)))
(defun open-with (appName)
(interactive)
(open-file-with (buffer-file-name) appName))
(defun send-to-transmit () (interactive) (open-with "Transmit"))
(defun send-to-launchbar () (interactive) (open-with "LaunchBar"))
(defun send-dir-to-launchbar () (interactive) (open-file-with default-directory "LaunchBar"))
(defun send-dir-to-finder () (interactive) (open-file-with default-directory "Finder"))
)
(my/install-package 'exec-path-from-shell) ; fix emacs PATH on OSX
(use-package exec-path-from-shell
:if window-system
:init (exec-path-from-shell-initialize))
;;
(provide 'core-osx)

View file

@ -1,61 +1,32 @@
;; (require 'cl)
;; Package management bootstrap
(setq package-user-dir "~/.emacs.d/vendor/")
(setq package-user-dir (expand-file-name "vendor" my/dir))
(setq package-enable-at-startup nil)
(setq package-archives '(("melpa" . "http://melpa.milkbox.net/packages/")
("org" . "http://orgmode.org/elpa/")
("marmalade" . "http://marmalade-repo.org/packages/")
("gnu" . "http://elpa.gnu.org/packages/")))
(let ((default-directory my-elisp-dir))
(normal-top-level-add-to-load-path '("."))
(normal-top-level-add-subdirs-to-load-path))
(let ((default-directory my/elisp-dir))
(normal-top-level-add-to-load-path '("."))
(normal-top-level-add-subdirs-to-load-path))
(package-initialize)
;; Run a body of code *after* a package is ready
(defmacro after (feature &rest body)
"After FEATURE is loaded, evaluate BODY."
(declare (indent defun))
(if (fboundp 'with-eval-after-load)
`(with-eval-after-load ,feature ,@body)
`(eval-after-load ,feature '(progn ,@body))))
;; Check if a package is installed; if load is t, load it too.
;; Works for packages bundled with emacs too!
(defun require-package (package)
(message "=> require-package(%s)" package)
(unless (require package nil 'noerror)
(defun my/install-package (package)
(unless skip-installs
(message "=> checking: %s" package)
(unless (package-installed-p package)
(unless (assoc package package-archive-contents)
(package-refresh-contents))
(package-install package)))
(require package))
(unless (assoc package package-archive-contents)
(package-refresh-contents))
(message "=> installing: %s" package)
(package-install package))))
;; List version of require-package
(defun require-packages (packages)
(mapc 'require-package packages))
;; Associate an extension with a mode, and install the necessary
;; package(s) for it. Also look for a modules/env-*.el modefile for
;; extra configuration.
(defun associate-mode (mode ext &optional only-load-env)
(let* ((mode-name (symbol-name mode))
(env-mode-name (concat "env-" mode-name))
(mode-path (expand-file-name (concat env-mode-name ".el") my-modules-dir)))
(message "=> associate mode(%s)" mode-name)
;; (unless only-load-env (autoload mode mode-name))
(unless only-load-env (require-package mode))
(when (file-exists-p mode-path)
(message "==> has extra-conf (%s)" env-mode-name)
(require (intern env-mode-name))
)
)
(if (typep ext 'list)
(dolist (e ext)
(add-to-list 'auto-mode-alist `(,e . ,mode)))
(add-to-list 'auto-mode-alist `(,ext . ,mode))))
(require 'use-package)
;;
(provide 'core-packages)

View file

@ -1,98 +0,0 @@
(require-packages
'(ido-ubiquitous ; enhances ido-everywhere
projectile ; project search (like ctrlp)
helm ; augments search of, well, anything
grizzl ; better searching engine for projectile
ag ; the_silver_searcher support
flx-ido ; enhances ido's flex matching
ido-vertical-mode ; vertical listing for ido completion
;; project-explorer ; sidebar for navigation project files
dired+
))
(diminish 'projectile-mode)
;;#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)
;; ido remaps its keys every time it's invoked, this screws with
;; custom mappings. So we've gotta neuter ido.
(defun ido-init-completion-maps ())
(setq ido-common-completion-map (make-sparse-keymap))
(setq ido-file-dir-completion-map (make-sparse-keymap))
(setq ido-file-completion-map (make-sparse-keymap))
(setq ido-buffer-completion-map (make-sparse-keymap))
(set-keymap-parent ido-common-completion-map minibuffer-local-map)
(set-keymap-parent ido-file-dir-completion-map ido-common-completion-map)
(set-keymap-parent ido-file-completion-map ido-file-dir-completion-map)
(set-keymap-parent ido-buffer-completion-map ido-common-completion-map)
(ido-mode 1)
(ido-vertical-mode 1)
(ido-everywhere 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
ido-enable-tramp-completion nil
ido-enable-flex-matching t
ido-create-new-buffer 'always
ido-enable-tramp-completion t
ido-enable-last-directory-history t)
;; (add-to-list 'ido-ubiquitous-default-function-overrides '(disable exact "evil-ex"))
;;; Filters ido-matches setting acronynm matches in front of the results
(defadvice ido-set-matches-1 (after ido-smex-acronym-matches activate)
(if (and (fboundp 'smex-already-running) (smex-already-running)
(> (length ido-text) 1))
(let ((regex (concat "^" (mapconcat 'char-to-string ido-text "[^-]*-")))
(acronym-matches (list))
(remove-regexes '("-menu-")))
;; Creating the list of the results to be set as first
(dolist (item items)
(if (string-match (concat regex "[^-]*$") item) ;; strict match
(add-to-list 'acronym-matches item)
(if (string-match regex item) ;; appending relaxed match
(add-to-list 'acronym-matches item t))))
;; Filtering ad-return-value
(dolist (to_remove remove-regexes)
(setq ad-return-value
(delete-if (lambda (item)
(string-match to_remove item))
ad-return-value)))
;; Creating resulting list
(setq ad-return-value
(append acronym-matches
ad-return-value))
(delete-dups ad-return-value)
(reverse ad-return-value))))
;;#projectile
(projectile-global-mode)
(setq projectile-completion-system 'grizzl
projectile-enable-caching t)
;;#project-explorer
;; (setq pe/width 24)
;; (evil-set-initial-state 'project-explorer-mode 'emacs)
;; (add-hook 'project-explorer-mode-hook
;; (lambda() (no-linum)))
;;#neotree
(add-to-list 'load-path "/some/path/neotree")
(require 'neotree)
;;
(provide 'core-project)

View file

@ -1,12 +1,5 @@
(require-packages
'(
;; uniquify ; unique buffer names for identical filenames
diminish ; shrinks/removes modeline elements
))
(setq inhibit-startup-screen t) ; don't show EMACs start screen
(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no
(global-linum-mode t) ; line numbers for everybody!
(my/install-package 'diminish)
(global-linum-mode t) ; line numbers for everybody!
;; Sane scroll settings
(setq scroll-margin 3
@ -18,7 +11,7 @@
(column-number-mode t)
;; make the fringe unintrusive
(if (fboundp 'fringe-mode) (fringe-mode 8))
(when (fboundp 'fringe-mode) (fringe-mode 8))
;; Line numbers with +1 left-padding
(defadvice linum-update-window (around linum-dynamic activate)
@ -29,29 +22,16 @@
(setq frame-title-format
'(:eval (if (buffer-file-name) (abbreviate-file-name (buffer-file-name)) "%b")))
;;;#uniquify
;; (setq uniquify-buffer-name-style 'forward)
;; (setq uniquify-separator "/")
;; (setq uniquify-after-kill-buffer-p t) ; rename after killing uniquified
;; (setq uniquify-ignore-buffers-re "^\\*") ; don't muck with special buffers
;; Modeline settings
;; TODO: Customize modeline!
;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;
(add-to-list 'default-frame-alist `(font . ,my-font))
(add-to-list 'default-frame-alist '(alpha 98 95)) ; *slightly* transparent window
;; Use system clipboard
(setq ring-bell-function 'ignore)
(add-to-list 'default-frame-alist `(font . ,my/font))
(add-to-list 'default-frame-alist '(alpha 98 95)) ; *slightly* transparent window
(when (functionp 'tool-bar-mode) (tool-bar-mode -1))
(when (functionp 'scroll-bar-mode) (scroll-bar-mode -1))
(when (functionp 'menu-bar-mode) (menu-bar-mode -1))
;;
(provide 'core-ui)

View file

@ -1,43 +1,53 @@
;; (require 'cl)
;; Setup theme
(add-to-list 'custom-theme-load-path my/themes-dir)
(load-theme my/theme t)
;; Emacs under-the-hood
(setq redisplay-dont-pause t)
(prefer-coding-system 'utf-8)
(setq-default gc-cons-threshold 50000000) ; avoid garbage collection (default is only 400k)
(setq make-backup-files nil) ; Don't want any backup files
(setq auto-save-list-file-name nil) ; Don't want any .saves files
(setq auto-save-default nil) ; Don't want any auto saving
(setq redisplay-dont-pause t)
(setq-default gc-cons-threshold 50000000) ; avoid garbage collection (default is 400k)
(setq make-backup-files nil ; Don't want any backup files
auto-save-list-file-name nil ; Don't want any .saves files
auto-save-default nil) ; Don't want any auto saving
(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no
(setq inhibit-startup-screen t) ; don't show EMACs start screen
;; If I ever enable bkacups/autosaves, then change where they go
(setq backup-directory-alist `((".*" . ,my-tmp-dir)))
(setq auto-save-file-name-transforms `((".*" ,my-tmp-dir t)))
(setq backup-directory-alist `((".*" . ,my/tmp-dir)))
(setq auto-save-file-name-transforms `((".*" ,my/tmp-dir t)))
;; Always revert buffers if the files were changed
(global-auto-revert-mode 1)
;; window layout undo/redo, keymaps in init-evil.el
;; window layout undo/redo, keymaps in core-keymaps.el
(when (fboundp 'winner-mode) (winner-mode 1))
(defun kill-other-buffers ()
(interactive)
(mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
(message "All other buffers killed")
)
(defconst is-mac
(eq system-type 'darwin)
"Is this running on OS X?")
(defconst is-linux
(eq system-type 'gnu/linux)
"Is this running on Linux?")
;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;;
;; Vimmish keymapping shortcuts
(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))
;; insert-mode key-chord mapping
(defmacro ichmap (key command)
`(key-chord-define evil-insert-state-map ,key ,command))
(defun kill-all-buffers ()
(interactive)
(mapc 'kill-buffer (buffer-list))
(message "All buffers killed")
)
;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;;
;; I do it this way because hooking mc/keyboard-quit to insert mode's exit
;; hook breaks multiple-cursors!
(defadvice keyboard-quit (around mc-and-keyboard-quit activate)
(mc/keyboard-quit)
ad-do-it)
;; Make next/previous-buffer skip special buffers
(defadvice next-buffer (after avoid-messages-buffer-in-next-buffer)
"Advice around `next-buffer' to avoid going into the *Messages* buffer."
@ -50,114 +60,64 @@
;; Prevent prompts when trying to close window. If I'm closing the window,
;; I likely want it to close!
(defadvice save-buffers-kill-emacs (around no-y-or-n activate)
(flet ((yes-or-no-p (&rest args) t)
(y-or-n-p (&rest args) t))
ad-do-it))
(when window-system
(defadvice save-buffers-kill-emacs (around no-y-or-n activate)
(flet ((yes-or-no-p (&rest args) t)
(y-or-n-p (&rest args) t))
ad-do-it)))
;; Prevent GUI dialog boxes, they make emacs hang
(defadvice yes-or-no-p (around prevent-dialog activate)
(let ((use-dialog-box nil)) ad-do-it))
(defadvice y-or-n-p (around prevent-dialog-yorn activate)
(let ((use-dialog-box nil)) ad-do-it))
;;;; My personal minor mode ;;;;;;;;
(defvar my-mode-map (make-sparse-keymap))
(define-minor-mode my-mode :keymap my-mode-map)
(defvar my/mode-map (make-sparse-keymap))
(define-minor-mode my/mode :keymap my/mode-map :global t)
;;;; Commands ;;;;;;;;;;;;;;;;;;;;;;
(defun minibuffer-quit ()
"Abort recursive edit.
In Delete Selection mode, if the mark is active, just deactivate it;
then it takes a second \\[keyboard-quit] to abort the minibuffer."
(interactive)
(if (and delete-selection-mode transient-mark-mode mark-active)
(setq deactivate-mark t)
(when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
(abort-recursive-edit)))
;; File navigation defuns
(defun my-init ()
(defun my/initfiles ()
(interactive)
(find-file (expand-file-name "init.el" my-dir)))
(ido-find-file-in-dir my/dir))
(defun my-init-find ()
(interactive)
(projectile-find-file-in-directory my-dir))
(defun open-scratch-buffer ()
(defun my/open-scratch ()
(interactive)
(switch-to-buffer (get-buffer-create "*scratch*"))
(text-mode))
;; Open the modules/env-{major-mode-name}.el file, if it exists
(defun open-major-mode-conf ()
(interactive)
(let ((path (major-mode-module-path)))
(if (file-exists-p path)
(find-file path)
(progn
(find-file path)
(message (concat "Mode (" (major-mode-name) ") doesn't have a module! Creating it..."))))))
;;
(defun backward-kill-line ()
(interactive)
(evil-delete (point-at-bol) (point)))
(defun expand-space ()
(defun my/expand-space ()
(interactive)
(save-excursion (insert " ")))
(defun expand-backspace ()
(defun my/expand-backspace ()
(interactive)
(save-excursion (delete-char 1))
(delete-backward-char 1))
(defun toggle-sidebar ()
(defun my/enable-hard-wrap()
(interactive)
(project-explorer-open))
(auto-fill-mode 1))
(defun major-mode-name ()
(symbol-name major-mode))
(defun major-mode-module-name ()
(concat "env-" (major-mode-name)))
(defun major-mode-module-path ()
(expand-file-name (concat (major-mode-module-name) ".el") my-modules-dir))
;; TODO: Write better eval-and-replace
(defun my/byte-recompile ()
(interactive)
(byte-recompile-file (expand-file-name "init.el" my/dir))
(byte-recompile-directory my/init-dir 0)
(byte-recompile-directory my/elisp-dir 0))
;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;;
;; Vimmish keymapping shortcuts
(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))
;; Global mapping
(defmacro gmap (key command)
`(global-set-key ,key ,command))
;; insert-mode key-chord mapping
(defmacro ichmap (key command)
`(key-chord-define evil-insert-state-map ,key ,command))
;; defines ex commands
(defmacro cmap (ex function)
`(evil-ex-define-cmd ,ex ,function))
;; This one's unique for my own special mappings
;; (defmacro map (key command)
;; `(define-key my-mode-map ,key ,command))
(defmacro is-osx () '(eq system-type 'darwin))
;;;; Defuns ;;;;;;;;;;;;;;;;;;;;;;;
(defun no-linum () (linum-mode 0))
;;;; Load the rest ;;;;;;;;;;;;;;;;;;
(require 'core-packages)
(require 'core-ui)
(require 'core-editor)
(use-package core-osx :if is-mac)
(add-hook 'after-init-hook (lambda() (require 'core-keymaps)))
;;
(provide 'core)

47
init/init-ac.el Normal file
View file

@ -0,0 +1,47 @@
(my/install-package 'auto-complete)
(use-package auto-complete
:diminish auto-complete-mode
:idle
(progn (require 'auto-complete-config)
(add-hook 'prog-mode-hook
(lambda()
(add-to-list 'ac-sources 'ac-source-filename)
(add-to-list 'ac-sources 'ac-source-files-in-current-dir)))
;; Use more vim-like keymappings
(add-hook 'change-major-mode-hook
(lambda () (imap ac-mode-map (kbd "C-SPC") 'auto-complete)))
;; (setq ac-auto-start 2)
;; (setq ac-auto-show-menu nil ; 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-us-quick-help nil ; Don't show tooltips unless invoked (see core-keymaps.el)
;; ac-fuzzy-cursor-color nil)
;; Keep auto-complete quiet until it's needed
(setq ac-auto-start nil)
(ac-config-default)
(ac-linum-workaround) ; Fix line number flux bug
;; (ac-flyspell-workaround) ; Compatibility with flyspell/make
)
:config
(progn (add-to-list 'ac-dictionary-files "~/.emacs.d/ac-dict/global")
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
(imap ac-mode-map (kbd "C-S-SPC") 'auto-complete)
(define-key ac-completing-map (kbd "<tab>") 'ac-expand)
(define-key ac-completing-map (kbd "C-n") 'ac-next)
(define-key ac-completing-map (kbd "C-p") 'ac-previous)
(define-key ac-completing-map (kbd "<F1>") 'ac-quick-help)
(define-key ac-completing-map (kbd "ESC") 'ac-stop)
(define-key ac-completing-map [return] nil)
;; Tell ido not to care about case
(setq completion-ignore-case t)
))
;;
(provide 'init-ac)

22
init/init-fly.el Normal file
View file

@ -0,0 +1,22 @@
(mapc 'my/install-package '(flycheck flyspell))
(use-package flycheck
:commands global-flycheck-mode
:diminish (flycheck-mode . " !")
:init (add-hook 'after-init-hook #'global-flycheck-mode)
:config
(progn
;; Removed checks on idle/change for snappiness
(setq flycheck-check-syntax-automatically '(save new-line mode-enabled))
(setq flycheck-indication-mode 'right-fringe)
(setq-default flycheck-disabled-checkers '(emacs-lisp-checkdoc))))
(use-package flyspell
:commands flyspell-mode
:diminish (flyspell-mode . " @")
:config
(setq ispell-program-name "aspell"
ispell-list-command "--list"))
;;
(provide 'init-fly)

53
init/init-git.el Normal file
View file

@ -0,0 +1,53 @@
(mapc 'my/install-package
'(git-commit-mode
git-rebase-mode
gitconfig-mode
gitignore-mode
git-gutter-fringe))
(use-package git-commit-mode
:mode (("/COMMIT_EDITMSG\\'" . git-commit-mode)
("/NOTES_EDITMSG\\'" . git-commit-mode)
("/MERGE_MSG\\'" . git-commit-mode)
("/TAG_EDITMSG\\'" . git-commit-mode)
("/PULLREQ_EDITMSG\\'" . git-commit-mode)))
(use-package git-rebase-mode
:mode ("/git-rebase-todo\\'" . git-rebase-mode))
(use-package gitconfig-mode
:mode (("/\\.gitconfig\\'" . gitconfig-mode)
("/\\.git/config\\'" . gitconfig-mode)
("/git/config\\'" . gitconfig-mode)
("/\\.gitmodules\\'" . gitconfig-mode))
:config (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-fringe
:diminish git-gutter-mode
:init
(progn
(global-git-gutter-mode t)
(add-hook 'git-gutter-mode-on-hook
(lambda() (fringe-mode '(4 . 8)))))
:config
(progn
(custom-set-variables '(git-gutter:lighter " !"))
(custom-set-variables '(git-gutter:verbosity 0))
(set-face-foreground 'git-gutter-fr:modified "#555555")
(set-face-background 'git-gutter-fr:modified "#444444")
(set-face-foreground 'git-gutter-fr:deleted "#995555")
(set-face-background 'git-gutter-fr:deleted "#884444")
(set-face-foreground 'git-gutter-fr:added "#559955")
(set-face-background 'git-gutter-fr:added "#448844")
))
;;
(provide 'init-git)

101
init/init-project.el Normal file
View file

@ -0,0 +1,101 @@
(mapc 'my/install-package
'(ido-ubiquitous ; enhances ido-everywhere
ido-vertical-mode ; vertical listing for ido completion
flx-ido ; enhances ido's flex matching
projectile ; project search (like ctrlp)
helm ; augments search of, well, anything
grizzl ; better searching engine for projectile
ag ; the_silver_searcher support
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)
(add-hook 'dired-load-hook (lambda() (use-package dired+)))
(use-package ag :defer t)
(use-package helm :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
projectile-enable-caching t)))
(use-package ido
:init
(progn
;; ido remaps its keys every time it's invoked, this screws with
;; custom mappings. So we've gotta neuter ido.
(defun ido-init-completion-maps ())
(setq ido-common-completion-map (make-sparse-keymap))
(setq ido-file-dir-completion-map (make-sparse-keymap))
(setq ido-file-completion-map (make-sparse-keymap))
(setq ido-buffer-completion-map (make-sparse-keymap))
(set-keymap-parent ido-common-completion-map minibuffer-local-map)
(set-keymap-parent ido-file-dir-completion-map ido-common-completion-map)
(set-keymap-parent ido-file-completion-map ido-file-dir-completion-map)
(set-keymap-parent ido-buffer-completion-map ido-common-completion-map))
:config
(progn
(use-package ido-ubiquitous)
(use-package ido-vertical-mode)
(ido-mode 1)
(ido-vertical-mode 1)
(ido-everywhere 1)
(use-package flx-ido :init (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
ido-enable-tramp-completion nil
ido-enable-flex-matching t
ido-create-new-buffer 'always
ido-enable-tramp-completion t
ido-enable-last-directory-history t)
;; (add-to-list 'ido-ubiquitous-default-function-overrides '(disable exact "evil-ex"))
;; Filters ido-matches setting acronynm matches in front of the results
(defadvice ido-set-matches-1 (after ido-smex-acronym-matches activate)
(if (and (fboundp 'smex-already-running) (smex-already-running)
(> (length ido-text) 1))
(let ((regex (concat "^" (mapconcat 'char-to-string ido-text "[^-]*-")))
(acronym-matches (list))
(remove-regexes '("-menu-")))
;; Creating the list of the results to be set as first
(dolist (item items)
(if (string-match (concat regex "[^-]*$") item) ;; strict match
(add-to-list 'acronym-matches item)
(if (string-match regex item) ;; appending relaxed match
(add-to-list 'acronym-matches item t))))
;; Filtering ad-return-value
(dolist (to_remove remove-regexes)
(setq ad-return-value
(delete-if (lambda (item)
(string-match to_remove item))
ad-return-value)))
;; Creating resulting list
(setq ad-return-value
(append acronym-matches
ad-return-value))
(delete-dups ad-return-value)
(reverse ad-return-value))))))
;;
(provide 'init-project)

30
init/init-snippets.el Normal file
View file

@ -0,0 +1,30 @@
(my/install-package 'yasnippet)
(use-package yasnippet
:diminish (yas-minor-mode . " $")
:mode (("emacs.+/snippets/" . snippet-mode))
:pre-load (progn
;; Fix yasnippet keymaps so they only work in insert mode (why they
;; had to make this so complicated I don't know); must be defined
;; BEFORE we include yasnippet.
(defvar yas-minor-mode-map
(let ((map (make-sparse-keymap)))
(evil-define-key 'insert map [(tab)] 'yas-expand)
(evil-define-key 'insert map (kbd "TAB") 'yas-expand)
(evil-define-key 'insert map "\C-c&\C-s" 'yas-insert-snippet)
(evil-define-key 'insert map "\C-c&\C-n" 'yas-new-snippet)
(evil-define-key 'insert map "\C-c&\C-v" 'yas-visit-snippet-file)
map)))
:config
(progn
;; Only load personal snippets
(setq yas-snippet-dirs `(,my/snippets-dir))
(yas-reload-all))
:init
(progn
(add-hook 'prog-mode-hook 'yas-minor-mode)
(add-hook 'org-mode-hook 'yas-minor-mode)))
;;
(provide 'init-snippets)

73
init/mod-dev.el Normal file
View file

@ -0,0 +1,73 @@
(mapc 'my/install-package
'(yaml-mode
jedi
python-mode
inf-ruby
ac-inf-ruby
rbenv
json-mode
))
(use-package yaml-mode :mode "\\.yaml\\'")
(use-package json-mode
:mode (("\\.json\\'" . json-mode)
("\\.jshintrc\\'" . json-mode)))
(use-package python
:mode ("\\.py\\'" . python-mode)
:interpreter ("python" . python-mode)
:config
(progn
(use-package jedi
:init
(if (not (file-directory-p "~/.emacs.d/.python-environments/default/"))
(jedi:install-server)))
;; Let autopair work with triple-quotes
(setq autopair-handle-action-fns
(list #'autopair-default-handle-action
#'autopair-python-triple-quote-action))
;; Don't remap backspace. Leave it to autopair, please.
(define-key python-mode-map [backspace] nil)
(nmap python-mode-map (kbd "s-r")
(lambda()
(interactive)
(shell-command-on-region (point-min) (point-max) "python")))
(vmap python-mode-map (kbd "s-r")
(lambda()
(interactive)
(shell-command-on-region (region-beginning) (region-end) "python")))
)
:init
(add-hook 'python-mode-hook 'jedi:ac-setup)
;; (evil-define-key 'insert ac-mode-map (kbd "C-SPC") 'jedi:complete)
)
(use-package ruby-mode
:mode (("\\.rb\\'" . ruby-mode)
("\\.rake\\'" . ruby-mode)
("Rakefile\\'" . ruby-mode))
:interpreter "ruby"
:config
(progn
(require 'ruby-mode-indent-fix)
(evil-set-initial-state 'inf-ruby-mode 'insert)
(setq ruby-indent-level 4)
(setq ruby-deep-indent-paren nil)
(use-package rbenv)
(use-package inf-ruby
:init
(add-to-list 'ac-modes 'inf-ruby-mode))
(use-package ac-inf-ruby
:init
(add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable)))
)
;;
(provide 'mod-dev)

5
init/mod-eclim.el Normal file
View file

@ -0,0 +1,5 @@
;; TODO Eclim stuff
;;
(provide 'mod-eclim)

22
init/mod-gamedev.el Normal file
View file

@ -0,0 +1,22 @@
(mapc 'my/install-package '(lua-mode))
(use-package lua-mode
:mode "\\.lua\\'"
:interpreter "lua"
:init
(add-hook 'lua-mode-hook
(lambda()
(nmap lua-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (point-min) (point-max) "lua")))
(vmap lua-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) "lua")))
(define-key lua-mode-map (kbd "s-b")
(lambda() (shell-command (concat "love " default-directory)))
))))
(use-package c++-mode :mode "\\.h\\'")
;;
(provide 'mod-gamedev)

151
init/mod-org.el Normal file
View file

@ -0,0 +1,151 @@
(mapc 'my/install-package '(org))
;; Ex-commands
(evil-ex-define-cmd "gtd" 'open-gtd)
(evil-ex-define-cmd "notes" 'open-notes)
;; Defuns
(defun my/org-insert-list-item ()
"Force insertion of org item"
(interactive)
(if (not (org-in-item-p))
(insert "\n- ")
(org-insert-item)))
(defun my/org-eol-call (fun)
"Go to end of line and call provided function"
(end-of-line)
(funcall fun)
(evil-append nil))
(defun my/gtd()
"Load up my notes folder in dropbox"
(interactive)
(find-file "~/Dropbox/notes/gtd.org"))
(defun my/notes()
"Load up my notes folder in dropbox"
(interactive)
(ido-find-file-in-dir "~/Dropbox/notes"))
;;
(use-package org
:mode ("\\.org\\'" . org-mode)
:init
(progn
(setq org-directory "~/Dropbox/notes")
(setq org-default-notes-file (concat org-directory "/notes.org"))
(setq org-archive-location "~/Dropbox/notes/archives.org")
(setq org-agenda-files '("~/Dropbox/notes/gtd.org"
"~/Dropbox/notes/notes.org"
"~/Dropbox/notes/blog.org"
"~/Dropbox/notes/invoices.org"
"~/Dropbox/notes/journal.org"
"~/Dropbox/notes/vocab.org"
"~/Dropbox/notes/excerpts.org"))
(setq org-completion-use-ido t)
(setq org-hide-leading-stars t)
(setq org-export-backends '(ascii html latex md))
(setq org-todo-keywords
'((sequence "TODO" "DOING" "VERIFY" "WAITING" "|" "DONE" "DELEGATED")))
(setq org-tag-alist '(("@work" . ?b)
("@home" . ?h)
("@writing" . ?w)
("@errands" . ?e)
("@drawing" . ?d)
("@coding" . ?c)
("@phone" . ?p)
("@reading" . ?r)
("@computer" . ?l)
("quantified" . ?q)
("lowenergy" . ?0)
("highenergy" . ?1)))
(setq org-capture-templates
'(("t" "TODO" entry (file+headline (concat org-directory "/gtd.org") "Inbox") "* TODO %? %u")
("T" "TODO Someday" entry (file+headline (concat org-directory "/gtd.org") "Someday") "* TODO %? %u :someday:")
("i" "Invoice" entry (file+headline (concat org-directory "/invoices.org") "Invoices") "** TODO %?")
("n" "Note" entry (file+datetree (concat org-directory "/notes.org")) "** %?")
("b" "Blog" entry (file+datetree (concat org-directory "/blog.org")) "** %?")
("j" "Journal" entry (file+datetree (concat org-directory "/journal.org")) "** %?%^g\n%?\nAdded: %U")
("v" "Vocab" entry (file (concat org-directory "/vocab.org")) "* %?")
("e" "Excerpt" entry (file (concat org-directory "/excerpts.org")) "* %?")
))
(define-minor-mode evil-org-mode
"Buffer local minor mode for evil-org"
:init-value nil
:lighter " EvilOrg"
:keymap (make-sparse-keymap) ; defines evil-org-mode-map
:group 'evil-org)
;; Keymaps
(imap evil-org-mode-map
(kbd "<s-return>") 'org-insert-heading-after-current)
(vmap evil-org-mode-map
",l" 'org-insert-link
)
(nmap evil-org-mode-map
",a" 'org-attach
",A" 'org-agenda
",t" 'org-todo
",T" 'org-show-todo-tree
",\\" 'org-match-sparse-tree
"gh" 'outline-up-heading
"gj" (if (fboundp 'org-forward-same-level) ;to be backward compatible with older org version
'org-forward-same-level
'org-forward-heading-same-level)
"gk" (if (fboundp 'org-backward-same-level)
'org-backward-same-level
'org-backward-heading-same-level)
"gl" 'outline-next-visible-heading
"go" 'org-open-at-point
"gr" 'org-refile
"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-todo
(kbd "TAB") 'org-cycle
)
;; normal & insert state shortcuts.
(mapc (lambda (state)
(evil-define-key state evil-org-mode-map
(kbd "M--") 'my/org-insert-list-item
(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)
(my/org-eol-call
'(lambda()
(org-insert-heading)
(org-metaright))))
(kbd "M-t") '(lambda () (interactive)
(my/org-eol-call
'(lambda()
(org-insert-todo-heading nil)
(org-metaright))))
))
'(normal insert))
(add-hook 'org-mode-hook (lambda() (evil-mode nil) (evil-mode 1)))
(add-hook 'org-mode-hook 'evil-org-mode)
(add-hook 'org-mode-hook 'flyspell-mode)
(add-hook 'org-mode-hook 'my/enable-hard-wrap))
)
;;
(provide 'mod-org)

17
init/mod-text.el Normal file
View file

@ -0,0 +1,17 @@
(mapc 'my/install-package '(markdown-mode))
(add-hook 'text-mode-hook 'my/enable-hard-wrap)
(use-package markdown-mode
:mode (("\\.md\\'" . markdown-mode)
("/README\\'" . markdown-mode))
:init
(add-hook 'markdown-mode-hook
(lambda()
;; Restore native mac M-left/right functionality
(local-unset-key (kbd "<M-left>"))
(local-unset-key (kbd "<M-right>")))))
;;
(provide 'mod-text)

55
init/mod-webdev.el Normal file
View file

@ -0,0 +1,55 @@
(mapc 'my/install-package
'(emmet-mode
scss-mode
web-mode
haml-mode
tern
tern-auto-complete
php-mode
rainbow-mode ; highlight color codes
))
(use-package rainbow-mode
:defer t
:init (add-hook 'scss-mode 'rainbow-mode))
(use-package scss-mode :mode "\\.scss\\'")
(use-package haml-mode :mode "\\.haml\\'")
(use-package web-mode
:mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
("\\.tpl\\(\\.php\\)?\\'" . web-mode)
("\\.erb\\'" . web-mode)))
(use-package php-mode
:mode "\\.php\\'"
:interpreter "php"
:config
(setq php-template-compatibility nil))
(use-package tern
:commands (tern-mode tern-ac-complete tern-ac-setup)
:config
(progn (use-package tern-auto-complete)
(setq tern-ac-on-dot nil))
:init
;; replace auto-complete with tern-ac-complete only in js-mode
(add-hook 'js-mode-hook
(lambda ()
(imap ac-mode-map (kbd "C-SPC") 'tern-ac-complete)
(tern-mode t)
(tern-ac-setup))))
(use-package emmet-mode
:defer t
:config
(progn
(imap 'emmet-mode-map (kbd "s-e") 'emmet-expand-line)
(add-hook 'scss-mode-hook 'emmet-mode)
(add-hook 'web-mode-hook 'emmet-mode)
(add-hook 'nxml-mode-hook 'emmet-mode))
)
;;
(provide 'mod-webdev)

View file

@ -1,40 +0,0 @@
(require-packages '(tern tern-auto-complete))
(setq tern-ac-on-dot nil)
;; replace auto-complete with tern-ac-complete only in js-mode
(add-hook 'js-mode-hook
(lambda ()
(evil-define-key 'insert ac-mode-map (kbd "C-SPC") 'tern-ac-complete)
(tern-mode t)
(tern-ac-setup)
))
;; Let flycheck handle parse errors
;; (setq-default js2-show-parse-errors nil)
;; (setq-default js2-strict-missing-semi-warning nil)
;; (setq-default js2-strict-trailing-comma-warning t) ;; jshint does not warn about this now for some reason
;; (defun js2-parse-jshintrc ()
;; "This looks recursively up for a .jshintrc and extracts the
;; globals from it to add them to js2-additional-externs."
;; (let* ((jshintrc (expand-file-name ".jshintrc" (locate-dominating-file default-directory ".jshintrc")))
;; (json (and jshintrc (json-read-file jshintrc)))
;; (globals (and json (cdr (assq 'globals json)))))
;; (when globals
;; (setq js2-additional-externs
;; (append
;; (mapcar (lambda (pair) (symbol-name (car pair))) globals)
;; js2-additional-externs
;; )
;; )
;; (js2-reparse t)
;; )
;; )
;; )
;; (add-hook 'js2-init-hook 'js2-parse-jshintrc)
;;
(provide 'env-js-mode)

View file

@ -1,14 +0,0 @@
(add-hook 'lua-mode-hook
(lambda()
(evil-define-key 'normal lua-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (point-min) (point-max) "lua")))
(evil-define-key 'visual lua-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) "lua")))
(define-key lua-mode-map (kbd "s-b")
(lambda() (shell-command (concat "love " default-directory)))
)))
;;
(provide 'env-lua-mode)

View file

@ -1,26 +0,0 @@
(require-package 'jedi)
(if (not (file-directory-p "~/.emacs.d/.python-environments/default/"))
(jedi:install-server))
;; (setq jedi:complete-on-dot nil)
(add-hook 'python-mode-hook 'jedi:ac-setup)
(add-hook 'python-mode-hook
(lambda ( )
;; (evil-define-key 'insert ac-mode-map (kbd "C-SPC") 'jedi:complete)
;; Don't remap backspace. Leave it to autopair, please.
(define-key python-mode-map [backspace] nil)
(evil-define-key 'normal python-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (point-min) (point-max) "python")))
(evil-define-key 'visual python-mode-map (kbd "s-r")
(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) "python")))
;; Let autopair work with triple-quotes
(setq autopair-handle-action-fns
(list #'autopair-default-handle-action
#'autopair-python-triple-quote-action))))
;;
(provide 'env-python-mode)

View file

@ -1,17 +0,0 @@
(require-packages
'(inf-ruby
ac-inf-ruby
rbenv
))
(add-to-list 'ac-modes 'inf-ruby-mode)
(add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable)
(evil-set-initial-state 'inf-ruby-mode 'insert)
(setq ruby-indent-level 4)
(setq ruby-deep-indent-paren nil)
(require 'ruby-mode-indent-fix)
;;
(provide 'env-ruby-mode)

View file

@ -1,45 +0,0 @@
(require-packages
'(auto-complete ; self-explanity
auto-complete-config ; its default config
))
;; (setq ac-auto-start 2)
;; (setq ac-auto-show-menu nil ; 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-us-quick-help nil ; Don't show tooltips unless invoked (see core-keymaps.el)
;; ac-fuzzy-cursor-color nil)
;; Keep auto-complete quiet until it's needed
(setq ac-auto-start nil)
(ac-config-default)
(ac-linum-workaround) ; Fix line number flux bug
(ac-flyspell-workaround) ; Compatibility with flyspell/make
(diminish 'auto-complete-mode) ; Hide mode-line entry
(add-to-list 'ac-dictionary-files "~/.emacs.d/ac-dict/global")
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
;; Use more vim-like keymappings
(add-hook 'change-major-mode-hook
(lambda () (evil-define-key 'insert ac-mode-map (kbd "C-SPC") 'auto-complete)))
(evil-define-key 'insert ac-mode-map (kbd "C-S-SPC") 'auto-complete)
(define-key ac-completing-map (kbd "<tab>") 'ac-expand)
(define-key ac-completing-map (kbd "C-n") 'ac-next)
(define-key ac-completing-map (kbd "C-p") 'ac-previous)
(define-key ac-completing-map (kbd "<F1>") 'ac-quick-help)
(define-key ac-completing-map (kbd "ESC") 'ac-stop)
(define-key ac-completing-map [return] nil)
(add-hook 'prog-mode-hook 'enable-path-completion)
(defun enable-path-completion ()
(add-to-list 'ac-sources 'ac-source-filename)
(add-to-list 'ac-sources 'ac-source-files-in-current-dir))
;; Tell ido not to care about case
(setq completion-ignore-case t)
;;
(provide 'mod-ac)

View file

@ -1,10 +0,0 @@
(require-package 'emmet-mode)
(add-hook 'scss-mode-hook 'emmet-mode) ;; Enable Emmet's css abbreviation.
(add-hook 'web-mode-hook 'emmet-mode) ;; Auto-start on any markup modes
(add-hook 'nxml-mode-hook 'emmet-mode) ;; XML too...
(imap (kbd "s-e") 'emmet-expand-line)
(provide 'mod-emmet)

View file

@ -1,22 +0,0 @@
(require-packages
'(flycheck ; syntax checker
flyspell ; spell checker
))
;;;#flyspell
(diminish 'flyspell-mode " ?")
(setq ispell-program-name "aspell")
(setq ispell-list-command "--list")
(dolist (hook '(markdown-mode-hook git-commit-mode-hook org-mode-hook))
(add-hook hook (lambda() (flyspell-mode 1))))
;;;#flycheck
;; Removed checks on idle/change for snappiness
(setq flycheck-check-syntax-automatically '(save new-line mode-enabled))
(setq flycheck-indication-mode 'right-fringe)
(setq-default flycheck-disabled-checkers '(emacs-lisp-checkdoc))
(global-flycheck-mode 1)
;;
(provide 'mod-fly)

View file

@ -1,25 +0,0 @@
(require-packages
'(git-commit-mode
git-rebase-mode
gitconfig-mode
gitignore-mode
git-gutter-fringe
))
(custom-set-variables '(git-gutter:lighter " !"))
(custom-set-variables '(git-gutter:verbosity 0))
(set-face-foreground 'git-gutter-fr:modified "#555555")
(set-face-background 'git-gutter-fr:modified "#444444")
(set-face-foreground 'git-gutter-fr:deleted "#995555")
(set-face-background 'git-gutter-fr:deleted "#884444")
(set-face-foreground 'git-gutter-fr:added "#559955")
(set-face-background 'git-gutter-fr:added "#448844")
; (setq git-gutter-fr:side 'right-fringe)
(global-git-gutter-mode t)
(add-hook 'git-gutter-mode-on-hook
(lambda() (fringe-mode '(4 . 8))))
;;
(provide 'mod-git)

View file

@ -1,26 +0,0 @@
;; Fix yasnippet keymaps so they only work in insert mode (why they
;; had to make this so complicated I don't know); must be defined
;; BEFORE we include yasnippet.
(defvar yas-minor-mode-map
(let ((map (make-sparse-keymap)))
(evil-define-key 'insert map [(tab)] 'yas-expand)
(evil-define-key 'insert map (kbd "TAB") 'yas-expand)
(evil-define-key 'insert map "\C-c&\C-s" 'yas-insert-snippet)
(evil-define-key 'insert map "\C-c&\C-n" 'yas-new-snippet)
(evil-define-key 'insert map "\C-c&\C-v" 'yas-visit-snippet-file)
map))
;; Require yasnippet *after* the minor mode map's been overwritten
(require-package 'yasnippet)
;;;#yasnippet
(associate-mode 'snippet-mode '("emacs.+/snippets/") t)
(add-hook 'prog-mode-hook
'(lambda ()
(yas-minor-mode)
(diminish 'yas-minor-mode " @")
))
;;
(provide 'mod-snippets)