Refactor initfiles

This commit is contained in:
Henrik Lissner 2014-09-05 17:08:40 -04:00
parent 6b094920bd
commit f2e2f05742
34 changed files with 1161 additions and 860 deletions

48
init.el
View file

@ -19,38 +19,46 @@
(unless (server-running-p) (server-start)))
;; Global vars
(defconst my/dir (file-name-directory load-file-name))
(defconst my/init-dir (expand-file-name "init" my/dir))
(defconst my/themes-dir (expand-file-name "themes" my/dir))
(defconst my/elisp-dir (expand-file-name "elisp" my/dir))
(defconst my/tmp-dir (expand-file-name "tmp" my/dir))
(defconst my/snippets-dir (expand-file-name "snippets" my/dir))
(defconst *dir (file-name-directory load-file-name))
(defconst *init-dir (expand-file-name "init" *dir))
(defconst *themes-dir (expand-file-name "themes" *dir))
(defconst *elisp-dir (expand-file-name "elisp" *dir))
(defconst *snippets-dir (expand-file-name "snippets" *dir))
(defconst *ac-dicts-dir (expand-file-name "ac-dict" *dir))
(defconst my/theme 'brin)
(defconst my/font "Inconsolata-14")
;; (defconst my/font "Ubuntu-Mono-16")
(defconst *theme 'brin)
(defconst *font "Inconsolata-16")
;; (defconst my/font "Ubuntu-Mono-15")
(add-to-list 'load-path my/init-dir)
(add-to-list 'load-path *init-dir)
(mapc 'require
'(core ; Just the... bear necessities...
;;; These are implicitly loaded from core.el, leave them commented!
;; core-editor ; Internal config for global editor behavior
;; core-ui ; User interface layout & behavior
;; core-osx ; Mac-specific config
;; my-keymaps ; My keybindings (loaded on after-init-hook)
my-defuns ; Personal functions
;; Modules to improve on emacs' heresy
init-ido ; Ido setup
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
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-love ; Love.app gamedev
mod-cpp ; C++ gamedev
mod-eclim ; Integration into eclipse (for Java)
mod-csharp ; Emacs as a Csharp/Unity IDE
;; mod-collab ; For collab programming
init-text ; Plain text editing (markdown, text)
init-org ; Org-mode: personal gtd/notes
init-dev ; Generic environment for all programming
init-ruby
init-python
init-webdev ; Environment for webdev (SCSS, PHP, Rails, Jekyll)
init-love ; Love.app gamedev
init-cpp ; C++ gamedev
init-eclim ; Integration into eclipse (for Java)
init-csharp ; Emacs as a Csharp/Unity IDE
;; init-collab ; For collab programming
))

View file

@ -1,34 +1,24 @@
(provide 'core-editor)
;;;; Editor behavior ;;;;;;;;;;;;;;;;
(blink-cursor-mode -1)
(setq sentence-end-double-space nil)
(setq require-final-newline t)
(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)
;; Remove trailing whitespace
(setq-default tab-width 4)
(setq-default indent-tabs-mode nil)
(setq-default tab-always-indent nil)
;;;; Modes 'n hooks ;;;;;;;;;;;;;;;;;
(add-to-list 'auto-mode-alist '("\\.plist\\'" . nxml-mode))
(add-to-list 'auto-mode-alist '("zsh\\(env\\|rc\\)?\\'" . shell-script-mode))
(add-to-list 'auto-mode-alist '("z\\(profile\\|login\\|logout\\)?\\'" . shell-script-mode))
(add-to-list 'auto-mode-alist '("zsh/" . shell-script-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)
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
;; All this just to show errant tab characters
(add-hook 'font-lock-mode-hook
(function
(lambda ()
(setq font-lock-keywords
(append font-lock-keywords
'(("\r" (0 'my-carriage-return-face t))
("\t" (0 'my-tab-face t))))))))
(setq whitespace-style (quote (face trailing tab-mark)))
(setq whitespace-display-mappings '((tab-mark 9 [?> 9] [92 9])))
(add-hook 'find-file-hook 'whitespace-mode)
;;;; Plugins ;;;;;;;;;;;;;;;;;;;;;;;;
(use-package highlight-indentation
:init
(add-hook 'prog-mode-hook 'highlight-indentation-mode))
;;;; Evil-mode ;;;;;;;;;;;;;;;;;;;;;;;
(use-package evil
:diminish undo-tree-mode
:config
@ -44,9 +34,6 @@
(use-package evil-nerd-commenter)
(use-package evil-ex-registers)
;; To get evil-leader mappings to work in the messages buffer...
(kill-buffer "*Messages*")
(global-evil-matchit-mode 1)
(global-evil-surround-mode 1)
@ -59,19 +46,21 @@
(evil-define-operator evil-destroy (beg end type register yank-handler)
(evil-delete beg end type ?_ yank-handler))
;; Enable half-cursor blink when using ace-jump
(defadvice evil-ace-jump-char-mode (around evil-ace-jump-char-mode-operator-mode activate)
(evil-half-cursor) ad-do-it)
(defadvice evil-ace-jump-word-mode (around evil-ace-jump-word-mode-operator-mode activate)
(evil-half-cursor) ad-do-it)
(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)))
(define-key evil-ex-completion-map (kbd "C-r") #'evil-ex-paste-from-register)
))
(use-package rainbow-delimiters
:commands rainbow-delimiters-mode
:init (add-hook 'prog-mode-hook 'rainbow-delimiters-mode))
;;;; Editing plugins ;;;;;;;;;;;;;;;;;;;
(use-package expand-region)
(use-package rotate-text
:commands (rotate-word-at-point rotate-region))
;;;; Init plugins ;;;;;;;;;;;;;;;;;;;
(use-package autopair
:diminish autopair-mode
:init
@ -84,29 +73,6 @@
:diminish anzu-mode
:init (global-anzu-mode))
(use-package expand-region)
(use-package key-chord
:init
(progn (key-chord-mode 1)
(setq key-chord-two-keys-delay 0.5)))
(use-package saveplace
:init
(progn (setq-default save-place t)
(setq save-place-file (expand-file-name "saveplace" my/tmp-dir))))
(use-package savehist
:init
(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)))
(use-package multiple-cursors
:commands (mc/mark-next-like-this mc/mark-previous-like-this mc/mark-all-like-this)
:config
@ -116,6 +82,12 @@
(defadvice keyboard-quit (around mc-and-keyboard-quit activate)
(mc/keyboard-quit) ad-do-it)))
;;;; Utility plugins ;;;;;;;;;;;;;;;;;;
(use-package key-chord
:init
(progn (key-chord-mode 1)
(setq key-chord-two-keys-delay 0.5)))
(use-package smex
:commands (smex smex-major-mode-commands)
:config
@ -125,13 +97,17 @@
(when (boundp 'smex-cache) (smex-update)))
(add-hook 'after-load-functions 'smex-update-after-load)))
(use-package uniquify
:config
(setq uniquify-buffer-name-style 'forward))
(use-package recentf
:init
(progn (recentf-mode 1)
(add-to-list 'recentf-exclude "\\.ido\\.last\\'")
(add-to-list 'recentf-exclude "\\.revive\\'")
(setq recentf-max-menu-items 0)
(setq recentf-auto-cleanup 'never)))
;;
(provide 'core-editor)
(setq recentf-max-menu-items 0
recentf-max-saved-items 75
recent5-auto-cleanup 'never
recentf-exclude '("/tmp/"
"/ssh:"
"\\.ido\\.last\\'"
"\\.revive\\'"))))

View file

@ -1,248 +0,0 @@
;; Global keymaps ;;;;;;;;;;;;;;;
(global-set-key (kbd "<C-escape>") 'my/open-scratch)
(global-set-key (kbd "C-c C-p") 'package-list-packages)
(global-set-key (kbd "M-x") 'smex)
(global-set-key (kbd "M-X") 'smex-major-mode-commands)
(when is-mac
;; TODO: Open in tmux
(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
(kbd "C-c t") 'my/tmux-chdir
(kbd "C-c T") (λ (my/tmux-chdir (projectile-project-root))))
;; Evaluating elisp
(nmap my/mode-map (kbd "C-c x") 'eval-buffer)
(vmap my/mode-map (kbd "C-c x") 'eval-region)
(when window-system
(global-set-key (kbd "s-=") 'text-scale-increase)
(global-set-key (kbd "s--") 'text-scale-decrease)
(global-set-key (kbd "s-w") 'evil-window-delete)
(global-set-key (kbd "s-/") 'evilnc-comment-or-uncomment-lines)
(global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
(global-set-key (kbd "C-;") 'eval-expression)
(global-set-key (kbd "s-;") 'my/tmux-run)
(global-set-key (kbd "s-:") 'my/tmux-paste)
;; Faster scrolling
(mapc (lambda(map)
(evil-define-key map my/mode-map (kbd "s-j") "5j")
(evil-define-key map my/mode-map (kbd "s-k") "5k"))
'(emacs normal visual))
(nmap my/mode-map
;; Leader alternatives
(kbd "s-t") 'projectile-find-file
(kbd "s-F") 'projectile-ag
(kbd "s-p") 'projectile-switch-project
(kbd "s-m") 'my/recentf-ido-find-file
(kbd "s-M") 'projectile-recentf
(kbd "s-o") 'ido-find-file
(kbd "s-d") 'dash-at-point
(kbd "s-'") 'mc/mark-next-like-this
(kbd "s-\"") 'mc/mark-previous-like-this
(kbd "C-s-'") 'mc/mark-all-like-this)
(imap my/mode-map
;; Textmate-esque insert-line before/after
(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)
(imap emmet-mode-keymap
(kbd "s-e") 'emmet-expand-yas
(kbd "s-E") 'emmet-expand-line)))
;; Local keymaps ;;;;;;;;;;;;;;;;
(nmap my/mode-map
",'" 'mc/mark-next-like-this
",\"" 'mc/mark-all-like-this
",e" 'ido-find-file
",E" 'my/initfiles
",g" 'git-gutter:stage-hunk
",G" 'git-gutter:revert-hunk
",m" 'my/recentf-ido-find-file ; recent GLOBAL files
",M" 'projectile-recentf ; recent PROJECT files
",p" 'projectile-switch-project
",\\" 'neotree-show
",|" 'neotree-hide
",;" 'helm-imenu
",:" 'my/ido-goto-symbol
",," 'ido-switch-buffer
",." 'projectile-find-file
",=" 'align-regexp
(kbd ", RET") 'org-capture)
;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use
;; define-key instead of n/vmap for this one to register.
(define-key evil-normal-state-map ";" 'evil-ex)
(define-key evil-visual-state-map ";" 'evil-ex)
(nmap my/mode-map
;; Moving rows rather than lines (in case of wrapping)
"j" 'evil-next-visual-line
"k" 'evil-previous-visual-line
"X" 'evil-destroy ; Delete without yanking
;; behave like D and C; yank to end of line
"Y" (λ (evil-yank (point) (point-at-eol)))
"zz" 'kill-this-buffer ; Close buffer
"]b" 'previous-buffer
"[b" 'next-buffer
"]e" 'next-error
"[e" 'previous-error
"]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
(kbd "C-w C-r") 'winner-redo
;; Increment/decrement number under cursor
(kbd "C--") 'evil-numbers/inc-at-pt
(kbd "C-+") 'evil-numbers/dec-at-pt)
(vmap my/mode-map
;; vnoremap < <gv
"<" (λ (evil-shift-left (region-beginning) (region-end))
(evil-normal-state)
(evil-visual-restore))
;; vnoremap > >gv
">" (λ (evil-shift-right (region-beginning) (region-end))
(evil-normal-state)
(evil-visual-restore))
"+" 'er/expand-region
"_" 'er/contract-region)
(imap my/mode-map
;; Make DEL act like expandtab in vim
(kbd "DEL") 'backward-delete-whitespace-to-column
;; Join lines from insert mode
(kbd "<M-kp-delete>") 'evil-join
;; Newline magic
(kbd "RET") 'newline-and-indent
(kbd "M-RET") (kbd "RET DEL")
(kbd "<C-return>") 'indent-new-comment-line
;; Textmate-esque indent shift left/right
(kbd "s-[") (λ (evil-shift-left (point-at-bol) (point-at-eol)))
(kbd "s-]") (λ (evil-shift-right (point-at-bol) (point-at-eol)))
(kbd "<backtab>") (kbd "s-["))
(emap my/mode-map
;; Preserve buffer-movement in emacs mode
"j" 'evil-next-line
"k" 'evil-previous-line
(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)
;; Rotate-text (see elisp/rotate-text.el)
(nmap my/mode-map "!" 'rotate-word-at-point)
(vmap my/mode-map "!" 'rotate-region)
;; Easy escape from insert mode
(ichmap "jj" 'evil-normal-state)
;; Enable TAB to do matchit
(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
;; Real go-to-definition for elisp
(nmap emacs-lisp-mode-map "gd"
(λ (let ((func (function-called-at-point)))
(if func (find-function func)))))
;;;; Ex Commands ;;;;;;;;;;;;;;;;
(evil-ex-define-cmd "retab" 'untabify) ; TODO: Implement proper retab defun
(evil-ex-define-cmd "msg" 'view-echo-area-messages)
(evil-ex-define-cmd "gtd" 'open-gtd)
(evil-ex-define-cmd "n[otes]" 'my/notes)
(evil-ex-define-cmd "tcd" (λ (my/tmux-chdir (projectile-project-root))))
(evil-ex-define-cmd "ag" 'projectile-ag)
(evil-ex-define-cmd "el" 'my/initfiles)
(evil-ex-define-cmd "bx" (λ (my/kill-all-buffers)))
;;;; Keymap fixes ;;;;;;;;;;;;;;;
;; Make ESC quit all the things
(mapc (lambda (map)
(define-key map [escape] 'minibuffer-quit))
(list minibuffer-local-map
minibuffer-local-ns-map
minibuffer-local-completion-map
minibuffer-local-must-match-map
minibuffer-local-isearch-map))
(define-key evil-emacs-state-map [escape] 'evil-exit-emacs-state)
;; Close help/compilation windows with escape
(define-key help-mode-map [escape] 'kill-buffer-and-window)
(define-key compilation-mode-map [escape] 'kill-buffer-and-window)
;; Restore bash-esque keymaps in insert mode and the minibuffer
(mapc (lambda (map)
(define-key map (kbd "C-a") 'move-beginning-of-line)
(define-key map (kbd "C-e") 'move-end-of-line)
(define-key map (kbd "C-u") 'backward-kill-line))
(list minibuffer-local-map minibuffer-local-ns-map evil-insert-state-map))
(define-key evil-insert-state-map (kbd "C-w") 'backward-kill-word)
(define-key minibuffer-local-map (kbd "C-w") 'ido-delete-backward-word-updir)
(add-hook 'ido-setup-hook '(lambda ()
;; take that "Text is read-only" and stick it where emacs don't shine!
(define-key ido-completion-map (kbd "<backspace>") 'ido-delete-backward-updir)
(define-key ido-completion-map "\C-n" 'ido-next-match)
(define-key ido-completion-map "\C-p" 'ido-prev-match)
;; Auto-complete on tab/space (why is it called ido-exit-minibuffer?)
(define-key ido-completion-map " " 'ido-exit-minibuffer)))
;;
(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 backward-kill-line ()
(interactive)
(evil-delete (point-at-bol) (point)))
;; Mimic expandtab in vim
(defun 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)
(if indent-tabs-mode
(call-interactively 'backward-delete-char-untabify)
(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-untabify (- (match-end 1) (match-beginning 1)))
(call-interactively 'backward-delete-char-untabify))))))
;;
(provide 'core-keymaps)

View file

@ -1,3 +1,4 @@
(provide 'core-osx)
;; Use a shared clipboard
(setq x-select-enable-clipboard t)
@ -10,6 +11,3 @@
(use-package exec-path-from-shell
:if (memq window-system '(mac ns))
:init (exec-path-from-shell-initialize))
;;
(provide 'core-osx)

View file

@ -1,23 +0,0 @@
;; Package management bootstrap
(setq package-enable-at-startup nil
;; 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/"))
package-archive-exclude-alist
'(("melpa" org-trello)
("melpa" org)
("marmalade" org)
("gnu" org)))
(let ((default-directory my/elisp-dir))
(normal-top-level-add-to-load-path '("."))
(normal-top-level-add-subdirs-to-load-path))
;; (package-initialize)
(require 'use-package)
(require 'diminish)
;;
(provide 'core-packages)

View file

@ -1,4 +1,7 @@
(global-linum-mode t) ; line numbers for everybody!
(provide 'core-ui)
;; (global-linum-mode t) ; line numbers for everybody!
;; (blink-cursor-mode -1)
;; Show line/col-no in mode-line
(line-number-mode t)
@ -8,22 +11,34 @@
(when (fboundp 'fringe-mode) (fringe-mode 8))
;; Line numbers with +1 left-padding
(defadvice linum-update-window (around linum-dynamic activate)
(let* ((w (length (number-to-string (count-lines (point-min) (point-max)))))
(linum-format (concat "%" (number-to-string (+ w 1)) "d" " "))) ad-do-it))
;; (defadvice linum-update-window (around linum-dynamic activate)
;; (let* ((w (length (number-to-string (count-lines (point-min) (point-max)))))
;; (linum-format (concat "%" (number-to-string (+ w 1)) "d" " "))) ad-do-it))
;; 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)
(setq whitespace-style '(face trailing tab-mark))
;; do not soft-wrap lines
(setq-default truncate-lines t)
(setq truncate-partial-width-windows 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)
(setq-default use-dialog-box nil)
;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;
(setq ring-bell-function 'ignore)
(add-to-list 'default-frame-alist `(font . ,my/font))
(add-to-list 'default-frame-alist `(font . ,*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,18 +1,24 @@
(provide 'core)
(defconst is-mac (eq system-type 'darwin))
(defconst is-linux (eq system-type 'gnu/linux))
;; Setup theme
(add-to-list 'custom-theme-load-path my/themes-dir)
(load-theme my/theme t)
(add-to-list 'custom-theme-load-path *themes-dir)
(load-theme *theme t)
;; Emacs under-the-hood
(prefer-coding-system 'utf-8)
(global-auto-revert-mode 1) ; revert buffers for changed files
(prefer-coding-system 'utf-8)
(setq-default load-prefer-newer t) ; load newer .el over older .elc
(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
(setq redisplay-dont-pause t)
(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no
(setq confirm-kill-emacs nil)
(setq-default enable-recursive-minibuffers nil)
;; Show keystrokes in [near] realtime
(setq echo-keystrokes 0.02)
;; Sane scroll settings
@ -28,23 +34,32 @@
initial-scratch-message nil
initial-scratch-buffer nil) ; empty scratch buffer
(setq require-final-newline nil)
(setq-default use-dialog-box nil)
(setq-default enable-recursive-minibuffers nil)
(setq-default visible-bell nil)
(setq sentence-end-double-space nil)
;;; Backups
;; If I ever enable backups/autosaves, then change where they go
(setq backup-directory-alist `((".*" . ,my/tmp-dir)))
(setq auto-save-file-name-transforms `((".*" ,my/tmp-dir t)))
(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
create-lockfiles nil)
(setq backup-directory-alist `((".*" . ,"/tmp/emacs/")))
(setq auto-save-file-name-transforms `((".*" ,"/tmp/emacs/" t)))
;; Save history across sessions
(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" "/tmp/emacs/"))
(savehist-mode 1)
;; Save cursor location across sessions
(require 'saveplace)
(setq-default save-place t)
(setq save-place-file (expand-file-name "saveplace" "/tmp/emacs/"))
;; window layout undo/redo, keymaps in core-keymaps.el
(when (fboundp 'winner-mode) (winner-mode 1))
(defconst is-mac (eq system-type 'darwin))
(defconst is-linux (eq system-type 'gnu/linux))
;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;;
;; Make next/previous-buffer skip special buffers
(defadvice next-buffer (after avoid-messages-buffer-in-next-buffer)
@ -55,16 +70,56 @@
(when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (previous-buffer)))
;;;; My personal minor mode ;;;;;;;;
(defvar my/mode-map (make-sparse-keymap))
(define-minor-mode my/mode :keymap my/mode-map :global t)
(defvar my-mode-map (make-sparse-keymap))
(define-minor-mode my-mode :global t :keymap my-mode-map)
;; 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"
(when buffer-file-name
(let ((name buffer-file-name)
(remote-id (file-remote-p buffer-file-name))
(alist auto-minor-mode-alist))
;; Remove backup-suffixes from file name.
(setq name (file-name-sans-versions name))
;; Remove remote file name identification.
(when (and (stringp remote-id)
(string-match-p (regexp-quote remote-id) name))
(setq name (substring name (match-end 0))))
(while (and alist (caar alist) (cdar alist))
(if (string-match (caar alist) name)
(funcall (cdar alist) 1))
(setq alist (cdr alist))))))
(add-hook 'find-file-hook 'enable-minor-mode-based-on-extension)
;;;; Load the rest ;;;;;;;;;;;;;;;;;;
(require 'core-packages)
(require 'shut-up)
;; (when noninteractive
;; (shut-up-silence-emacs))
;; Package management bootstrap
(setq package-enable-at-startup nil
package-archive-exclude-alist
'(("melpa" org-trello)
("melpa" org)
("marmalade" org)
("gnu" org))
delete-old-versions t)
(let ((default-directory *elisp-dir))
(normal-top-level-add-to-load-path '("."))
(normal-top-level-add-subdirs-to-load-path))
(require 'use-package)
(require 'diminish)
(require 'core-ui)
(require 'core-editor)
(if is-mac (require 'core-osx))
(add-hook 'after-init-hook (lambda() (require 'core-keymaps)))
;;
(provide 'core)
(add-hook 'after-init-hook (lambda() (require 'my-keymaps)))

View file

206
init/defuns/commands.el Normal file
View file

@ -0,0 +1,206 @@
;;;; Defun Commands ;;;;;;;;;;;;;;;;;;;;
;; 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:ido-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:ido-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-all-buffers ()
"Kill all buffers, even the one you're in"
(interactive)
(delete-other-windows)
(mapc 'kill-buffer (buffer-list))
(message "All buffers killed"))
(defun my:kill-other-buffers ()
"Kill all buffers but the one you're in"
(interactive)
(delete-other-windows)
(mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
(message "All other buffers killed"))
(defun my:kill-dired-buffers ()
(interactive)
(mapc (lambda (buffer)
(when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
(kill-buffer buffer)))
(buffer-list)))
;;;; Tmux defuns ;;;;;;;;;;;;;;;;;
(defun my:tmux-run (command)
"Run command in tmux"
(interactive
(list
(read-shell-command "Tmux command: " nil nil
(let ((filename (cond (buffer-file-name)
((eq major-mode 'dired-mode)
(dired-get-filename nil t)))))
(and filename (file-relative-name filename))))))
(shell-command (concat "/usr/local/bin/tmux send-keys C-u " (shell-quote-argument command) " Enter"))
;; (call-process "/usr/local/bin/tmux" nil nil nil "C-u" "send-keys" command "C-m")
(message "[Tmux] Command sent: %s" command))
(defun my:tmux-paste (command)
(interactive "sSend to Tmux: ")
(shell-command (concat "/usr/local/bin/tmux send-keys " (shell-quote-argument command)))
(message "[Tmux] Text pasted: %s" command))
(defun my:tmux-chdir (dir)
"CD into a new directory in tmux"
(interactive "DDirectory: ")
(my:tmux-run (concat "cd " (shell-quote-argument dir)))
(message "[Tmux] Directory changed: %s" dir))
(defun my/project-root (&optional force-pwd)
(if (and (not force-pwd)
(projectile-project-p))
(projectile-project-root)
default-directory))
;;;; Mac-specific Defuns ;;;;;;;;;
(when is-mac
;; Send current file to OSX apps
(defun open-file-with (path &optional appName)
(if (and appName
(stringp appName)
(not (string= "" appName)))
(setq appName (concat "-a " appName ".app")))
(shell-command (concat "open " appName " " (shell-quote-argument path))))
(defun open-with (appName)
(interactive "sApp name: ")
(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")))
;;;; Ex-commands ;;;;;;;;;;;;;;;;;;;;;;;
(evil-define-command my:ex:msg-buffer () :repeat nil
(interactive)
(view-echo-area-messages)
(text-mode))
(evil-define-command my:ex:kill-buffers (&optional bang) :repeat nil
(interactive "<!>")
(if bang (my:kill-all-buffers) (my:kill-other-buffers)))
(evil-define-command my: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
(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
(interactive "<a><!>")
(let ((root (my/project-root bang)))
(ag search root)))
(evil-define-command my:ex:ag-regex-search (search &optional bang) :repeat nil
(interactive "<a><!>")
(let ((root (my/project-root bang)))
(ag-regexp search root)))
(evil-define-command my:ex:tmux-chdir (&optional bang) :repeat nil
(interactive "<!>")
(if bang
(my:tmux-chdir default-directory)
(my:tmux-chdir (projectile-project-root))))
;; Run a command. If <bang>, then only type command into tmux
(evil-define-command my:ex:tmux-send (command &optional bang) :repeat nil
(interactive "<fsh><!>")
(if bang
(my:tmux-paste command)
(my:tmux-run command)))
(evil-define-operator my:ex:scratch-buffer (beg end type &optional bang)
:motion nil
:move-point nil
:type line
:repeat nil
(interactive "<R><!>")
(let ((text nil)
(mode major-mode)
(text-empty-p nil))
(when (and beg end)
(setq text (buffer-substring beg end)))
(if bang
(if text
(org-capture-string text)
(org-capture))
(progn
(switch-to-buffer (get-buffer-create "*scratch*"))
(if text (insert text))
(funcall mode)))))
(evil-define-command my:ex:byte-compile-all (&optional bang) :repeat nil
(interactive "<!>")
(byte-recompile-file (expand-file-name "init.el" *dir) bang 0)
(byte-recompile-directory *init-dir 0 bang)
(byte-recompile-directory *elisp-dir 0 bang))
(evil-define-command my:ex:mru () :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))))

46
init/defuns/config.el Normal file
View file

@ -0,0 +1,46 @@
;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;;
(defmacro λ (&rest body)
`(lambda () (interactive) ,@body))
;; vimmish keymapping shortcuts
(defmacro nmap (map &rest body)
(macroexpand `(evil-define-key 'normal ,map ,@body)))
(defmacro vmap (map &rest body)
(macroexpand `(evil-define-key 'visual ,map ,@body)))
(defmacro imap (map &rest body)
(macroexpand `(evil-define-key 'insert ,map ,@body)))
(defmacro emap (map &rest body)
(macroexpand `(evil-define-key 'emacs ,map ,@body)))
(defmacro nvmap (map &rest body)
(macroexpand-all
`(progn (nmap ,map ,@body)
(vmap ,map ,@body))))
;; insert-mode key-chord mapping
(defmacro ichmap (key command)
`(key-chord-define evil-insert-state-map ,key ,command))
(defmacro associate-mode (match mode &optional minor-mode-p)
(let ((mode-alist (if minor-mode-p 'auto-minor-mode-alist 'auto-mode-alist)))
`(add-to-list ',mode-alist '(,match . ,mode))))
;;;; Defuns ;;;;;;;;;;;;;;;;;;;;;;;;
(defun run-code-with (interpreter mode-map)
"Set up ,r (and s-r on macs) to run code using a specified
interpreter and print the output in the echo area"
(nmap mode-map (kbd ",r")
`(lambda()
(interactive)
(if (and (not (buffer-modified-p))
(file-exists-p (buffer-file-name)))
(shell-command (concat ,interpreter " " (buffer-file-name)))
(shell-command-on-region (point-min) (point-max) ,interpreter))))
(vmap mode-map (kbd ",r")
`(lambda()
(interactive)
(shell-command-on-region (region-beginning) (region-end) ,interpreter)))
(when is-mac
(nmap mode-map (kbd "s-r") ",r")
(vmap mode-map (kbd "s-r") ",r")))

10
init/defuns/hooks.el Normal file
View file

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

80
init/defuns/text.el Normal file
View file

@ -0,0 +1,80 @@
(defun my/surrounded-p ()
(and (looking-back "[[{(]\s*")
(looking-at-p "\s*[]})]"))
;; (and (s-match "[[{(]" (s-right 1 (s-trim (buffer-substring (line-beginning-position) (point)))))
;; (s-match "[])}]" (s-left 1 (s-trim (buffer-substring (point) (line-end-position))))))
)
(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 ()
(interactive)
(evil-delete (point-at-bol) (point)))
(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)))
(my.backward-kill-to-bol)
(if (not empty-line)
(indent-according-to-mode))))
;; 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. If it's at the beginning of the line, join with the previous line."
(interactive)
(if indent-tabs-mode
(call-interactively 'backward-delete-char)
(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-untabify (- (match-end 1) (match-beginning 1)))
(call-interactively 'autopair-backspace))))))
;; TODO Make inflate/deflate smarter
(defun my.inflate-space-maybe ()
(interactive)
(if (my/surrounded-p)
(progn (insert " ") (save-excursion (insert " ")))
(insert " ")))
(defun my.deflate-space-maybe ()
(interactive)
(if (my/surrounded-p)
(progn (delete-char -1) (save-excursion (delete-char 1)))
(my.backward-delete-whitespace-to-column)))
(defun my.dumb-indent ()
(interactive)
(when (not (ac-menu-live-p))
(let ((indent-mode indent-tabs-mode))
(insert (if indent-mode "\t" (make-string tab-width ? ))))))
(defun my.newline-and-indent ()
"Newline and indent; if in a comment, auto-comment and properly
indent the next line."
(interactive)
(let ((in-comment (evil-in-comment-p)))
(if in-comment
(indent-new-comment-line)
(evil-ret-and-indent))))
(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] 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)))

6
init/defuns/utility.el Normal file
View file

@ -0,0 +1,6 @@
(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))))

View file

@ -1,3 +1,10 @@
(provide 'init-ac)
(defun ac-add-files()
"Set up filepath completion sources"
(setq ac-sources (append '(ac-source-filename ac-source-files-in-current-dir) ac-sources)))
;;
(use-package auto-complete
:diminish auto-complete-mode
:init
@ -14,7 +21,7 @@
(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 'my/ac-files-setup)
(add-hook 'shell-script-mode-hook 'ac-add-files)
;; (add-hook 'auto-complete-mode-hook 'ac-common-setup)
(global-auto-complete-mode t)
@ -22,8 +29,8 @@
(ac-linum-workaround))
:config
(progn
(add-to-list 'ac-dictionary-files "~/.emacs.d/ac-dict/global")
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
(add-to-list 'ac-dictionary-files (expand-file-name "global" *ac-dicts-dir))
(add-to-list 'ac-dictionary-directories *ac-dicts-dir)
(imap ac-mode-map (kbd "C-x C-f") 'ac-complete-filename)
(imap ac-mode-map (kbd "C-SPC") 'auto-complete)
@ -33,10 +40,7 @@
(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)
(define-key ac-completing-map (kbd "RET") 'ac-complete)
;; Tell ido not to care about case
(setq completion-ignore-case t)))
;;
(provide 'init-ac)

View file

@ -1,3 +1,5 @@
(provide 'init-cpp)
(add-to-list 'auto-mode-alist '("\\.h\\'" . c++-mode))
(add-hook 'c-mode-common-hook
(lambda()
@ -23,11 +25,4 @@
:lighter " C2D"
:keymap (make-sparse-keymap))
(defun cocoa2d-mode-maybe()
(let ((root (projectile-project-root)))
(if (or (string-match "[.-]cocos2d/" root)
(file-exists-p (concat root ".cocos2d-mode")))
(cocos-mode t))))
;;
(provide 'mod-cpp)
(associate-mode "[.-]c2d/" cocoa2d-mode t)

View file

@ -1,3 +1,5 @@
(provide 'init-csharp)
;; TODO Make more Unity-friendly
(use-package omnisharp :defer t
@ -19,5 +21,3 @@
(progn
(setq csharp-want-imenu nil)
(add-hook 'csharp-mode-hook (lambda() (omnisharp-mode t) (flycheck-mode t)))))
(provide 'mod-csharp)

32
init/init-dev.el Normal file
View file

@ -0,0 +1,32 @@
(provide 'init-dev)
;;; Tools
(use-package dash-at-point
:commands (dash-at-point dash-at-point-with-docset)
: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
(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 (add-hook 'yaml-mode-hook 'enable-tab-width-2))
(use-package json-mode
:mode (("\\.json\\'" . json-mode)
("\\.jshintrc\\'" . json-mode)))

View file

@ -1,3 +1,5 @@
(provide 'init-eclim)
(use-package eclim
:commands (eclim-mode global-eclim-mode)
:init
@ -19,6 +21,3 @@
(setq help-at-pt-display-when-idle t)
(setq help-at-pt-timer-delay 0.1)
(help-at-pt-set-timer)))
;;
(provide 'mod-eclim)

View file

@ -1,3 +1,5 @@
(provide 'init-fly)
(use-package flycheck
:init (add-hook 'after-init-hook #'global-flycheck-mode)
:config
@ -5,7 +7,7 @@
;; 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))))
(setq-default flycheck-disabled-checkers '(emacs-lisp emacs-lisp-checkdoc))))
(use-package flyspell
:commands flyspell-mode
@ -13,6 +15,3 @@
:config
(setq ispell-program-name "aspell"
ispell-list-command "--list"))
;;
(provide 'init-fly)

View file

@ -1,3 +1,5 @@
(provide 'init-git)
(use-package git-commit-mode
:mode (("/COMMIT_EDITMSG\\'" . git-commit-mode)
("/NOTES_EDITMSG\\'" . git-commit-mode)
@ -22,6 +24,7 @@
(use-package git-gutter-fringe
:diminish git-gutter-mode
:disabled t
:init
(progn
(global-git-gutter-mode t)
@ -40,5 +43,11 @@
(set-face-background 'git-gutter-fr:added "#448844")
))
;;
(provide 'init-git)
(use-package git-gutter
:diminish git-gutter-mode
:init
(global-git-gutter-mode t)
:config
(progn
(custom-set-variables '(git-gutter:lighter " !"))
(custom-set-variables '(git-gutter:verbosity 0))))

35
init/init-ido.el Normal file
View file

@ -0,0 +1,35 @@
(provide 'init-ido)
;; 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)
(use-package ido-ubiquitous)
(use-package ido-vertical-mode)
(use-package flx-ido)
(ido-mode 1)
(ido-vertical-mode 1)
(ido-everywhere 1)
(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
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)

25
init/init-love.el Normal file
View file

@ -0,0 +1,25 @@
(provide 'init-love)
(use-package lua-mode
:mode "\\.lua\\'"
:interpreter "lua"
:config
(run-code-with "lua" lua-mode-map)
:init
(progn
(define-minor-mode love-mode
"Buffer local minor mode for Love2D"
:init-value nil
:lighter " <3"
:keymap (make-sparse-keymap) ; defines love-mode-map
:group lua)
;; (add-to-list 'auto-minor-mode-alist '("[.-]love/.+\\.lua\\'" . love-mode))
(associate-mode "[.-]love/.+\\.lua\\'" love-mode t)
(nmap love-mode-map (kbd "s-b") ",b")
(nmap love-mode-map (kbd ",b")
`(lambda()
(interactive)
(let ((root (if (projectile-project-p) (projectile-project-root) default-directory)))
(shell-command (concat "open -a love.app " (projectile-project-root))))))))

View file

@ -1,3 +1,5 @@
(provide 'init-org)
;; Defuns
(defun my/org-insert-list-item ()
"Force insertion of org item"
@ -43,9 +45,9 @@
(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)
(add-hook 'org-mode-hook 'enable-hard-wrap)
(load-library "ox-opml")
(shut-up (load-library "ox-opml"))
;; Formatting shortcuts
(vmap evil-org-mode-map
@ -158,17 +160,17 @@
("hard" . ?1)))
(setq org-capture-templates
'(("t" "TODO" entry (file+headline "~/Dropbox/notes/gtd.org" "Inbox") "* TODO %? %u")
("T" "TODO Someday" entry (file+headline "~/Dropbox/notes/gtd.org" "Someday") "* TODO %? %u :someday:")
("c" "Changelog" entry (file+headline (concat (projectile-project-root) "/CHANGELOG.org") "Unsorted") "** %u %? :unsorted:" :prepend t)
("i" "Invoice" entry (file+headline "~/Dropbox/notes/invoices.org" "Invoices") "** TODO %?" :prepend t)
("n" "Note" entry (file+datetree org-default-notes-file) "** %?")
("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %?")
("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\n%?\nAdded: %U")
("a" "Trivia" entry (file "~/Dropbox/notes/trivia.org") "* %u %?" :prepend t)
("s" "Writing Scraps" entry (file "~/Dropbox/notes/writing.org") "* %u %?" :prepend t)
("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %u %?" :prepend t)
("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %u %?" :prepend t)))
'(("t" "TODO" entry (file+headline "~/Dropbox/notes/gtd.org" "Inbox") "* TODO %? %u\n%i")
("T" "TODO Someday" entry (file+headline "~/Dropbox/notes/gtd.org" "Someday") "* TODO %? %u :someday:\n%i")
("c" "Changelog" entry (file+headline (concat (projectile-project-root) "/CHANGELOG.org") "Unsorted") "** %u %? :unsorted:\n%i" :prepend t)
("i" "Invoice" entry (file+headline "~/Dropbox/notes/invoices.org" "Invoices") "** TODO %?\n%i" :prepend t)
("n" "Note" entry (file+datetree org-default-notes-file) "** %?\n%i")
("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %i%?")
("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\nAdded: %U\n%i")
("a" "Trivia" entry (file "~/Dropbox/notes/trivia.org") "* %u %?\n%i" :prepend t)
("s" "Writing Scraps" entry (file "~/Dropbox/notes/writing.org") "* %u %?\n%i" :prepend t)
("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %u %?\n%i" :prepend t)
("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %u %?\n%i" :prepend t)))
(setq org-agenda-custom-commands
'(("x" agenda)
@ -180,6 +182,3 @@
("tg" tags-todo "+gamedev")
("tw" tags-tree "+webdev")))
))
;;
(provide 'mod-org)

View file

@ -1,3 +1,4 @@
(provide 'init-project)
(add-hook 'dired-load-hook
(lambda()
@ -9,13 +10,12 @@
;; current subdir, instead of the current subdir of this dired buffer
dired-dwim-target t))))
(use-package ag :defer t
:config
(define-key ag-mode-map [escape] 'kill-buffer-and-window))
(use-package helm :defer t)
(use-package grizzl :defer t)
(use-package neotree :commands (neotree-show neotree-hide neotree-toggle))
(use-package neotree
:commands
(neotree-show neotree-hide neotree-toggle))
(use-package projectile
:diminish projectile-mode
@ -24,44 +24,12 @@
(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))
(use-package ag
:commands (ag ag-search ag-regexp)
:config
(progn
(use-package ido-ubiquitous)
(use-package ido-vertical-mode)
(use-package flx-ido)
(ido-mode 1)
(ido-vertical-mode 1)
(ido-everywhere 1)
(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
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)
))
;;
(provide 'init-project)
(setq ag-reuse-window t)
(setq ag-reuse-buffers t)
(setq ag-highlight-search t)
(define-key ag-mode-map [escape] 'ag-kill-buffers)
(define-key ag-mode-map "h" nil)))

49
init/init-python.el Normal file
View file

@ -0,0 +1,49 @@
(provide 'init-python)
(use-package python
:mode ("\\.py\\'" . python-mode)
:interpreter ("python" . python-mode)
:config
(progn
(use-package pyenv
:init
(progn
(setq pyenv-show-active-python-in-modeline nil)
(global-pyenv-mode)
(add-hook 'python-mode-hook 'pyenv-use-corresponding)))
(use-package jedi
:init
(if (not (file-directory-p "~/.emacs.d/.python-environments/default/"))
(jedi:install-server))
(add-hook 'python-mode-hook 'jedi:ac-setup))
;; Let autopair work with triple-quotes
(setq autopair-handle-action-fns
(list #'autopair-default-handle-action
#'autopair-python-triple-quote-action))
;;; Keybindings
(run-code-with "python" python-mode-map)
;; (nmap python-mode-map (kbd ",r") 'python-shell-send-buffer)
;; (vmap python-mode-map (kbd ",r") 'python-shell-send-region)
;; Don't remap backspace. Leave it to autopair, please.
(define-key python-mode-map [backspace] nil)
(use-package nose :commands (nose-mode)
:config
(setq nose-mode-map (make-sparse-keymap))
(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)
:init
(associate-mode "/test_.+\\.py\\'" nose-mode)
;; (add-to-list 'auto-minor-mode-alist '("/test_.+\\.py\\'" . nose-mode)))
)))

90
init/init-ruby.el Normal file
View file

@ -0,0 +1,90 @@
(provide 'init-ruby)
(defun enable-ruby-rsense ()
(setq rsense-home "/usr/local/Cellar/rsense/0.3/libexec")
(when (file-directory-p rsense-home)
(add-to-list 'load-path (concat rsense-home "/etc"))
(require 'rsense)
(add-hook 'ruby-mode-hook 'ac-add-ruby-rsense)))
(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)
("\\.ru$" . ruby-mode)
("\\.rake$" . ruby-mode)
("\\.gemspec$" . ruby-mode)
("Gemfile$" . ruby-mode)
("Capfile$" . ruby-mode)
("Vagrantfile$" . ruby-mode)
("Rakefile$" . ruby-mode))
:interpreter "ruby"
:config
(progn
;;; Ruby tools
(use-package rbenv
:init
(progn
(setq rbenv-show-active-ruby-in-modeline nil)
(global-rbenv-mode)
(add-hook 'ruby-mode-hook 'rbenv-use-corresponding)))
(use-package inf-ruby
:config
(evil-set-initial-state 'inf-ruby-mode 'insert)
:init
(add-to-list 'ac-modes 'inf-ruby-mode))
(use-package rspec-mode
:defer t
:config
(progn
(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))
:init
(associate-mode "_spec\\.rb\\'" rspec-mode t))
;;; Auto-completion
;; Remember to install rsense w/ homebrew!
(enable-ruby-rsense)
(use-package ac-inf-ruby
:init (add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable))
;;; Formatting
(setq ruby-indent-level 2)
(setq ruby-deep-indent-paren nil)
(add-hook 'ruby-mode-hook 'enable-tab-width-2)
(require 'ruby-mode-indent-fix)
(setq evilmi-ruby-match-tags
'((("unless" "if") ("elsif" "else") ("end"))
("begin" ("rescue" "ensure") "end")
("case" ("when" "else") ("end"))
(("task" "namespace" "class" "def" "while" "do" "module" "for" "until") () ("end"))
))
(evil-define-text-object ruby-mode-string-interp-inner (count &optional beg end type)
"Select a string hash block in a string: #{|...|}"
(evil-regexp-range count beg end type "#{" "}" t))
(evil-define-text-object ruby-mode-string-interp-outer (count &optional beg end type)
"Select a string hash block in a string, including the delimiters: |#{...}|"
(evil-regexp-range count beg end type "[#$]{" "}"))
(evil-define-key 'motion ruby-mode-map "")
;;; Keybindings
(nmap ruby-mode-map "gd" 'rsense-jump-to-definition)
(run-code-with "ruby" ruby-mode-map)
))

View file

@ -1,3 +1,4 @@
(provide 'init-shell)
(setq shell-file-name "zsh")
(setq comint-process-echoes t)
@ -20,9 +21,4 @@
(local-unset-key [tab])
(evil-define-key 'normal shell-mode-map "j" nil)
(evil-define-key 'normal shell-mode-map "k" nil)
))
;;
(provide 'mod-shell)
(evil-define-key 'normal shell-mode-map "k" nil)))

View file

@ -1,3 +1,5 @@
(provide 'init-snippets)
(use-package yasnippet
:diminish (yas-minor-mode . " $")
:mode (("emacs.+/snippets/" . snippet-mode))
@ -13,12 +15,10 @@
:config
(progn
;; Only load personal snippets
(setq yas-snippet-dirs `(,my/snippets-dir))
(setq yas-snippet-dirs `(,*snippets-dir))
(setq yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
(imap yas-minor-mode-map (kbd "C-c C-s") 'yas-insert-snippet)
(define-key yas-minor-mode-map (kbd "C-c C-n") 'yas-new-snippet)
(define-key yas-minor-mode-map (kbd "C-c C-v") 'yas-visit-snippet-file)
(define-key yas-keymap (kbd "DEL") 'my/yas-clear-field)
(yas-reload-all))
:init
@ -28,5 +28,14 @@
(add-hook 'markdown-mode-hook 'yas-minor-mode)
(add-hook 'org-mode-hook 'yas-minor-mode)))
;;
(provide 'init-snippets)
(defun my/yas-clear-field (&optional field)
(interactive)
(let ((field (or field
(and yas--active-field-overlay
(overlay-buffer yas--active-field-overlay)
(overlay-get yas--active-field-overlay 'yas--field)))))
(cond ((and field
(not (yas--field-modified-p field))
(eq (point) (marker-position (yas--field-start field))))
(yas--skip-and-clear field))
(t (delete-char -1)))))

View file

@ -1,4 +1,4 @@
(add-hook 'text-mode-hook 'my/enable-hard-wrap)
(provide 'init-text)
(use-package markdown-mode
:mode (("\\.md\\'" . markdown-mode)
@ -24,9 +24,7 @@
(define-key map (kbd "s-*") 'markdown-insert-list-item)
(define-key map (kbd "s-b") 'markdown-insert-bold)
(define-key map (kbd "s-i") 'markdown-insert-italic)
(define-key map (kbd "s-`") 'markdown-insert-del)
)
))
(define-key map (kbd "s-`") 'markdown-insert-del))))
(defvar markdown-regex-del "\\(^\\|[^\\]\\)\\(\\(~\\{2\\}\\)\\([^ \n \\]\\|[^ \n ]\\(?:.\\|\n[^\n]\\)*?[^\\ ]\\)\\(\\3\\)\\)")
(defun markdown-insert-del ()
@ -47,6 +45,3 @@ insert bold delimiters and place the cursor in between them."
(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)))))
;;
(provide 'mod-text)

View file

@ -1,3 +1,5 @@
(provide 'init-webdev)
(use-package rainbow-mode
:defer t
:init (add-hook 'scss-mode 'rainbow-mode))
@ -11,14 +13,18 @@
(use-package haml-mode :mode "\\.haml\\'")
(use-package php-mode
:mode (("\\.php\\'" . php-mode)
("\\.inc\\'" . php-mode))
:interpreter "php"
;;; HTML/Markup
(use-package emmet-mode
:defer t
:config
(setq emmet-move-cursor-between-quotes t)
:init
(progn
(my/setup-run-code php-mode-map "php")
(setq php-template-compatibility nil)))
(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)
@ -30,30 +36,51 @@
(setq web-mode-ac-sources-alist
'(("css" . (ac-source-css-property))))
(setq web-mode-markup-indent-offset 4
web-mode-css-indent-offset 4
web-mode-code-indent-offset 4)
(setq 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)
;; (setq web-mode-tag-auto-close-style 0)
;; (setq web-mode-enable-auto-opening t)
;; (setq web-mode-indent-style 1)
(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)
"]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
",ct" 'web-mode-element-rename)
"zf" 'web-mode-fold-or-unfold
",ct" 'web-mode-element-rename)
(define-key web-mode-map (kbd "s-/") 'web-mode-comment-or-uncomment)
(add-hook 'web-mode-hook 'jekyll-mode-maybe)))
(add-hook 'web-mode-hook
(lambda()
(setq indent-tabs-mode t)
(setq tab-always-indent t)))
(add-hook 'web-mode-hook 'enable-tab-width-2)
))
(use-package php-mode
:mode (("\\.php\\'" . php-mode)
("\\.inc\\'" . php-mode))
:interpreter "php"
:config
(progn
(run-code-with "php" php-mode-map)
(setq php-template-compatibility nil)))
;;; Javascript
(use-package tern
:commands tern-mode
:config
(progn
(my/setup-run-code js-mode-map "node")
(run-code-with "node" js-mode-map)
(use-package tern-auto-complete
:config (setq tern-ac-on-dot nil)))
:init
@ -62,19 +89,8 @@
(lambda ()
(tern-mode t)
(tern-ac-setup)
(imap js-mode-map (kbd "C-SPC") 'tern-ac-complete
))))
(use-package emmet-mode
: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 'haml-mode-hook 'emmet-mode)
(add-hook 'nxml-mode-hook 'emmet-mode)))
(imap js-mode-map [remap auto-complete] 'tern-ac-complete)
)))
;; Jekyll support
(define-minor-mode jekyll-mode
@ -82,18 +98,4 @@
:lighter " :{"
:keymap (make-sparse-keymap))
(defun jekyll-mode-maybe()
(let ((root (projectile-project-root)))
(if (or (string-match "[.-]jekyll/" root)
(file-exists-p (concat root ".jekyll-mode")))
(jekyll-mode t))))
(nmap jekyll-mode-map (kbd ",b")
(λ (open-file-with "http://localhost:4000")))
(add-hook 'scss-mode-hook 'jekyll-mode-maybe)
(add-hook 'web-mode-hook 'jekyll-mode-maybe)
(add-hook 'markdown-mode-hook 'jekyll-mode-maybe)
;;
(provide 'mod-webdev)
(associate-mode "[.-]jekyll/" jekyll-mode t)

View file

@ -1,88 +0,0 @@
(add-hook 'prog-mode-hook 'my/enable-comment-hard-wrap)
(add-to-list 'auto-mode-alist '("\\.plist\\'" . nxml-mode))
(use-package dash-at-point
:commands (dash-at-point dash-at-point-with-docset)
: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 . "py2"))))
(use-package yaml-mode
:defer t
:config
(defun my/setup-yaml-mode () (setq tab-width 2))
(add-hook 'yaml-mode-hook 'my/setup-yaml-mode))
(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)
(my/setup-run-code python-mode-map "python"))
:init
(add-hook 'python-mode-hook 'jedi:ac-setup))
(use-package ruby-mode
:mode (("\\.rb\\'" . ruby-mode)
("\\.rake\\'" . ruby-mode)
("Rakefile\\'" . ruby-mode))
:interpreter "ruby"
:config
(progn
(setq ruby-indent-level 2)
(setq ruby-deep-indent-paren nil)
(require 'ruby-mode-indent-fix)
;; Remember to install rsense w/ homebrew!
(setq rsense-home "/usr/local/Cellar/rsense/0.3/libexec")
(when (file-directory-p rsense-home)
(add-to-list 'load-path (concat rsense-home "/etc"))
(require 'rsense)
(add-hook 'ruby-mode-hook 'my/ac-ruby-setup))
(use-package rbenv)
(use-package inf-ruby
:config (evil-set-initial-state 'inf-ruby-mode 'insert)
: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))
(setq evilmi-ruby-match-tags
'((("unless" "if") ("elsif" "else") ("end"))
("begin" ("rescue" "ensure") "end")
("case" ("when" "else") ("end"))
(("task" "namespace" "class" "def" "while" "do" "module" "for" "until") () ("end"))
))
(my/setup-run-code ruby-mode-map "ruby")
(nmap ruby-mode-map "gd" 'rsense-jump-to-definition))
:init
(add-hook 'ruby-mode-hook (lambda() (setq tab-width 2))))
(use-package go-mode
:mode "\\.go\\'"
:interpreter "go"
:init
(require 'go-autocomplete))
;;
(provide 'mod-dev)

View file

@ -1,27 +0,0 @@
(use-package lua-mode
:mode "\\.lua\\'"
:interpreter "lua"
:config
(my/setup-run-code lua-mode-map "lua")
:init
(progn
(define-minor-mode love-mode
"Buffer local minor mode for Love2D"
:init-value nil
:lighter " <3"
:keymap (make-sparse-keymap) ; defines love-mode-map
:group lua)
(nmap love-mode-map (kbd ",b")
(λ (shell-command (concat "open -a love.app " (projectile-project-root)))))
(add-hook 'lua-mode-hook 'love-mode-maybe)))
(defun love-mode-maybe()
(let ((root (projectile-project-root)))
(if (or (string-match "[.-]love/" root)
(file-exists-p (concat root ".love-mode")))
(love-mode t))))
;;
(provide 'mod-love)

View file

@ -1,199 +1,10 @@
;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;;
(defmacro λ (&rest body)
`(lambda () (interactive) ,@body))
;; 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))
(defmacro nvmap (map &rest body)
`(progn (evil-define-key 'normal ,map ,@body)
(evil-define-key 'visual ,map ,@body)))
;; insert-mode key-chord mapping
(defmacro ichmap (key command)
`(key-chord-define evil-insert-state-map ,key ,command))
;;;; Commands ;;;;;;;;;;;;;;;;;;;;;;
;; File navigation defuns
(defun my/initfiles ()
"Do an ido-find in ~/.emacs.d"
(interactive)
(ido-find-file-in-dir my/dir))
(defun my/open-scratch ()
"Open a blank scratch buffer"
(interactive)
(switch-to-buffer (get-buffer-create "*scratch*"))
(text-mode))
(defun my/byte-recompile ()
"Byte compile init.el, ~/.emacs.d/init/* and ~/.emacs.d/elisp/*"
(interactive)
(byte-recompile-file (expand-file-name "init.el" my/dir) t)
(byte-recompile-directory my/init-dir 0 t)
(byte-recompile-directory my/elisp-dir 0 t))
(defun my/notes()
"Load up my notes folder in dropbox"
(interactive)
(ido-find-file-in-dir "~/Dropbox/notes"))
(defun my/kill-all-buffers ()
"Kill all buffers, even the one you're in"
(interactive)
(delete-other-windows)
(mapc 'kill-buffer (buffer-list))
(message "All buffers killed"))
(defun my/kill-other-buffers ()
"Kill all buffers but the one you're in"
(interactive)
(delete-other-windows)
(mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
(message "All other buffers killed"))
(defun my/kill-dired-buffers ()
(interactive)
(mapc (lambda (buffer)
(when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
(kill-buffer buffer)))
(buffer-list)))
(defun my/recentf-ido-find-file ()
"Find a recent file using ido."
(interactive)
(let ((file (ido-completing-read "Choose recent file: " recentf-list nil t)))
(when file
(find-file file))))
(defun my/ido-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/ido-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/ido-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))))))))
;;;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;
(defun my/enable-hard-wrap()
(auto-fill-mode 1)
(diminish 'auto-fill-function))
(defun my/enable-comment-hard-wrap ()
(set (make-local-variable 'comment-auto-fill-only-comments) t)
(auto-fill-mode 1)
(diminish 'auto-fill-function))
(defun my/ac-ruby-setup()
"Set up RSense and ac-sources"
(setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources)))
(defun my/ac-files-setup()
"Set up filepath completion sources"
(setq ac-sources (append '(ac-source-filename ac-source-files-in-current-dir) ac-sources)))
(defun my/setup-run-code(mode interpreter)
"Set up s-r to run code using a specified interpreter and print the
output in the echo area"
(nmap mode (kbd ",r")
`(lambda()
(interactive)
(if (file-exists-p (buffer-file-name))
(shell-command (concat ,interpreter " " (buffer-file-name)))
(shell-command-on-region (point-min) (point-max) ,interpreter))))
(vmap mode (kbd ",r")
`(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) ,interpreter))))
;;;; Tmux defuns ;;;;;;;;;;;;;;;;;
(defun my/tmux-run (command)
"Run command in tmux"
(interactive
(list
(read-shell-command "Tmux command: " nil nil
(let ((filename (cond (buffer-file-name)
((eq major-mode 'dired-mode)
(dired-get-filename nil t)))))
(and filename (file-relative-name filename))))))
(shell-command (concat "/usr/local/bin/tmux send-keys C-u " (shell-quote-argument command) " Enter"))
;; (call-process "/usr/local/bin/tmux" nil nil nil "C-u" "send-keys" command "C-m")
(message "Tmux: Command sent!"))
(defun my/tmux-paste (command)
(interactive "sSend to Tmux: ")
(shell-command (concat "/usr/local/bin/tmux send-keys " command))
(message "Tmux: Text pasted!"))
(defun my/tmux-chdir(dir)
"CD into a new directory in tmux"
(interactive "DDirectory: ")
(my/tmux-run (concat "cd " (shell-quote-argument dir)))
(message "Tmux: Directory changed!"))
;;;; Mac-specific Defuns ;;;;;;;;;
(when is-mac
;; Send current file to OSX apps
(defun open-file-with (path &optional appName)
(if (and appName
(stringp appName)
(not (string= "" appName)))
(setq appName (concat "-a " appName ".app")))
(shell-command (concat "open " appName " " (shell-quote-argument path))))
(defun open-with (appName)
(interactive "sApp name: ")
(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")))
;;
(provide 'my-defuns)
(add-to-list 'load-path (expand-file-name "defuns" *init-dir))
(shut-up
(load "defuns/config")
(load "defuns/commands")
(load "defuns/text")
(load "defuns/hooks")
(load "defuns/utility"))

270
init/my-keymaps.el Normal file
View file

@ -0,0 +1,270 @@
(provide 'my-keymaps)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Global keymaps ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global-set-key (kbd "C-c C-p") 'package-list-packages)
(global-set-key (kbd "M-x") 'smex)
(global-set-key (kbd "M-X") 'smex-major-mode-commands)
(when is-mac
;; TODO: Open in tmux
(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
(kbd "C-c t") 'my:tmux-chdir
(kbd "C-c T") (λ (my:tmux-chdir (projectile-project-root))))
;; Evaluating elisp
(nmap my-mode-map (kbd "C-c x") 'eval-buffer)
(vmap my-mode-map (kbd "C-c x") 'eval-region)
(when window-system
(global-set-key (kbd "s-=") 'text-scale-increase)
(global-set-key (kbd "s--") 'text-scale-decrease)
(global-set-key (kbd "s-w") 'evil-window-delete)
(global-set-key (kbd "s-/") 'evilnc-comment-or-uncomment-lines)
(global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
(global-set-key (kbd "C-;") 'eval-expression)
(global-set-key (kbd "s-;") 'my:tmux-run)
(global-set-key (kbd "s-:") 'my:tmux-paste)
;; Faster scrolling
(mapc (lambda(map)
(evil-define-key map my-mode-map (kbd "s-j") "5j")
(evil-define-key map my-mode-map (kbd "s-k") "5k"))
'(emacs normal visual))
(nmap my-mode-map
;; Leader alternatives
(kbd "s-t") 'projectile-find-file
(kbd "s-F") 'projectile-ag
(kbd "s-p") 'projectile-switch-project
(kbd "s-m") 'my:ex:mru
(kbd "s-M") 'projectile-recentf
(kbd "s-o") 'ido-find-file
(kbd "s-d") 'dash-at-point
(kbd "s-'") 'mc/mark-next-like-this
(kbd "s-\"") 'mc/mark-previous-like-this
(kbd "C-s-'") 'mc/mark-all-like-this)
(imap my-mode-map
;; Textmate-esque insert-line before/after
(kbd "<s-return>") 'evil-open-below
(kbd "<S-s-return>") 'evil-open-above
;; Fix OSX text navigation shortcuts
(kbd "<s-left>") 'evil-first-non-blank
(kbd "<s-right>") 'move-end-of-line
(kbd "<s-backspace>") 'my.backward-kill-to-bol-and-indent
;; Fixes delete
(kbd "<kp-delete>") 'delete-char)
(imap emmet-mode-keymap
(kbd "s-e") 'emmet-expand-yas
(kbd "s-E") 'emmet-expand-line)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Local keymaps ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use
;; define-key instead of n/vmap for this one to register.
(define-key evil-normal-state-map ";" 'evil-ex)
(define-key evil-visual-state-map ";" 'evil-ex)
(nvmap my-mode-map
"gc" 'evil-ace-jump-char-mode
"gw" 'evil-ace-jump-word-mode ; overwrites evil-fill
"gl" 'evil-ace-jump-line-mode)
(nmap my-mode-map
;; Leader maps
",'" 'mc/mark-next-like-this
",\"" 'mc/mark-all-like-this
",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
",\\" 'neotree-show
",|" 'neotree-hide
",;" 'helm-imenu
",:" 'my:ido-goto-symbol
",," 'ido-switch-buffer
",." 'projectile-find-file
",=" 'align-regexp
;; Moving rows rather than lines (in case of wrapping)
"j" 'evil-next-visual-line
"k" 'evil-previous-visual-line
"X" 'evil-destroy ; Delete without yanking
;; behave like D and C; yank to end of line
"Y" (λ (evil-yank (point) (point-at-eol)))
"zz" 'kill-this-buffer ; Close buffer
"]b" 'next-buffer
"[b" 'previous-buffer
"]e" 'next-error
"[e" 'previous-error
"]h" 'git-gutter:next-hunk
"[h" 'git-gutter:previous-hunk
;; For quickly capturing notes and todos
(kbd ", RET") 'org-capture
;; winner-mode: window layout undo/redo (see init-core.el)
(kbd "C-w u") 'winner-undo
(kbd "C-w C-r") 'winner-redo
;; Increment/decrement number under cursor
(kbd "C--") 'evil-numbers/inc-at-pt
(kbd "C-+") 'evil-numbers/dec-at-pt)
(vmap my-mode-map
;; vnoremap < <gv
"<" (λ (evil-shift-left (region-beginning) (region-end))
(evil-normal-state)
(evil-visual-restore))
;; vnoremap > >gv
">" (λ (evil-shift-right (region-beginning) (region-end))
(evil-normal-state)
(evil-visual-restore))
"+" 'er/expand-region
"_" 'er/contract-region)
(imap my-mode-map
;; Join lines from insert mode
(kbd "<M-kp-delete>") 'evil-join
;; Newline magic
(kbd "<return>") 'my.newline-and-indent
(kbd "<C-return>") 'evil-ret-and-indent
(kbd "<M-return>") (kbd "<return> DEL") ; newline and dedent
;; Textmate-esque indent shift left/right
(kbd "s-[") (kbd "C-o m l C-o I DEL C-o ` l")
(kbd "s-]") (λ (evil-shift-right (point-at-bol) (point-at-eol)))
(kbd "<backtab>") (kbd "s-["))
(emap my-mode-map
;; Preserve buffer-movement in emacs mode
"j" 'evil-next-line
"k" 'evil-previous-line
";" 'linum-mode
"o" 'send-dir-to-finder
"u" 'send-to-transmit
"l" 'send-to-launchbar
"L" 'send-dir-to-launchbar
"t" 'my:tmux-chdir
"T" (λ (my:tmux-chdir (projectile-project-root)))
(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)
;; Rotate-text (see elisp/rotate-text.el)
(nmap my-mode-map "!" 'rotate-word-at-point)
(vmap my-mode-map "!" 'rotate-region)
;; Easy escape from insert mode
(ichmap "jj" 'evil-normal-state)
;; Enable TAB to do matchit
(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
;; Real go-to-definition for elisp
(nmap emacs-lisp-mode-map "gd"
(λ (let ((func (function-called-at-point)))
(if func (find-function func)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Ex Commands ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(evil-ex-define-cmd "msg" 'my:ex:msg-buffer)
(evil-ex-define-cmd "recompile" 'my:ex:byte-compile-all)
(evil-ex-define-cmd "n[otes]" 'my:ex:notes)
(evil-ex-define-cmd "ini" 'my:ex:init-files)
(evil-ex-define-cmd "snip[pets]" 'my:ex:snippets)
(evil-ex-define-cmd "mru" 'my:ex:mru)
(evil-ex-define-cmd "retab" 'untabify) ; TODO: Implement proper retab defun
(evil-ex-define-cmd "ag" 'my:ex:ag-search)
(evil-ex-define-cmd "agr" 'my:ex:ag-regex-search)
(evil-ex-define-cmd "x" 'my:ex:scratch-buffer)
(evil-ex-define-cmd "bx" 'my:ex:kill-buffers)
(evil-ex-define-cmd "tcd" 'my:ex:tmux-chdir)
(evil-ex-define-cmd "tmux" 'my:ex:tmux-send)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Keymap fixes ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Restores "dumb" indentation to the tab key. This rustles a lot of
;; peoples' jimmies, apparently, but it's how I like it.
(imap my-mode-map (kbd "<tab>") 'my.dumb-indent)
;; Except for lisp
(imap lisp-mode-map (kbd "<tab>") 'indent-for-tab-command)
(imap emacs-lisp-mode-map (kbd "<tab>") 'indent-for-tab-command)
;; Highjacks the backspace and space to:
;; a) expand spaces between delimiters intelligently: (|) -> ( | )
;; b) the reverse of A: ( | ) -> (|)
;; c) And allow backspace to delete indentation blocks intelligently
(define-key evil-insert-state-map
[remap autopair-backspace] 'my.deflate-space-maybe)
(define-key evil-insert-state-map
(kbd "SPC") 'my.inflate-space-maybe)
;; Make ESC quit all the things
(mapc (lambda (map)
(define-key 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))
(define-key evil-emacs-state-map [escape] 'evil-exit-emacs-state)
;; Close help/compilation windows with escape
(define-key help-mode-map [escape] 'kill-buffer-and-window)
(define-key compilation-mode-map [escape] 'kill-buffer-and-window)
;; Restore bash-esque keymaps in insert mode
(imap my-mode-map
(kbd "C-a") 'evil-move-beginning-of-line
(kbd "C-e") 'evil-move-end-of-line
(kbd "C-u") 'my.backward-kill-to-bol-and-indent)
;; And the minibuffer
(mapc (lambda (map)
(define-key map (kbd "C-a") 'move-beginning-of-line)
(define-key map (kbd "C-e") 'move-end-of-line)
(define-key map (kbd "C-u") 'my.backward-kill-to-bol))
(list minibuffer-local-map minibuffer-local-ns-map))
(define-key evil-insert-state-map (kbd "C-w") 'backward-kill-word)
(define-key minibuffer-local-map (kbd "C-w") 'ido-delete-backward-word-updir)
(add-hook 'ido-setup-hook '(lambda ()
;; take that "Text is read-only" and stick it where emacs don't shine!
(define-key ido-completion-map (kbd "<backspace>") 'ido-delete-backward-updir)
(define-key ido-completion-map "\C-n" 'ido-next-match)
(define-key ido-completion-map "\C-p" 'ido-prev-match)
;; Auto-complete on tab/space (why is it called ido-exit-minibuffer?)
(define-key ido-completion-map " " 'ido-exit-minibuffer)))