From f2e2f05742abca5c375a91c1db7916589d1d4273 Mon Sep 17 00:00:00 2001 From: Henrik Lissner Date: Fri, 5 Sep 2014 17:08:40 -0400 Subject: [PATCH] Refactor initfiles --- init.el | 48 +++-- init/core-editor.el | 112 ++++------ init/core-keymaps.el | 248 ----------------------- init/core-osx.el | 4 +- init/core-packages.el | 23 --- init/core-ui.el | 31 ++- init/core.el | 107 +++++++--- init/defuns/coderunner.el | 0 init/defuns/commands.el | 206 +++++++++++++++++++ init/defuns/config.el | 46 +++++ init/defuns/hooks.el | 10 + init/defuns/text.el | 80 ++++++++ init/defuns/utility.el | 6 + init/init-ac.el | 18 +- init/{mod-cpp.el => init-cpp.el} | 11 +- init/{mod-csharp.el => init-csharp.el} | 4 +- init/init-dev.el | 32 +++ init/{mod-eclim.el => init-eclim.el} | 5 +- init/init-fly.el | 7 +- init/init-git.el | 13 +- init/init-ido.el | 35 ++++ init/init-love.el | 25 +++ init/{mod-org.el => init-org.el} | 31 ++- init/init-project.el | 56 ++--- init/init-python.el | 49 +++++ init/init-ruby.el | 90 +++++++++ init/{mod-shell.el => init-shell.el} | 8 +- init/init-snippets.el | 21 +- init/{mod-text.el => init-text.el} | 9 +- init/{mod-webdev.el => init-webdev.el} | 94 ++++----- init/mod-dev.el | 88 -------- init/mod-love.el | 27 --- init/my-defuns.el | 207 +------------------ init/my-keymaps.el | 270 +++++++++++++++++++++++++ 34 files changed, 1161 insertions(+), 860 deletions(-) delete mode 100644 init/core-keymaps.el delete mode 100644 init/core-packages.el create mode 100644 init/defuns/coderunner.el create mode 100644 init/defuns/commands.el create mode 100644 init/defuns/config.el create mode 100644 init/defuns/hooks.el create mode 100644 init/defuns/text.el create mode 100644 init/defuns/utility.el rename init/{mod-cpp.el => init-cpp.el} (75%) rename init/{mod-csharp.el => init-csharp.el} (96%) create mode 100644 init/init-dev.el rename init/{mod-eclim.el => init-eclim.el} (96%) create mode 100644 init/init-ido.el create mode 100644 init/init-love.el rename init/{mod-org.el => init-org.el} (93%) create mode 100644 init/init-python.el create mode 100644 init/init-ruby.el rename init/{mod-shell.el => init-shell.el} (88%) rename init/{mod-text.el => init-text.el} (92%) rename init/{mod-webdev.el => init-webdev.el} (58%) delete mode 100644 init/mod-dev.el delete mode 100644 init/mod-love.el create mode 100644 init/my-keymaps.el diff --git a/init.el b/init.el index 8e7f14599..1aff957cc 100644 --- a/init.el +++ b/init.el @@ -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 )) diff --git a/init/core-editor.el b/init/core-editor.el index 1d3f371dc..1484883a8 100644 --- a/init/core-editor.el +++ b/init/core-editor.el @@ -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\\'")))) diff --git a/init/core-keymaps.el b/init/core-keymaps.el deleted file mode 100644 index b74be9f85..000000000 --- a/init/core-keymaps.el +++ /dev/null @@ -1,248 +0,0 @@ -;; Global keymaps ;;;;;;;;;;;;;;; -(global-set-key (kbd "") '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-") '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 "") 'evil-open-below - (kbd "") 'evil-open-above - - ;; Fix OSX text navigation shortcuts - (kbd "") 'move-beginning-of-line - (kbd "") 'move-end-of-line - (kbd "") 'backward-kill-line - - ;; Fixes delete - (kbd "") '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-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 "") 'evil-join - - ;; Newline magic - (kbd "RET") 'newline-and-indent - (kbd "M-RET") (kbd "RET DEL") - (kbd "") '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 "") (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 "") '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) diff --git a/init/core-osx.el b/init/core-osx.el index 21b551b47..414c7f714 100644 --- a/init/core-osx.el +++ b/init/core-osx.el @@ -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) diff --git a/init/core-packages.el b/init/core-packages.el deleted file mode 100644 index e9259cbf2..000000000 --- a/init/core-packages.el +++ /dev/null @@ -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) diff --git a/init/core-ui.el b/init/core-ui.el index 13a35fcf5..48682f9ec 100644 --- a/init/core-ui.el +++ b/init/core-ui.el @@ -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) diff --git a/init/core.el b/init/core.el index f074a9cb9..725eeb07b 100644 --- a/init/core.el +++ b/init/core.el @@ -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))) diff --git a/init/defuns/coderunner.el b/init/defuns/coderunner.el new file mode 100644 index 000000000..e69de29bb diff --git a/init/defuns/commands.el b/init/defuns/commands.el new file mode 100644 index 000000000..68aeffca3 --- /dev/null +++ b/init/defuns/commands.el @@ -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 "") + (let ((root (my/project-root bang))) + (ag search root))) + +(evil-define-command my:ex:ag-regex-search (search &optional bang) :repeat nil + (interactive "") + (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 , then only type command into tmux +(evil-define-command my:ex:tmux-send (command &optional bang) :repeat nil + (interactive "") + (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 "") + (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)))) diff --git a/init/defuns/config.el b/init/defuns/config.el new file mode 100644 index 000000000..dad1953c0 --- /dev/null +++ b/init/defuns/config.el @@ -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"))) diff --git a/init/defuns/hooks.el b/init/defuns/hooks.el new file mode 100644 index 000000000..b23468a2b --- /dev/null +++ b/init/defuns/hooks.el @@ -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)) diff --git a/init/defuns/text.el b/init/defuns/text.el new file mode 100644 index 000000000..584c793cc --- /dev/null +++ b/init/defuns/text.el @@ -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))) diff --git a/init/defuns/utility.el b/init/defuns/utility.el new file mode 100644 index 000000000..3e1ed2302 --- /dev/null +++ b/init/defuns/utility.el @@ -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)))) diff --git a/init/init-ac.el b/init/init-ac.el index 28033dabd..6e21e4329 100644 --- a/init/init-ac.el +++ b/init/init-ac.el @@ -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 "") '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) diff --git a/init/mod-cpp.el b/init/init-cpp.el similarity index 75% rename from init/mod-cpp.el rename to init/init-cpp.el index 4ea3c7bbc..04341c2c7 100644 --- a/init/mod-cpp.el +++ b/init/init-cpp.el @@ -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) diff --git a/init/mod-csharp.el b/init/init-csharp.el similarity index 96% rename from init/mod-csharp.el rename to init/init-csharp.el index 2e2cb91c9..db8cdf068 100644 --- a/init/mod-csharp.el +++ b/init/init-csharp.el @@ -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) diff --git a/init/init-dev.el b/init/init-dev.el new file mode 100644 index 000000000..2827fcd1f --- /dev/null +++ b/init/init-dev.el @@ -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))) diff --git a/init/mod-eclim.el b/init/init-eclim.el similarity index 96% rename from init/mod-eclim.el rename to init/init-eclim.el index 021cd278a..7afe025c6 100644 --- a/init/mod-eclim.el +++ b/init/init-eclim.el @@ -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) diff --git a/init/init-fly.el b/init/init-fly.el index ba5a0a555..c652fc332 100644 --- a/init/init-fly.el +++ b/init/init-fly.el @@ -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) diff --git a/init/init-git.el b/init/init-git.el index 3d00f7069..321fc9fa8 100644 --- a/init/init-git.el +++ b/init/init-git.el @@ -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)))) diff --git a/init/init-ido.el b/init/init-ido.el new file mode 100644 index 000000000..13c0daa36 --- /dev/null +++ b/init/init-ido.el @@ -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) diff --git a/init/init-love.el b/init/init-love.el new file mode 100644 index 000000000..8493c38c6 --- /dev/null +++ b/init/init-love.el @@ -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)))))))) diff --git a/init/mod-org.el b/init/init-org.el similarity index 93% rename from init/mod-org.el rename to init/init-org.el index 09bc32ddd..591461965 100644 --- a/init/mod-org.el +++ b/init/init-org.el @@ -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) diff --git a/init/init-project.el b/init/init-project.el index a5ae7d9ab..0d627ed47 100644 --- a/init/init-project.el +++ b/init/init-project.el @@ -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))) diff --git a/init/init-python.el b/init/init-python.el new file mode 100644 index 000000000..fa72660fb --- /dev/null +++ b/init/init-python.el @@ -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))) + ))) diff --git a/init/init-ruby.el b/init/init-ruby.el new file mode 100644 index 000000000..6955f5387 --- /dev/null +++ b/init/init-ruby.el @@ -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) + )) diff --git a/init/mod-shell.el b/init/init-shell.el similarity index 88% rename from init/mod-shell.el rename to init/init-shell.el index d1e0f4438..2de6627b2 100644 --- a/init/mod-shell.el +++ b/init/init-shell.el @@ -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))) diff --git a/init/init-snippets.el b/init/init-snippets.el index 39b326f1d..2669f1866 100644 --- a/init/init-snippets.el +++ b/init/init-snippets.el @@ -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))))) diff --git a/init/mod-text.el b/init/init-text.el similarity index 92% rename from init/mod-text.el rename to init/init-text.el index 6244c3f47..08e6a41e3 100644 --- a/init/mod-text.el +++ b/init/init-text.el @@ -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) diff --git a/init/mod-webdev.el b/init/init-webdev.el similarity index 58% rename from init/mod-webdev.el rename to init/init-webdev.el index 884e00c41..50128c459 100644 --- a/init/mod-webdev.el +++ b/init/init-webdev.el @@ -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) diff --git a/init/mod-dev.el b/init/mod-dev.el deleted file mode 100644 index 948c660b4..000000000 --- a/init/mod-dev.el +++ /dev/null @@ -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) diff --git a/init/mod-love.el b/init/mod-love.el deleted file mode 100644 index 4bd378a21..000000000 --- a/init/mod-love.el +++ /dev/null @@ -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) diff --git a/init/my-defuns.el b/init/my-defuns.el index bca44012d..fa3dd71b7 100644 --- a/init/my-defuns.el +++ b/init/my-defuns.el @@ -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")) diff --git a/init/my-keymaps.el b/init/my-keymaps.el new file mode 100644 index 000000000..ff5a6ba13 --- /dev/null +++ b/init/my-keymaps.el @@ -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-") '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 "") 'evil-open-below + (kbd "") 'evil-open-above + + ;; Fix OSX text navigation shortcuts + (kbd "") 'evil-first-non-blank + (kbd "") 'move-end-of-line + (kbd "") 'my.backward-kill-to-bol-and-indent + + ;; Fixes delete + (kbd "") '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-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 "") 'evil-join + + ;; Newline magic + (kbd "") 'my.newline-and-indent + (kbd "") 'evil-ret-and-indent + (kbd "") (kbd " 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 "") (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 "") 'my.dumb-indent) +;; Except for lisp +(imap lisp-mode-map (kbd "") 'indent-for-tab-command) +(imap emacs-lisp-mode-map (kbd "") '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 "") '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)))