diff --git a/Cask b/Cask index d80b5f673..860c92ec6 100644 --- a/Cask +++ b/Cask @@ -10,30 +10,42 @@ (depends-on "f") (depends-on "deferred") (depends-on "exec-path-from-shell") +(depends-on "fuzzy") (depends-on "use-package") +(depends-on "smex") +(depends-on "auto-async-byte-compile") ;; Editing +(depends-on "smooth-scrolling") (depends-on "smart-mode-line") (depends-on "shut-up") (depends-on "dired+") (depends-on "expand-region") (depends-on "flycheck") (depends-on "flyspell") -(depends-on "multiple-cursors") (depends-on "rainbow-delimiters") (depends-on "smartparens") (depends-on "anzu") (depends-on "key-chord") -(depends-on "saveplace") (depends-on "yasnippet") -(depends-on "git-gutter") +(depends-on "git-gutter-fringe+") (depends-on "popwin") (depends-on "dash-at-point") (depends-on "auto-complete") (depends-on "auto-complete-clang") (depends-on "auto-complete-c-headers") -(depends-on "ace-jump-mode") (depends-on "ac-etags") +(depends-on "xcscope") +(depends-on "ac-ispell") +(depends-on "ace-jump-mode") +(depends-on "ace-window") +(depends-on "smart-forward") +(depends-on "regex-tool") +(depends-on "perspective") +(depends-on "persp-projectile") +;;(depends-on "multiple-cursors") +;;(depends-on "git-gutter") +;;(depends-on "saveplace") ;; Eeeevil (depends-on "evil") @@ -43,54 +55,64 @@ (depends-on "evil-exchange") (depends-on "evil-space") (depends-on "evil-visualstar") -;; evil-nerd-commenter chokes if it's installed via cask for some reason... -;;(depends-on "evil-nerd-commenter") (depends-on "evil-indent-textobject") (depends-on "evil-jumper") (depends-on "evil-god-state") (depends-on "god-mode") +;; evil-nerd-commenter chokes if it's installed via cask for some reason... +;;(depends-on "evil-nerd-commenter") ;; Project management +(depends-on "ag") (depends-on "projectile") (depends-on "helm") -(depends-on "smex") -(depends-on "ag") -(depends-on "grizzl") +(depends-on "helm-ag") +(depends-on "helm-css-scss") +(depends-on "helm-projectile") (depends-on "neotree") (depends-on "ido-ubiquitous") (depends-on "ido-vertical-mode") (depends-on "flx-ido") +;;(depends-on "grizzl") ;; Modes/mode-specific (depends-on "org-plus-contrib") (depends-on "org-opml" :git "https://github.com/edavis/org-opml") (depends-on "rainbow-mode") -(depends-on "web-mode") (depends-on "lua-mode") (depends-on "php-mode") -(depends-on "emmet-mode") (depends-on "haml-mode") (depends-on "scss-mode") +(depends-on "sass-mode") (depends-on "sws-mode") (depends-on "json-mode") (depends-on "yaml-mode") (depends-on "markdown-mode") (depends-on "glsl-mode") -(depends-on "haxe-mode") -(depends-on "go-mode" :git "https://github.com/dominikh/go-mode.el") +(depends-on "groovy-mode") +(depends-on "swift-mode") +;; (depends-on "haxe-mode") +;; (depends-on "go-mode" :git "https://github.com/dominikh/go-mode.el") +(depends-on "web-mode") +(depends-on "emmet-mode") +(depends-on "web-beautify") + +(depends-on "js2-mode") +(depends-on "js2-refactor") (depends-on "tern") (depends-on "tern-auto-complete") (depends-on "rspec-mode") (depends-on "inf-ruby") -(depends-on "ac-inf-ruby") +;;(depends-on "ac-inf-ruby") +(depends-on "robe") (depends-on "jedi") ;;(depends-on "omnisharp") -(depends-on "csharp-mode") +;;(depends-on "csharp-mode") (depends-on "emacs-eclim") (depends-on "git-commit-mode") diff --git a/cleanup.sh b/cleanup.sh index 0aa36d61b..0a9e3803b 100755 --- a/cleanup.sh +++ b/cleanup.sh @@ -1,3 +1,3 @@ #!/usr/bin/env bash -rm -f init.elc init/*.elc init/defuns/*.elc elisp/*.elc &> /dev/null +rm -f init.elc init/*.elc elisp/*.elc &> /dev/null diff --git a/elisp/hl-todo.el b/elisp/hl-todo.el new file mode 100644 index 000000000..4493f5d6a --- /dev/null +++ b/elisp/hl-todo.el @@ -0,0 +1,117 @@ +;;; hl-todo.el --- highlight TODO keywords + +;; Copyright (C) 2013-2014 Jonas Bernoulli + +;; Author: Jonas Bernoulli +;; Created: 20130310 +;; Homepage: http://github.com/tarsius/hl-todo +;; Keywords: convenience + +;; This file is not part of GNU Emacs. + +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. + +;; This file is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; For a full copy of the GNU General Public License +;; see . + +;;; Commentary: + +;; Hightlight TODO keywords. There are many minor modes like it +;; but this one is mine. It also happens to be simpler than the +;; alternatives. + +;; For now at least -- I might extend it. Or I might abandon it +;; in favor of one of the following -- so you might be better of +;; going straight for one of these: + +;; - [[http://emacswiki.org/fic-ext-mode.el][fic-ext-mode]] +;; - [[https://github.com/lewang/fic-mode][fic-mode]] +;; - [[http://emacswiki.org/FixmeMode][fixme-mode]] +;; - [[https://github.com/rolandwalker/fixmee][fixmee]] +;; - see http://emacswiki.org/FixmeMode for more alternatives + +;; If you like this you might also like [[https://github.com/tarsius/orglink][orglink]]. + +;;; Code: + +(defgroup hl-todo nil + "Highlight TODO keywords in comments." + :group 'font-lock-extra-types) + +(defface hl-todo + '((t (:bold t :foreground "#cc9393"))) + "Face used to highlight TODO keywords." + :group 'hl-todo) + +(defcustom hl-todo-activate-in-modes '(emacs-lisp-mode) + "Major modes in which `hl-todo-mode' should be activated. +This is used by `global-hl-todo-mode'." + :group 'hl-todo + :type '(repeat function)) + +(defvar hl-todo-keywords nil) + +(defcustom hl-todo-keyword-faces + '(("HOLD" . "#d0bf8f") + ("TODO" . "#cc9393") + ("NEXT" . "#dca3a3") + ("THEM" . "#dc8cc3") + ("PROG" . "#7cb8bb") + ("OKAY" . "#7cb8bb") + ("DONT" . "#5f7f5f") + ("FAIL" . "#8c5353") + ("DONE" . "#afd8af") + ("FIXME" . "#cc9393") + ("XXX" . "#cc9393") + ("XXXX" . "#cc9393") + ("???" . "#cc9393")) + "Faces used to highlight specific TODO keywords." + :group 'hl-todo + :type '(repeat (cons (string :tag "Keyword") + (choice :tag "Face " + (string :tag "Color") + (sexp :tag "Face")))) + :set (lambda (symbol value) + (set-default symbol value) + (setq hl-todo-keywords + `((,(concat "\\_<\\(" + (mapconcat 'car value "\\|") + "\\)\\_>") + (1 (hl-todo-get-face) t)))))) + +(defun hl-todo-get-face () + (let ((f (cdr (assoc (match-string 1) hl-todo-keyword-faces)))) + (if (stringp f) (list :inherit 'hl-todo :foreground f) f))) + +;;;###autoload +(define-minor-mode hl-todo-mode + "Highlight TODO tags in comments." + :lighter "" + :group 'hl-todo + (if hl-todo-mode + (font-lock-add-keywords nil hl-todo-keywords 'append) + (font-lock-remove-keywords nil hl-todo-keywords)) + (when (called-interactively-p 'any) + (font-lock-fontify-buffer))) + +;;;###autoload +(define-globalized-minor-mode global-hl-todo-mode + hl-todo-mode turn-on-hl-todo-mode-if-desired) + +(defun turn-on-hl-todo-mode-if-desired () + (when (apply 'derived-mode-p hl-todo-activate-in-modes) + (hl-todo-mode 1))) + +(provide 'hl-todo) +;; Local Variables: +;; indent-tabs-mode: nil +;; End: +;;; hl-todo.el ends here diff --git a/init.el b/init.el index b97fdad63..707be4d4d 100644 --- a/init.el +++ b/init.el @@ -10,61 +10,70 @@ ;; instead of / (cd "~") -;; (setq use-package-verbose t) ; for debug purposes +(setq use-package-verbose t) ; for debug purposes (require 'cask) (cask-initialize) +(setq user-mail-address "henrik@lissner.net") + (defconst *dir (file-name-directory load-file-name)) (defconst *init-dir (concat *dir "init/")) (defconst *themes-dir (concat *dir "themes/")) (defconst *elisp-dir (concat *dir "elisp/")) (defconst *snippets-dir (concat *dir "snippets/")) -(defconst *ac-dicts-dir (concat *dir "ac-dict")) -(defconst *tmp-dir "/tmp/emacs/") +(defconst *ac-dicts-dir (concat *dir "ac-dict/")) +(defconst *tmp-dir (concat *dir "tmp/")) (defconst *theme 'brin) -(defconst *font "Inconsolata-14") +(defconst *font + (if (string-equal system-name "ganymede.local") + "Ubuntu Mono-12" ; Use smaller font on my laptop + "Ubuntu Mono-14")) ; And larger font everywhere else (add-to-list 'load-path *init-dir) ;; Just the... bear necessities... (mapc 'require '(core - my-defuns ; Personal library - - ;; Tailoring emacs - core-editor ; Internal config for global editor behavior + core-defuns ; Defun library + core-editor ; Global editor behavior (w/ evil) core-ui ; User interface layout & behavior core-osx ; Mac-specific config - ;; Plugins & modules + ;; Essential plugins & modules init-ido ; Ido setup - init-project ; Project navigation tools & settings - init-ac ; Auto-complete engine & settings + init-project ; Project nav+search tools (projectile, helm, ag) init-snippets ; Snippet engine init-git ; GIT tools/settings init-fly ; Syntax & spell checker - init-etags + init-auto-complete ; Auto-complete engine + init-auto-insert ; File auto-insert templates + init-cscope ; Global code indexing ;; Modes & environments init-text ; Plain text editing (markdown, text) + init-sh ; Shell script editing (sh, zsh) init-org ; Org-mode: personal gtd/notes init-dev ; Generic dev tools & environment for all programming init-ruby init-python - init-webdev ; Environment for webdev (SCSS, PHP, Rails, Jekyll) + ;;init-php + init-webdev ; Environment for webdev (SCSS, PHP, Rails, Javascript) init-love ; Love.app gamedev init-cpp ; C++ gamedev - init-eclim ; Integration into eclipse (for Java) + init-java ; Java-specific settings (including eclim) + ;; init-go ; Go-lang + ;; init-swift ; iOS/Mac dev environment for swift ;; init-csharp ; Emacs as a Csharp/Unity IDE + ;; My homebaked packages + my-commands ; Ex commands & evil operators/commands + my-coderunner ; Code/REPL runners + + ;; Personal settings (must be last!) my-settings ; Any other custom settings - my-commands ; Interactive defuns & evil operators/commands my-keymaps ; My keybindings )) -;; (require 'server) -;; (unless (server-running-p) (server-start)) - ;; I've created a monster! diff --git a/init/README.md b/init/README.md deleted file mode 100644 index e69de29bb..000000000 diff --git a/init/core-defuns.el b/init/core-defuns.el new file mode 100644 index 000000000..69b2bba86 --- /dev/null +++ b/init/core-defuns.el @@ -0,0 +1,237 @@ +(provide 'core-defuns) + +;;;; Convenience ;;;;;;;;;;;;;;;;;;; +(defun associate-mode (match mode) + (add-to-list 'auto-mode-alist (cons match mode))) +(defun associate-minor-mode (match mode) + (add-to-list 'auto-minor-mode-alist (cons match mode))) + +(defmacro λ (&rest body) + `(lambda () (interactive) ,@body)) +(defmacro λ! (&rest body) + `(lambda () ,@body)) +(defmacro add-hook! (hook &rest body) + `(add-hook ,hook (lambda() ,@body))) + +;; Backwards compatibility +(unless (fboundp 'with-eval-after-load) + (defmacro with-eval-after-load (file &rest body) + `(eval-after-load ,file + `(funcall (function ,(lambda () ,@body)))))) + +(defmacro after (feature &rest forms) + `(,(if (or (not (boundp 'byte-compile-current-file)) + (not byte-compile-current-file) + (if (symbolp feature) + (require feature nil :no-error) + (load feature :no-message :no-error))) + 'progn + (message "after: cannot find %s" feature) + 'with-no-warnings) + (with-eval-after-load ',feature ,@forms))) + +;; vimmish keymapping shortcuts +(defalias 'defcmd 'evil-ex-define-cmd) + +(defmacro ibind (key command) + `(key-chord-define evil-insert-state-map ,key ,command)) + +(defun bind (state &rest keys) + (let ((state-list state) + (is-global (or (stringp state) + (vectorp state))) + keymap) + + (if is-global + (setq keys (-insert-at 0 state keys)) + (progn + (if (keymapp (first keys)) + (setq keymap (pop keys))) + + (if (or (keymapp state) + (not (listp state))) + (setq state-list (list state))))) + + (while keys + (let ((-key (pop keys)) + (-def (pop keys))) + + (if is-global + (global-set-key -key -def) + (dolist (-state state-list) + (cond ((evil-state-p -state) + (define-key + (if keymap + (evil-get-auxiliary-keymap keymap -state t) + (evil-state-property -state :keymap t)) -key -def)) + ((keymapp -state) + (define-key -state -key -def))))))))) + + +;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defun enable-comment-hard-wrap () + (set (make-local-variable 'comment-auto-fill-only-comments) t) + (turn-on-auto-fill)) + +(defun enable-tab-width-2 () + (setq tab-width 2 + evil-shift-width 2)) + +(defun disable-final-newline () + (set (make-local-variable 'require-final-newline) nil)) + + +;;; Text Defuns ;;;;;;;;;;;;;;;;;;;;;;;; +(defun my/surrounded-p () + (and (looking-back "[[{(]\\(\s+\\|\n\\)?\\(\s\\|\t\\)*") + (let* ((whitespace (match-string 1)) + (match-str (concat whitespace (match-string 2) "[])}]"))) + (looking-at-p match-str)))) + +(defun my/empty-line-p () + (zerop (length (s-trim (my/get-line))))) + +(defun my/get-line () + (buffer-substring (line-beginning-position) (line-end-position))) + +(defun my.backward-kill-to-bol-and-indent () + "Kill line to the first non-blank character. If invoked again +afterwards, kill line to column 1." + (interactive) + (let ((empty-line (my/empty-line-p))) + (evil-delete (point-at-bol) (point)) + (if (not empty-line) + (indent-according-to-mode)))) + +(defun my.point-at-first-non-blank() + (save-excursion (evil-first-non-blank) (point))) + +(defun my.move-to-bol () + "Moves cursor to the first non-blank character on the line. If +already there, move it to the true bol." + (interactive) + (evil-save-goal-column + (let ((point-at-bol (my.point-at-first-non-blank)) + (point (point))) + (if (= point-at-bol point) + (evil-move-beginning-of-line) + (unless (= (point-at-bol) point) + (evil-first-non-blank)))))) + +(defun my.move-to-eol () + (interactive) + (evil-save-goal-column + (let ((old-point (point))) + (when (comment-search-forward (point-at-eol) t) + (goto-char (match-beginning 0)) + (skip-syntax-backward " ^<*" (my.point-at-first-non-blank)) + + (if (eq old-point (point)) ; + (evil-move-end-of-line)))))) + +;; Mimic expandtab in vim +(defun my.backward-delete-whitespace-to-column () + "Delete back to the previous column of whitespace, or as much +whitespace as possible, or just one char if that's not possible." + (interactive) + (cond ;; If in a string + ((sp-point-in-string) + (call-interactively 'backward-delete-char-untabify)) + ;; If using tabs (or at bol), just delete normally + ((or indent-tabs-mode + (= (point-at-bol) (point))) + (call-interactively 'backward-delete-char)) + ;; Otherwise, delete up to the nearest tab column + (t (let ((movement (% (current-column) tab-width)) + (p (point))) + (when (= movement 0) + (setq movement tab-width)) + (save-match-data + (if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p)) + (backward-delete-char (- (match-end 1) (match-beginning 1))) + (call-interactively 'backward-delete-char-untabify))))))) + +(defun my.dumb-indent () + "Inserts a tab character (or spaces x tab-width). Checks if the +auto-complete window is open." + (interactive) + (if indent-tabs-mode + (insert "\t") + (let* ((movement (% (current-column) tab-width)) + (spaces (if (zerop movement) tab-width (- tab-width movement)))) + (insert (s-repeat spaces " "))))) + +(defun my.inflate-space-maybe () + "Checks if point is surrounded by {} [] () delimiters and adds a +space on either side of the point if so." + (interactive) + (if (my/surrounded-p) + (progn (call-interactively 'self-insert-command) + (save-excursion (call-interactively 'self-insert-command))) + (call-interactively 'self-insert-command))) + +(defun my.deflate-space-maybe () + "Checks if point is surrounded by {} [] () delimiters, and deletes +spaces on either side of the point if so. Resorts to +`my.backward-delete-whitespace-to-column' otherwise." + (interactive) + (save-match-data + (if (my/surrounded-p) + (let ((whitespace-match (match-string 1))) + (cond ((not whitespace-match) + (call-interactively 'delete-backward-char)) + ((string-match "\n" whitespace-match) + (evil-delete (point-at-bol) (point)) + (delete-char -1) + (save-excursion (delete-char 1))) + (t + (just-one-space 0)))) + (my.backward-delete-whitespace-to-column)))) + +(defun my.newline-and-indent () + "Newline and indent; if in a comment, auto-comment and properly +indent the next line." + (interactive) + (cond ((sp-point-in-string) + (evil-ret)) + ((evil-in-comment-p) + (if (eq major-mode 'js2-mode) + (js2-line-break) + (call-interactively 'indent-new-comment-line))) + (t + (evil-ret-and-indent)))) + +(defun s-lines? (s) (length (s-lines s))) + + +;; Utility ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun what-face (pos) + "Tells you the name of the face (point) is on." + (interactive "d") + (let ((face (or (get-char-property (point) 'read-face-name) + (get-char-property (point) 'face)))) + (if face (message "Face: %s" face) (message "No face at %d" pos)))) + +(defun what-col () + (interactive) + (message "Column %d" (current-column))) + +(defun my/append-to-list (list-var elements) + "Append ELEMENTS to the end of LIST." + (unless (consp elements) + (error "ELEMENTS must be a list")) + (let ((list (symbol-value list-var))) + (if list + (setcdr (last list) elements) + (set list-var elements))) + (symbol-value list-var)) + +(defun my/project-root (&optional force-pwd) + (if (and (not force-pwd) + (projectile-project-p)) + (projectile-project-root) + default-directory)) + +(defmacro f--exists? (file dir) + `(f-exists? (expand-file-name ,file ,dir))) diff --git a/init/core-editor.el b/init/core-editor.el index 7825d5769..3888422f7 100644 --- a/init/core-editor.el +++ b/init/core-editor.el @@ -2,134 +2,112 @@ ;;;; Editor behavior ;;;;;;;;;;;;;;;; (setq sentence-end-double-space nil) -(setq require-final-newline t) +;; (setq require-final-newline nil) +;; (setq mode-require-final-newline nil) +(setq-default fill-column 80) +(electric-indent-mode -1) ; In case of emacs 24.4 +(setq-default tab-width 4 + tab-always-indent nil + indent-tabs-mode nil) ; spaces instead of tabs -(setq-default tab-width 4) -(setq-default indent-tabs-mode nil) -(setq-default tab-always-indent nil) - -;; In case of emacs 24.4 -(electric-indent-mode -1) - -;; Remember undo history -(setq undo-tree-auto-save-history t) -(setq undo-tree-history-directory-alist `((".*" . ,*tmp-dir-undo))) - -;; Save cursor location across sessions -(require 'saveplace) -(setq-default save-place t) -(setq save-place-file (f-expand "saveplace" *tmp-dir)) - -;; Save history across sessions -(setq savehist-additional-variables - ;; search entries - '(search ring regexp-search-ring) - ;; keep the home clean - savehist-file (f-expand "savehist" *tmp-dir)) -(savehist-mode 1) +;; Show tab characters +(global-whitespace-mode 1) +(setq whitespace-style '(face tabs tab-mark) ; needs to be re-set in every buffer + whitespace-display-mappings + '((tab-mark ?\t [?| ?\t] [?\\ ?\t]) + (newline-mark 10 [36 10]))) ;;;; Modes 'n hooks ;;;;;;;;;;;;;;;;; -(associate-mode "\\.plist$" nxml-mode) -(associate-mode "zsh\\(env\\|rc\\)?$" shell-script-mode) -(associate-mode "z\\(profile\\|login\\|logout\\)?$" shell-script-mode) -(associate-mode "zsh/" shell-script-mode) -(associate-mode "\\.applescript$" applescript-mode) -(associate-mode "Cask$" emacs-lisp-mode) -(associate-mode "\\.el\\.gz$" emacs-lisp-mode) +(associate-mode "/LICENSE[^/]*$" 'text-mode) +(associate-mode "zsh\\(env\\|rc\\)?$" 'sh-mode) +(associate-mode "z\\(profile\\|login\\|logout\\)?$" 'sh-mode) +(associate-mode "zsh/" 'sh-mode) +(associate-mode "\\.applescript$" 'applescript-mode) +(associate-mode "Cask$" 'emacs-lisp-mode) +(associate-mode "\\.el\\.gz$" 'emacs-lisp-mode) +(associate-mode "/Makefile$" 'makefile-gmake-mode) +(associate-mode "\\.plist$" 'nxml-mode) -(add-hook 'text-mode-hook 'enable-hard-wrap) -(add-hook 'prog-mode-hook 'enable-comment-hard-wrap) (add-hook 'before-save-hook 'delete-trailing-whitespace) +;; Kill special (\\*.+\\*) buffers that are buried +(run-with-idle-timer 10 t 'my:kill-other-buffers) -;;;; Evil-mode ;;;;;;;;;;;;;;;;;;;;;;; + +;;;; Evil ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (use-package evil - :diminish undo-tree-mode - :config + :pre-load (defvar evil-want-C-u-scroll t) + :init (progn (evil-mode 1) + (setq evil-want-visual-char-semi-exclusive t + evil-search-module 'evil-search + evil-magic 'very-magic + + ;; Color-coded state cursors + evil-normal-state-cursor '("white" box) + evil-visual-state-cursor '("cyan" box) + evil-god-state-cursor '("orange" box)) + + ;; Fixes C-i's synonymity with TAB + (keyboard-translate ?\C-i ?\H-i) + (add-hook! 'find-file-hook (setq evil-shift-width tab-width)) - (setq evil-search-module 'evil-search) - (setq evil-magic 'very-magic) - ;; Color-coded state cursors - (setq evil-normal-state-cursor '("white" box)) - (setq evil-visual-state-cursor '("cyan" box)) - (setq evil-god-state-cursor '("orange" box)) - - (evil-set-initial-state 'comint-mode 'insert) + ;; modes to map to different default states + (dolist (mode-map '((cider-repl-mode . emacs) + (comint-mode . emacs) + (eshell-mode . emacs) + (fundamental-mode . normal) + (git-commit-mode . insert) + (git-rebase-mode . emacs) + (help-mode . normal) + (term-mode . emacs))) + (evil-set-initial-state `,(car mode-map) `,(cdr mode-map))) (use-package evil-ex-registers) (use-package evil-exchange) - (use-package evil-indent-textobject) + (use-package evil-indent-textobject) ; vii/vai/vaI (use-package evil-numbers) (use-package evil-visualstar) - - (use-package evil-nerd-commenter - :pre-load (setq evilnc-hotkey-comment-operator "g/")) - + (use-package evil-nerd-commenter :pre-load (setq evilnc-hotkey-comment-operator "g/")) + (use-package evil-space :init (evil-space-default-setup)) + (use-package evil-matchit :init (global-evil-matchit-mode 1)) + (use-package evil-surround :init (global-evil-surround-mode 1)) + (use-package evil-god-state) (use-package evil-jumper - :pre-load - (defvar evil-jumper-file (expand-file-name "jumplist" *tmp-dir)) - :config - (setq evil-jumper-auto-center t - evil-jumper-auto-save-interval 3600)) - - (use-package evil-space - :init (evil-space-default-setup)) - (use-package evil-matchit - :init (global-evil-matchit-mode 1)) - (use-package evil-surround - :init (global-evil-surround-mode 1) + :pre-load (defvar evil-jumper-file (expand-file-name "jumplist" *tmp-dir)) :config (progn - ;; Adds escaped delimiters to evil-surround - (defun my.evil-surround-escaped-pair () - "Evil-surround function to allow escaped delimiters. e.g. \"...\"" - (let* ((input (format "\\%s" (char-to-string (read-char "\\"))))) - ;; Type \\ to simply surround in single backslashes - (if (= input "\\\\") - (cons "\\" "\\") - (cons input input)))) - (setq-default evil-surround-pairs-alist (cons '(?\\ . my.evil-surround-escaped-pair) evil-surround-pairs-alist)))) + (setq evil-jumper-auto-center t + evil-jumper-auto-save-interval 3600) - (use-package god-mode) - (use-package evil-god-state :diminish god-local-mode) - - (defmap evil-ex-completion-map - (kbd "C-r") #'evil-ex-paste-from-register ; registers in ex-mode - (kbd "C-a") 'move-beginning-of-line - (kbd "") 'move-beginning-of-line - (kbd "") 'move-beginning-of-line - (kbd "") 'evil-delete-whole-line) + (define-key evil-motion-state-map (kbd "H-i") 'evil-jumper/forward))) + ;;;; ace-jump ;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Enable half-cursor blink when using ace-jump - (defadvice evil-ace-jump-char-mode (before evil-ace-jump-char-mode-operator-mode activate) - (evil-half-cursor)) - (defadvice evil-ace-jump-word-mode (before evil-ace-jump-word-mode-operator-mode activate) - (evil-half-cursor)) + (defadvice evil-ace-jump-char-mode (before evil-ace-jump-char-mode-op activate) (evil-half-cursor)) + (defadvice evil-ace-jump-word-mode (before evil-ace-jump-word-mode-op activate) (evil-half-cursor)) + (setq ace-jump-mode-scope 'global) ; limit ace-jump to current window + (setq ace-jump-mode-move-keys ; use a-z, 0-9 + (nconc (loop for i from ?a to ?z collect i) + (loop for i from ?A to ?Z collect i))) + ;; (setq ace-jump-mode-move-keys ; use a-z + ;; (loop for i from ?a to ?z collect i)) ;; Exit evil-exchange mode with (silently) -- and close ;; minibuffer remotely if it happens to be left open (defadvice evil-force-normal-state (before evil-esc-quit-exchange activate) (shut-up (evil-exchange-cancel) - (if (minibufferp) + (if (minibuffer-window-active-p (minibuffer-window)) (my:minibuffer-quit)))) - ;; Shut up beginning/end of buffer/line messages in minibuffer - (defun my.minibuffer-bolp () - "Return t if (point) is truly at the beginning of the -minibuffer/evil-ex (first character after the prompt), otherwise -returns nil." - (<= (- (point) (minibuffer-prompt-end)) 0)) - (defadvice left-char (around left-char-move-on-edges activate) - (if (minibufferp) - (unless (my.minibuffer-bolp) ad-do-it) - ad-do-it)) - (defadvice right-char (around right-char-move-on-edges activate) - (if (minibufferp) - (unless (eolp) ad-do-it) - ad-do-it)) + (defadvice evil-visual-line (before spc-for-line-jump activate) + (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-line-mode)) + (defadvice evil-visual-char (before spc-for-char-jump activate) + (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-char-mode)) + (defadvice evil-visual-block (before spc-for-char-jump activate) + (define-key evil-motion-state-map (kbd "SPC") #'evil-ace-jump-char-mode)) ;; Switch to new splits after splitting (defadvice evil-window-split (after evil-window-split-then-switch activate) @@ -174,69 +152,12 @@ returns nil." "\\1" file-name t))) file-name))) -;;;; Keymap Fixes ;;;;;;;;;;;;;;;;;;;;;; -;; This section is dedicated to keymaps that "fix" certain keys to -;; behave to be more like vim (or how I like it). - -;; Restores "dumb" indentation to the tab key. This rustles a lot of -;; peoples' jimmies, apparently, but it's how I like it. -(-imap (kbd "TAB") 'my.dumb-indent) -;; Except for lisp -(imap lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command) -(imap emacs-lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command) - -;; Highjacks backspace and space to: -;; a) expand spaces between delimiters intelligently: (|) -> ( | ) -;; b) the reverse of A: ( | ) -> (|) -;; c) allow backspace to delete indented blocks intelligently -;; d) and not do any of this magic when inside a string -(-imap (kbd "SPC") 'my.inflate-space-maybe - [remap backward-delete-char-untabify] 'my.deflate-space-maybe - [remap newline] 'my.newline-and-indent - - ;; Smarter move-to-beginning-of-line - [remap move-beginning-of-line] 'my.move-to-bol - - ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist - "\C-e" 'my.move-to-eol - "\C-u" 'my.backward-kill-to-bol-and-indent - - ;; Fix osx keymappings - (kbd "") 'my.move-to-bol - (kbd "") 'my.move-to-eol - (kbd "") 'my.backward-kill-to-bol-and-indent - - ;; Fixes delete - (kbd "") 'delete-char - - ;; Textmate-esque insert-line before/after - (kbd "") 'evil-open-below - (kbd "") 'evil-open-above) - -(add-hook! 'ido-setup-hook - (defmap ido-completion-map - (kbd "") 'ido-delete-backward-updir - "\C-w" 'ido-delete-backward-word-updir)) - -;; Make ESC quit all the things -(global-set-key [escape] 'keyboard-escape-quit) -(mapc (lambda (map) - (defmap map [escape] 'my:minibuffer-quit)) - (list minibuffer-local-map - minibuffer-local-ns-map - minibuffer-local-completion-map - minibuffer-local-must-match-map - minibuffer-local-isearch-map)) -(defmap isearch-mode-map [escape] 'isearch-abort) -(defmap evil-god-state-map [escape] 'evil-god-state-bail) -(defmap evil-ex-search-keymap [escape] 'evil-ex-search-exit) -;; Close help/compilation windows with escape -(defmap help-mode-map [escape] 'kill-buffer-and-window) -(defmap compilation-mode-map [escape] 'kill-buffer-and-window) -(emap debugger-mode-map [remap evil-exit-emacs-state] 'kill-buffer-and-window) ;;;; Editing plugins ;;;;;;;;;;;;;;;;;;; -(use-package expand-region) +(use-package anzu :init (global-anzu-mode)) +(use-package expand-region :commands (er/expand-region er/contract-region)) +(use-package rotate-text :commands (rotate-word-at-point rotate-region)) +(use-package smart-forward) (use-package smartparens :config @@ -255,49 +176,82 @@ returns nil." (sp-with-modes '(emacs-lisp-mode lisp-mode) (sp-local-pair "[" nil :post-handlers '(("|" "RET")))) - (sp-pair "[" nil :unless '(sp-point-before-word-p)) - (sp-pair "(" nil :unless '(sp-point-before-word-p)) - (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p)) - (sp-pair "'" nil :unless '(sp-point-after-word-p sp-point-before-word-p)) + (sp-pair "[" nil :unless '(sp-point-before-word-p sp-point-before-same-p)) + (sp-pair "(" nil :unless '(sp-point-before-word-p sp-point-before-same-p)) + (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p)) + (sp-pair "'" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p)) + (sp-pair "\"" nil :unless '(sp-point-after-word-p sp-point-before-word-p sp-point-before-same-p)) (after yasnippet (defadvice yas-expand (before advice-for-yas-expand activate) (sp-remove-active-pair-overlay))))) -(use-package anzu - :diminish anzu-mode - :init - (global-anzu-mode)) -;;;; Utility plugins ;;;;;;;;;;;;;;;;;; -(use-package key-chord - :init - (progn (key-chord-mode 1) - (setq key-chord-two-keys-delay 0.5))) +;;;; Keymap Fixes ;;;;;;;;;;;;;;;;;;;;;; +;; This section is dedicated to keymaps that "fix" certain keys so +;; that they behave more like vim (or how I like it). -(use-package smex - :commands (smex smex-major-mode-commands) - :config - (progn (smex-initialize) - ;; Hook up smex to auto-update, rather than update on every run - (defun smex-update-after-load (unused) - (when (boundp 'smex-cache) (smex-update))) - (add-hook 'after-load-functions 'smex-update-after-load))) +;; Restores "dumb" indentation to the tab key. This rustles a lot of +;; peoples' jimmies, apparently, but it's how I like it. +(bind 'insert (kbd "TAB") 'my.dumb-indent) +;; Except for lisp +(bind 'insert lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command) +(bind 'insert emacs-lisp-mode-map [remap my.dumb-indent] 'indent-for-tab-command) -(use-package recentf - :init - (progn (recentf-mode 1) - (setq recentf-max-menu-items 0 - recentf-max-saved-items 100 - recentf-auto-cleanup 'never - recentf-exclude '("/tmp/" "/ssh:" "\\.ido\\.last\\'" "\\.revive\\'", "TAGS", "GEMTAGS")))) +;; Highjacks backspace and space to: +;; a) expand spaces between delimiters intelligently: (|) -> ( | ) +;; b) the reverse of A: ( | ) -> (|) +;; c) allow backspace to delete indented blocks intelligently +;; d) and not do any of this magic when inside a string +(bind 'insert + (kbd "SPC") 'my.inflate-space-maybe + [remap backward-delete-char-untabify] 'my.deflate-space-maybe + [remap newline] 'my.newline-and-indent -(use-package re-builder - :defer t - :config - (progn (setq reb-re-syntax 'string) - (defadvice evil-force-normal-state (before evil-esc-quit-reb-mode activate) - (when (eq 'reb-mode major-mode) - (if reb-subexp-mode - (reb-quit-subexp-mode) - (reb-quit)))))) + ;; Smarter move-to-beginning-of-line + [remap move-beginning-of-line] 'my.move-to-bol + + ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist + "\C-e" 'my.move-to-eol + "\C-u" 'my.backward-kill-to-bol-and-indent + + ;; Fixes delete + (kbd "") 'delete-char + + ;; Textmate-esque insert-line before/after + (kbd "") 'evil-open-below + (kbd "") 'evil-open-above) + +;; Fix osx keymappings and then some +(bind (kbd "") 'my.move-to-bol + (kbd "") 'my.move-to-eol + (kbd "") 'smart-up + (kbd "") 'smart-down + (kbd "") 'my.backward-kill-to-bol-and-indent) + +(add-hook! 'ido-setup-hook + (bind ido-completion-map + (kbd "") 'ido-delete-backward-updir + "\C-w" 'ido-delete-backward-word-updir)) + +;; Make ESC quit all the things +(bind [escape] 'keyboard-escape-quit) +(bind (list minibuffer-local-map + minibuffer-local-ns-map + minibuffer-local-completion-map + minibuffer-local-must-match-map + minibuffer-local-isearch-map) [escape] 'my:minibuffer-quit) + +(bind 'god [escape] 'evil-god-state-bail) +(bind 'normal special-mode-map [escape] 'popwin:close-popup-window) +(bind isearch-mode-map "\C-w" 'isearch-abort) +;; Close help/compilation windows with escape +(bind messages-buffer-mode-map [escape] 'kill-this-buffer) +(bind special-mode-map [escape] 'popwin:close-popup-window) +;;(bind 'normal diff-mode-map +;; [escape] 'kill-this-buffer +;; "q" 'kill-this-buffer) +; (bind 'normal c +; scope-minor-mode-keymap +; [escape] 'kill-this-buffer +; "q" 'kill-this-buffer) diff --git a/init/core-osx.el b/init/core-osx.el index 4bbe0f758..11657f1f0 100644 --- a/init/core-osx.el +++ b/init/core-osx.el @@ -11,4 +11,11 @@ ;; fix emacs PATH on OSX (GUI only) (use-package exec-path-from-shell :if (memq window-system '(mac ns)) - :init (exec-path-from-shell-initialize))) + :init (exec-path-from-shell-initialize)) + + ;; On OSX, stop copying each visual state move to the clipboard: + ;; https://bitbucket.org/lyro/evil/issue/336/osx-visual-state-copies-the-region-on + ;; Most of this code grokked from: + ;; http://stackoverflow.com/questions/15873346/elisp-rename-macro + (defadvice evil-visual-update-x-selection (around clobber-x-select-text activate) + (unless (featurep 'ns) ad-do-it))) diff --git a/init/core-ui.el b/init/core-ui.el index b9ec48c1c..0683ac33b 100644 --- a/init/core-ui.el +++ b/init/core-ui.el @@ -1,30 +1,43 @@ (provide 'core-ui) -;; (global-linum-mode t) ; line numbers for everybody! -(blink-cursor-mode -1) -(global-hl-line-mode 1) +;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;; +(setq ring-bell-function 'ignore) +(add-to-list 'default-frame-alist `(font . ,*font)) +(add-to-list 'default-frame-alist '(alpha . 100)) ; *slightly* transparent window +(when (functionp 'scroll-bar-mode) (scroll-bar-mode -1)) ; no scrollbar +(when (functionp 'tool-bar-mode) (tool-bar-mode -1)) ; no toolbar +(when (functionp 'menu-bar-mode) (menu-bar-mode -1)) ; no menubar +(when (fboundp 'fringe-mode) (fringe-mode '(5 . 10))) ; no nonsense + +(defun toggle-transparency () + (interactive) + (let ((frame (selected-frame))) + (if (= (frame-parameter frame 'alpha) 0) + (set-frame-parameter frame 'alpha 100) + (set-frame-parameter frame 'alpha 0)))) + + +;;;; Other Settings ;;;;;;;;;;;;;;;;;;;; +(blink-cursor-mode 1) ; blink cursor +(global-hl-line-mode -1) ; highlight line +(line-number-mode 1) ; hide line no in modeline +(column-number-mode 1) ; hide col no in modeline +(show-paren-mode -1) ; highlight matching delimiters (setq show-paren-delay 0) -(show-paren-mode 1) -;; Multiple cursors across buffers cause a strange redraw delay for -;; some things, like auto-complete or evil-mode's cursor color -;; switching. -(setq-default cursor-in-non-selected-windows nil) - -;; Show line/col-no in mode-line -(line-number-mode t) -(column-number-mode t) -;; make the fringe unintrusive -(when (fboundp 'fringe-mode) - (fringe-mode '(0 . 10))) +(setq linum-format (quote "%4d ")) +;; (add-hook 'text-mode-hook 'linum-mode) +;; (add-hook 'prog-mode-hook 'linum-mode) ;; 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)) +;; Multiple cursors across buffers cause a strange redraw delay for +;; some things, like auto-complete or evil-mode's cursor color +;; switching. +(setq-default cursor-in-non-selected-windows nil) ;; do not soft-wrap lines (setq-default truncate-lines t) @@ -32,40 +45,82 @@ (add-hook! 'help-mode-hook (setq truncate-lines nil)) (setq ediff-window-setup-function 'ediff-setup-windows-plain) - (setq indicate-buffer-boundaries nil) (setq indicate-empty-lines nil) +(setq-default visible-bell nil) ; silence of the bells +(setq-default use-dialog-box nil) ; avoid GUI -(setq-default visible-bell nil) -(setq-default use-dialog-box nil) - -;;;; GUI Settings ;;;;;;;;;;;;;;;;;;;;;; -(setq ring-bell-function 'ignore) -(add-to-list 'default-frame-alist `(font . ,*font)) -(add-to-list 'default-frame-alist '(alpha 98 95)) ; *slightly* transparent window - -(when (functionp 'scroll-bar-mode) (scroll-bar-mode -1)) -(when (functionp 'tool-bar-mode) (tool-bar-mode -1)) -(when (functionp 'menu-bar-mode) (menu-bar-mode -1)) ;;;; Modeline ;;;;;;;;;;;;;;;;;;;;;;;;;; +(use-package uniquify + :config (setq uniquify-buffer-name-style 'post-forward + uniquify-separator ":" + uniquify-ignore-buffers-re "^\\*")) + (use-package smart-mode-line :config - (mapc (lambda(mode) (add-to-list 'rm-excluded-modes mode)) - '(" SP" - " Fill" - " yas" - " Fly" - " EvilOrg" - " Abbrev" - )) + (setq rm-blacklist + (mapconcat 'identity + '(" SP" + " Fill" + " yas" + " Fly" + " EvilOrg" + " Abbrev" + " WS" + " GitGutter" + " Anzu" + " Undo-Tree" + " AC" + " Projectile\\[.+\\]" + ) "\\|")) :init (progn (setq sml/no-confirm-load-theme t sml/mode-width 'full + sml/extra-filler 2 sml/show-remote nil + sml/modified-char "*" sml/encoding-format nil) - (add-to-list 'sml/replacer-regexp-list '("^:DB:projects/" "PR:") t) - (sml/setup) - (sml/apply-theme 'respectful))) + (setq sml/replacer-regexp-list '(("^~/Dropbox/Projects/" "PROJECTS:") + ("^~/.emacs.d/" "EMACS.D:"))) + + (after evil (setq evil-mode-line-format nil)) + + (setq-default mode-line-misc-info + '((which-func-mode ("" which-func-format "")) + (global-mode-string ("" global-mode-string "")))) + + (add-hook! 'after-change-major-mode-hook + (setq mode-line-format + '(" " + "%e" + ;; anzu--mode-line-format + mode-line-mule-info + mode-line-client + mode-line-remote + mode-line-frame-identification + mode-line-buffer-identification + mode-line-modified + mode-line-modes + mode-line-misc-info + (vc-mode vc-mode) + " " + mode-line-position + " " + mode-line-front-space + )) + + (add-to-list 'mode-line-modes + '(sml/buffer-identification-filling + sml/buffer-identification-filling + (:eval (setq sml/buffer-identification-filling + (sml/fill-for-buffer-identification)))))) + + (let ((-linepo mode-line-position)) + (sml/setup) + (sml/apply-theme 'respectful) + + (setq mode-line-position -linepo) + (sml/filter-mode-line-list 'mode-line-position)))) diff --git a/init/core.el b/init/core.el index 7f5f9ee87..ffd273957 100644 --- a/init/core.el +++ b/init/core.el @@ -1,78 +1,91 @@ (provide 'core) -(require 'f) - -(defconst is-mac (eq system-type 'darwin)) +(defconst is-mac (eq system-type 'darwin)) (defconst is-linux (eq system-type 'gnu/linux)) -;; Setup theme +;;;; Load theme ;;;;;;;;;;;;;;;;;;;;;;;;;; (add-to-list 'custom-theme-load-path *themes-dir) (load-theme *theme t) -;; Emacs under-the-hood -(global-auto-revert-mode 1) ; revert buffers for changed files -(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no +;;;; Emacs under the hood ;;;;;;;;;;;;;;;; (prefer-coding-system 'utf-8) -(setq-default load-prefer-newer t ; load newer .el over older .elc - gc-cons-threshold 50000000 ; avoid garbage collection (default is 400k) - enable-recursive-minibuffers nil - redisplay-dont-pause t - confirm-kill-emacs nil - compilation-scroll-output t) - -;; Show keystrokes -(setq echo-keystrokes 0.02) +(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no +(setq-default + load-prefer-newer t ; load newer .el over older .elc + gc-cons-threshold 50000000 ; avoid garbage collection (default is 400k) + enable-recursive-minibuffers nil + redisplay-dont-pause t + confirm-kill-emacs nil + compilation-scroll-output t) ;; Sane scroll settings -(setq scroll-margin 3 +(setq scroll-margin 5 scroll-conservatively 100000 - scroll-preserve-screen-position 1) - -(setq inhibit-startup-screen t ; don't show EMACs start screen + scroll-preserve-screen-position 1 + echo-keystrokes 0.02 ; Show keystrokes + inhibit-startup-screen t ; don't show EMACs start screen inhibit-splash-screen t inhibit-startup-buffer-menu t - inhibit-startup-echo-area-message t initial-major-mode 'text-mode initial-scratch-message nil - initial-scratch-buffer nil) ; empty scratch buffer + initial-scratch-buffer nil) ; empty scratch buffer -;;; Backups -(defconst *tmp-dir-undo (f-expand "undo" *tmp-dir)) -(defconst *tmp-dir-backup (f-expand "backup" *tmp-dir)) +;; Make sure undo/backup folders exist +(require 'f) +(defconst *tmp-dir-undo (f-expand "undo" *tmp-dir)) +(defconst *tmp-dir-backup (f-expand "backup" *tmp-dir)) +(defconst *tmp-dir-autosave (f-expand "autosave" *tmp-dir)) (unless (f-dir? *tmp-dir) - (f-mkdir *tmp-dir *tmp-dir-undo *tmp-dir-backup)) + (f-mkdir *tmp-dir + *tmp-dir-undo + *tmp-dir-backup + *tmp-dir-autosave)) -(setq make-backup-files nil ; Don't want any backup - auto-save-list-file-name nil ; Don't want any .saves - auto-save-default nil ; Don't want any auto saving - create-lockfiles nil) +;; Disable all backups (that's what git/dropbox are for) +(setq make-backup-files nil + create-lockfiles nil + auto-save-default nil + auto-save-list-file-name (concat *tmp-dir-autosave ".auto-save") + ;; In case I want to reactivate backup files + backup-directory-alist `((".*" . ,*tmp-dir-backup)) + auto-save-file-name-transforms `((".*" ,*tmp-dir-autosave t))) -;; In case I want to reactivate backup files -(setq backup-directory-alist `((".*" . ,*tmp-dir-backup))) +;; Remember undo history +(setq-default undo-tree-history-directory-alist `(("." . ,*tmp-dir-undo))) +(setq-default undo-tree-auto-save-history t) -;; window layout undo/redo, keymaps in core-keymaps.el -(when (fboundp 'winner-mode) (winner-mode 1)) +;;;; Save history across sessions +;; search entries +(defvar savehist-additional-variables '(search ring regexp-search-ring)) +;; keep the home clean +(defvar savehist-file (f-expand "savehist" *tmp-dir)) +(savehist-mode 1) -;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;; + +;;;; My personal global mode ;;;;;;;;;;;;; +(defvar my-mode-map (make-sparse-keymap)) +(define-minor-mode my-mode + "My personal global mode." + :global t + :keymap my-mode-map) + + +;;;; Behavior adjustments ;;;;;;;;;;;;;;;; ;; Make next/previous-buffer skip special buffers -(defadvice next-buffer (after avoid-messages-buffer-in-next-buffer activate) +(defadvice next-buffer (after void-messages-buffer-in-next-buffer activate) "Advice around `next-buffer' to avoid going into the *Messages* buffer." (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (next-buffer))) (defadvice previous-buffer (after avoid-messages-buffer-in-previous-buffer activate) "Advice around `previous-buffer' to avoid going into the *Messages* buffer." (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (previous-buffer))) -;;;; My personal minor mode ;;;;;;;; -(defvar my-mode-map (make-sparse-keymap)) -(define-minor-mode my-mode :global t :keymap my-mode-map) -;; Automatic minor modes +;;;; Automatic minor modes ;;;;;;;;;;;;;;; (defvar auto-minor-mode-alist () "Alist of filename patterns vs correpsonding minor mode functions, see `auto-mode-alist' All elements of this alist are checked, meaning you can enable multiple minor modes for the same regexp.") - (defun enable-minor-mode-based-on-extension () "check file name against auto-minor-mode-alist to enable minor modes the checking happens for all pairs in auto-minor-mode-alist" @@ -93,17 +106,54 @@ the checking happens for all pairs in auto-minor-mode-alist" (add-hook 'find-file-hook 'enable-minor-mode-based-on-extension) -;;;; Load the rest ;;;;;;;;;;;;;;;;;; +(global-auto-revert-mode 1) ; revert buffers for changed files (require 'shut-up) -(when noninteractive - (shut-up-silence-emacs)) +(when noninteractive (shut-up-silence-emacs)) +;; What we do every night, Pinkie... +(defun my/greeter () (message "What're we gonna do tonight, Brain?")) +(defalias 'display-startup-echo-area-message 'my/greeter) + +(when (fboundp 'winner-mode) (winner-mode 1)) ; window layout undo/redo + + +;;;; Utility plugins ;;;;;;;;;;;;;;;;;; ;; Package management bootstrap +(require 'use-package) (setq package-enable-at-startup nil delete-old-versions t) - +;; Add ./elisp/* to load-path (let ((default-directory *elisp-dir)) (normal-top-level-add-to-load-path '(".")) (normal-top-level-add-subdirs-to-load-path)) -(require 'use-package) +(use-package key-chord + :init (key-chord-mode 1) + :config (setq key-chord-two-keys-delay 0.5)) + +(use-package recentf + :init + (progn (setq recentf-max-menu-items 0 + recentf-max-saved-items 100 + recentf-auto-cleanup 'never + recentf-save-file (concat *tmp-dir "recentf") + recentf-exclude '("/tmp/" "/ssh:" "\\.?ido\\.last\\'" "\\.revive\\'", "/TAGS\\'")) + (recentf-mode 1))) + +(use-package smex + :commands (smex smex-major-mode-commands) + :config + (progn (smex-initialize) + ;; Hook up smex to auto-update, rather than update on every run + (defun smex-update-after-load (unused) + (when (boundp 'smex-cache) (smex-update))) + (add-hook 'after-load-functions 'smex-update-after-load))) + +(use-package popwin + :init (popwin-mode 1) + :config + (progn (setq popwin:popup-window-height 0.45) + (push '(diff-mode :position bottom :stick t) popwin:special-display-config) + (push '("*Backtrace*") popwin:special-display-config) + (push '("*Warnings*") popwin:special-display-config) + (push '("*Process List*") popwin:special-display-config))) diff --git a/init/defuns/commands.el b/init/defuns/commands.el deleted file mode 100644 index e69de29bb..000000000 diff --git a/init/defuns/config.el b/init/defuns/config.el deleted file mode 100644 index a750d0c15..000000000 --- a/init/defuns/config.el +++ /dev/null @@ -1,93 +0,0 @@ -;;;; Macros ;;;;;;;;;;;;;;;;;;;;;;;; -(defmacro λ (&rest body) - `(lambda () (interactive) ,@body)) - -(defmacro associate-mode (match mode) - `(add-to-list 'auto-mode-alist '(,match . ,mode))) - -(defmacro associate-minor-mode (match minor-mode) - `(add-to-list 'auto-minor-mode-alist '(,match . ,minor-mode))) - -(defmacro add-hook! (hook &rest body) - `(add-hook ,hook (lambda() ,@body))) - -;; Backwards compatibility -(unless (fboundp 'with-eval-after-load) - (defmacro with-eval-after-load (file &rest body) - `(eval-after-load ,file - `(funcall (function ,(lambda () ,@body)))))) - -(defmacro after (feature &rest forms) - `(,(if (or (not (boundp 'byte-compile-current-file)) - (not byte-compile-current-file) - (if (symbolp feature) - (require feature nil :no-error) - (load feature :no-message :no-error))) - 'progn - (message "after: cannot find %s" feature) - 'with-no-warnings) - (with-eval-after-load ',feature ,@forms))) - -;; vimmish keymapping shortcuts -(defalias 'exmap 'evil-ex-define-cmd) -(defmacro ichmap (key command) - `(key-chord-define evil-insert-state-map ,key ,command)) -(defmacro defmap (map &rest body) - `(evil-define-key nil ,map ,@body)) - -(defmacro nmap (map &rest body) - `(evil-define-key 'normal ,map ,@body)) -(defmacro vmap (map &rest body) - `(evil-define-key 'visual ,map ,@body)) -(defmacro imap (map &rest body) - `(evil-define-key 'insert ,map ,@body)) -(defmacro emap (map &rest body) - `(evil-define-key 'emacs ,map ,@body)) -(defmacro gmap (map &rest body) - `(evil-define-key 'god ,map ,@body)) -(defmacro mmap (map &rest body) - `(evil-define-key 'motion ,map ,@body)) -(defmacro omap (map &rest body) - `(evil-define-key 'operator ,map ,@body)) -(defmacro nvmap (map &rest body) - (macroexpand - `(progn (nmap ,map ,@body) - (vmap ,map ,@body)))) - -(defmacro nmap! (&rest body) - `(evil-define-key 'normal my-mode-map ,@body)) -(defmacro vmap! (&rest body) - `(evil-define-key 'visual my-mode-map ,@body)) -(defmacro imap! (&rest body) - `(evil-define-key 'insert my-mode-map ,@body)) -(defmacro emap! (&rest body) - `(evil-define-key 'emacs my-mode-map ,@body)) -(defmacro gmap! (&rest body) - `(evil-define-key 'god my-mode-map ,@body)) -(defmacro mmap! (&rest body) - `(evil-define-key 'motion my-mode-map ,@body)) -(defmacro omap! (&rest body) - `(evil-define-key 'operator my-mode-map ,@body)) -(defmacro nvmap! (&rest body) - (macroexpand - `(progn (nmap! ,@body) - (vmap! ,@body)))) - -(defmacro -nmap (&rest body) - `(evil-define-key nil evil-normal-state-map ,@body)) -(defmacro -vmap (&rest body) - `(evil-define-key nil evil-visual-state-map ,@body)) -(defmacro -imap (&rest body) - `(evil-define-key nil evil-insert-state-map ,@body)) -(defmacro -emap (&rest body) - `(evil-define-key nil evil-emacs-state-map ,@body)) -(defmacro -gmap (&rest body) - `(evil-define-key nil evil-god-state-map ,@body)) -(defmacro -mmap (&rest body) - `(evil-define-key nil evil-motion-state-map ,@body)) -(defmacro -omap (&rest body) - `(evil-define-key nil evil-operator-state-map ,@body)) -(defmacro -nvmap (&rest body) - (macroexpand - `(progn (-nmap ,@body) - (-vmap ,@body)))) diff --git a/init/defuns/hooks.el b/init/defuns/hooks.el deleted file mode 100644 index 2768623b6..000000000 --- a/init/defuns/hooks.el +++ /dev/null @@ -1,9 +0,0 @@ -(defun enable-hard-wrap() - (auto-fill-mode 1)) - -(defun enable-comment-hard-wrap () - (set (make-local-variable 'comment-auto-fill-only-comments) t) - (auto-fill-mode 1)) - -(defun enable-tab-width-2 () - (setq tab-width 2)) diff --git a/init/defuns/text.el b/init/defuns/text.el deleted file mode 100644 index 7f4b1239b..000000000 --- a/init/defuns/text.el +++ /dev/null @@ -1,105 +0,0 @@ -;;; Library Defuns ;;;;;;;;;;;;;;;;;;;;; -(defun my/surrounded-p () - (and (looking-back "[[{(]\\(\s+\\|\n\\)?\\(\s\\|\t\\)*") - (let* ((whitespace (match-string 1)) - (match-str (concat whitespace (match-string 2) "[])}]"))) - (looking-at-p match-str)))) - -(defun my/empty-line-p () - (zerop (length (s-trim (my/get-line))))) - -(defun my/get-line () - (buffer-substring (line-beginning-position) (line-end-position))) - -;;; Text Defuns ;;;;;;;;;;;;;;;;;;;;;;;; -(defun my.backward-kill-to-bol-and-indent () - "Kill line to the first non-blank character. If invoked again -afterwards, kill line to column 1." - (interactive) - (let ((empty-line (my/empty-line-p))) - (evil-delete (point-at-bol) (point)) - (if (not empty-line) - (indent-according-to-mode)))) - -(defun my.move-to-bol () - "Moves cursor to the first non-blank character on the line. If -already there, move it to the true bol." - (interactive) - (let ((point-at-bol (save-excursion (evil-first-non-blank) (point)))) - (if (= point-at-bol (point)) - (evil-move-beginning-of-line) - (evil-first-non-blank)))) - -(defun my.move-to-eol () - (interactive) - (evil-move-end-of-line)) - -;; Mimic expandtab in vim -(defun my.backward-delete-whitespace-to-column () - "Delete back to the previous column of whitespace, or as much -whitespace as possible, or just one char if that's not possible." - (interactive) - (cond ;; If in a string - ((sp-point-in-string) - (call-interactively 'backward-delete-char-untabify)) - ;; If using tabs (or at bol), just delete normally - ((or indent-tabs-mode - (= (point-at-bol) (point))) - (call-interactively 'backward-delete-char)) - ;; Otherwise, delete up to the nearest tab column - (t (let ((movement (% (current-column) tab-width)) - (p (point))) - (when (= movement 0) - (setq movement tab-width)) - (save-match-data - (if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p)) - (backward-delete-char (- (match-end 1) (match-beginning 1))) - (call-interactively 'backward-delete-char-untabify))))))) - -(defun my.dumb-indent () - "Inserts a tab character (or spaces x tab-width). Checks if the -auto-complete window is open." - (interactive) - (if indent-tabs-mode - (insert "\t") - (let* ((movement (% (current-column) tab-width)) - (spaces (if (zerop movement) tab-width (- tab-width movement)))) - (insert (s-repeat spaces " "))))) - -(defun my.inflate-space-maybe () - "Checks if point is surrounded by {} [] () delimiters and adds a -space on either side of the point if so." - (interactive) - (if (my/surrounded-p) - (progn (insert " ") - (save-excursion (insert " "))) - (insert " "))) - -(defun my.deflate-space-maybe () - "Checks if point is surrounded by {} [] () delimiters, and deletes -spaces on either side of the point if so. Resorts to -`my.backward-delete-whitespace-to-column' otherwise." - (interactive) - (save-match-data - (if (my/surrounded-p) - (let ((whitespace-match (match-string 1))) - (cond ((not whitespace-match) - (call-interactively 'delete-backward-char)) - ((string-match "\n" whitespace-match) - (evil-delete (point-at-bol) (point)) - (delete-char -1) - (save-excursion (delete-char 1))) - (t - (just-one-space 0)))) - (my.backward-delete-whitespace-to-column)))) - -(defun my.newline-and-indent () - "Newline and indent; if in a comment, auto-comment and properly -indent the next line." - (interactive) - (cond ((sp-point-in-string) - (evil-ret)) - ((evil-in-comment-p) - (indent-new-comment-line)) - (t - (evil-ret-and-indent)))) diff --git a/init/defuns/utility.el b/init/defuns/utility.el deleted file mode 100644 index eb3125a24..000000000 --- a/init/defuns/utility.el +++ /dev/null @@ -1,25 +0,0 @@ -(defun what-face (pos) - "Tells you the name of the face (point) is on." - (interactive "d") - (let ((face (or (get-char-property (point) 'read-face-name) - (get-char-property (point) 'face)))) - (if face (message "Face: %s" face) (message "No face at %d" pos)))) - -(defun my/append-to-list (list-var elements) - "Append ELEMENTS to the end of LIST." - (unless (consp elements) - (error "ELEMENTS must be a list")) - (let ((list (symbol-value list-var))) - (if list - (setcdr (last list) elements) - (set list-var elements))) - (symbol-value list-var)) - -(defun my/project-root (&optional force-pwd) - (if (and (not force-pwd) - (projectile-project-p)) - (projectile-project-root) - default-directory)) - -(defmacro f--exists? (file dir) - `(f-exists? (expand-file-name ,file ,dir))) diff --git a/init/init-ac.el b/init/init-ac.el deleted file mode 100644 index 6f9129cef..000000000 --- a/init/init-ac.el +++ /dev/null @@ -1,31 +0,0 @@ -(provide 'init-ac) - -;; -(use-package auto-complete - :diminish auto-complete-mode - :init - (progn - (require 'auto-complete-config) - - (setq ac-auto-start nil - ac-auto-show-menu t ; Suggestions box must be invoked manually (see core-keymaps.el) - ac-use-menu-map t ; Enable ac-menu-map map when menu is open - ac-use-quick-help t ; Don't show tooltips unless invoked (see core-keymaps.el) - ac-use-fuzzy nil - ac-candidate-limit 25) - (setq ac-comphist-file (concat *tmp-dir "ac-comphist.dat")) - - (setq-default ac-sources '(ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers)) - (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup) - (add-hook 'css-mode-hook 'ac-css-mode-setup) - (add-hook 'shell-script-mode-hook 'ac-add-files) - ;; (add-hook 'auto-complete-mode-hook 'ac-common-setup) - (global-auto-complete-mode t)) - :config - (progn - (add-to-list 'ac-dictionary-files (expand-file-name "global" *ac-dicts-dir)) - (add-to-list 'ac-dictionary-directories *ac-dicts-dir) - (add-to-list 'ac-modes 'nxml-mode) - - ;; Tell ido not to care about case - (setq completion-ignore-case t))) diff --git a/init/init-auto-complete.el b/init/init-auto-complete.el new file mode 100644 index 000000000..61a5f74cc --- /dev/null +++ b/init/init-auto-complete.el @@ -0,0 +1,68 @@ +(provide 'init-auto-complete) + +(setq tags-case-fold-search nil) + +(use-package auto-complete + :init + (progn + (require 'auto-complete-config) + + (setq ac-auto-start nil + ac-auto-show-menu t ; Suggestions box must be invoked manually (see core-keymaps.el) + ac-use-menu-map t ; Enable ac-menu-map map when menu is open + ac-use-quick-help t ; Don't show tooltips unless invoked (see core-keymaps.el) + ac-use-fuzzy t + ac-candidate-limit 25) + (setq ac-comphist-file (concat *tmp-dir "ac-comphist.dat")) + + (setq-default ac-sources '(ac-source-yasnippet ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers)) + + (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup) + (add-hook 'css-mode-hook 'ac-css-mode-setup) + (add-hook 'shell-script-mode-hook 'ac-add-files) + ;; (add-hook 'auto-complete-mode-hook 'ac-common-setup) + ) + :config + (progn + ;; Redefine this function so auto-complete is available [almost] everywhere + (defun auto-complete-mode-maybe () + (unless (minibufferp (current-buffer)) + (auto-complete-mode 1))) + + (global-auto-complete-mode t) + + (add-to-list 'ac-dictionary-files (expand-file-name "global" *ac-dicts-dir)) + (add-to-list 'ac-dictionary-directories *ac-dicts-dir) + + ;; Tell ido not to care about case + (setq completion-ignore-case t) + + (bind 'insert ac-mode-map + (kbd "C-x C-k") 'ac-complete-dictionary + (kbd "C-x C-f") 'ac-complete-filename + (kbd "C-x C-]") 'ac-complete-etags + (kbd "C-x s") 'ac-complete-ispell + (kbd "C-x C-s") 'ac-complete-ispell-fuzzy + (kbd "C-x C-y") 'ac-complete-yasnippet + (kbd "C-x C-o") 'auto-complete + (kbd "C-SPC") 'auto-complete) + + (bind ac-completing-map + (kbd "") 'ac-complete + (kbd "C-n") 'ac-next + (kbd "C-p") 'ac-previous + (kbd "") 'ac-quick-help + (kbd "C-") 'ac-help + (kbd "ESC") 'ac-stop + (kbd "RET") 'ac-complete) + + (use-package ac-etags + :commands (ac-complete-etags) + :config (ac-etags-setup)) + + (use-package ac-ispell + :commands (ac-complete-ispell ac-complete-ispell-fuzzy) + :config + (progn (ac-ispell-setup) + (setq ac-ispell-requires 1 + ac-ispell-fuzzy-limit 25))))) diff --git a/init/init-auto-insert.el b/init/init-auto-insert.el new file mode 100644 index 000000000..2d165df9f --- /dev/null +++ b/init/init-auto-insert.el @@ -0,0 +1,82 @@ +(provide 'init-auto-insert) + +(use-package autoinsert) +;; (setq auto-insert-directory "%/.emacs.d/templates/") +(setq auto-insert-query nil) ; Don't prompt before insertion +(setq auto-insert-alist (list)) ; Don't prompt before insertion +(auto-insert-mode 1) + +(after yasnippet + (defun template (file-regexp uuid mode &optional project-only) + (define-auto-insert file-regexp `(lambda () (template-insert ,uuid ',mode ,project-only)))) + (defun template-insert (uuid mode &optional project-only) + "Expand snippet template in MODE by its UUID" + (unless (and project-only + (not (projectile-project-p))) + (yas-expand-snippet + (yas--template-content + (yas--get-template-by-uuid mode uuid)) (point-min) (point-max)) + (evil-insert-state))) + + (template "/\\.gitignore$" "%%" 'gitignore-mode) + + ;; C/C++ + (template "/Makefile$" "%%" 'makefile-gmake-mode) + (template "/main\\.\\([Cc]\\|cc\\|cpp\\)$" "%main.cpp%" 'c++-mode) + (template "/win32_\\.\\([Cc]\\|cc\\|cpp\\)$" "%winmain.cpp%" 'c++-mode) + (template "\\.\\([Hh]\\|hpp\\)$" "%.h%" 'c++-mode) + (template "\\.\\([Cc]\\|cc\\|cpp\\)$" "%.cpp%" 'c++-mode) + + ;; Shell scripts + (template "\\.z?sh$" "%%" 'sh-mode) + + ;; ;; ;; Ruby + (template "/spec_helper\\.rb$" "%helper%" 'rspec-mode t) + (template "_spec\\.rb$" "%%" 'rspec-mode t) + (template "/\\.rspec$" "%.rspec%" 'rspec-mode t) + (template "/Rakefile$" "%Rakefile%" 'ruby-mode t) + (template "/Gemfile$" "%Gemfile%" 'ruby-mode t) + ;; (template "\\.gemspec$" "%.gemspec%" 'ruby-mode t) + (template "/lib/.+\\.rb$" "%module%" 'ruby-mode t) + (template "\\.rb$" "%%" 'ruby-mode) + + ;; ;; ;; Python + ;; ;; (template "tests?/test_.+\\.py$" "%%" 'nose-mode) + ;; ;; (template "/setup\\.py$" "%setup%" 'python-mode) + (template "\\.py$" "%%" 'python-mode) + + ;; ;; ;; PHP + ;; ;; (template "\\.class\\.php$" "%class%" 'php-mode) + ;; ;; (template "\\.php$" "%%" 'php-mode) + + ;; ;; ;; Markdown + ;; (template "/README\\.md$" "%README.md%" 'markdown-mode) + ;; ;; (template "/_posts/.+\\.md$" "%jekyll-post" 'markdown-mode) + ;; ;; (template "/_layouts/.+\\.html$" "%jekyll-layout%" 'web-mode) + + ;; ;; ;; Javascript + ;; ;; (template "\\.lbaction/Contents/Info.plist$" "%lb6%" 'nxml-mode) + ;; ;; (template "\\.lbaction/.+/\\(default\\|suggestions\\)\\.js$" "%lb6%" 'js-mode) + ;; ;; (template "/package\\.json$" "%package.json%" 'json-mode) + ;; ;; (template "\\.\\(json\\|jshintrc\\)$" "%%" 'json-mode) + + ;; ;; ;; SCSS + ;; ;; (template "/master\\.scss$" "%master%" 'scss-mode) + ;; ;; (template "/normalize\\.scss$" "%normalize%" 'scss-mode) + ;; ;; (template "\\.scss$" "%%" 'scss-mode) + + ;; ;; ;; HTML + ;; ;; (template "\\.html$" "%%" 'web-mode) + + ;; ;; ;; Lua + ;; ;; (template "\\.love/main\\.lua$" "%love.main%" 'lua-mode) + ;; ;; (template "\\.love/conf\\.lua$" "%love.conf%" 'lua-mode) + ;; ;; (template "\\.lua$" "%%" 'lua-mode) + + ;; ;; ;; Java + ;; ;; (template "/src/.+/.+\\.java$ "%%" 'java-mode) + ;; ;; (template "\\.gradle$" "%%" 'groovy-mode) + + ;; ;; ;; Elisp + (template "\\.emacs\\.d/init/.+\\.el$" "%initfile%" 'emacs-lisp-mode) + (template "\\.emacs\\.d/snippets/.+$" "%%" 'snippet-mode)) diff --git a/init/init-cpp.el b/init/init-cpp.el index c75e4a6e6..c6fd933e6 100644 --- a/init/init-cpp.el +++ b/init/init-cpp.el @@ -38,7 +38,7 @@ (c-toggle-auto-newline -1) ;; DEL mapping interferes with smartparens and my.deflate-maybe - (defmap c-mode-map (kbd "DEL") nil) + (bind c-mode-map (kbd "DEL") nil) (c-set-offset 'substatement-open '0) ; brackets should be at same indentation level as the statements they open (c-set-offset 'inline-open '+) diff --git a/init/init-cscope.el b/init/init-cscope.el new file mode 100644 index 000000000..33bab2e6e --- /dev/null +++ b/init/init-cscope.el @@ -0,0 +1,9 @@ +(provide 'init-cscope) + +(use-package xcscope + :config + (progn + (cscope-setup) + (add-hook 'ruby-mode-hook (function cscope-minor-mode)) + + (push '("*cscope*" :position bottom) popwin:special-display-config))) diff --git a/init/init-csharp.el b/init/init-csharp.el index e43b5d12c..1f15059d7 100644 --- a/init/init-csharp.el +++ b/init/init-csharp.el @@ -12,7 +12,7 @@ ;; (use-package csharp-mode ;; :mode "\\.cs$" ;; :config -;; (imap csharp-mode-map (kbd "C-SPC") 'omnisharp-auto-complete)) +;; (bind 'insert csharp-mode-map (kbd "C-SPC") 'omnisharp-auto-complete)) ;; :init ;; (add-hook! 'csharp-mode-hook (omnisharp-mode t) (flycheck-mode t))) diff --git a/init/init-dev.el b/init/init-dev.el index d89836005..4f1ee6ed5 100644 --- a/init/init-dev.el +++ b/init/init-dev.el @@ -2,32 +2,24 @@ (use-package dash-at-point :commands (dash-at-point dash-at-point-with-docset) - :if is-mac - :config - (progn - (add-to-list 'dash-at-point-mode-alist '(ruby-mode . "rb")) - (add-to-list 'dash-at-point-mode-alist '(python-mode . "py3")))) + :if is-mac) (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)) + :init (add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode)) ;;; Config modes (use-package yaml-mode :defer t - :config - (add-hook 'yaml-mode-hook 'enable-tab-width-2)) + :config (add-hook 'yaml-mode-hook 'enable-tab-width-2)) (use-package json-mode :mode (("\\.json\\'" . json-mode) ("\\.jshintrc\\'" . json-mode))) + +(use-package hl-todo + :init (add-hook 'find-file-hook 'hl-todo-mode)) + +(use-package regex-tool + :commands regex-tool + :config (setq regex-tool-backend 'perl) + :init (add-hook 'regex-tool-mode-hook 'whitespace-newline-mode)) diff --git a/init/init-etags.el b/init/init-etags.el deleted file mode 100644 index 372e73c44..000000000 --- a/init/init-etags.el +++ /dev/null @@ -1,5 +0,0 @@ -(provide 'init-etags) - -;; (use-package ac-etags :config (ac-etags-setup)) - -;; Load etags solely for project navigation diff --git a/init/init-fly.el b/init/init-fly.el index 0a91a2705..3e15ece53 100644 --- a/init/init-fly.el +++ b/init/init-fly.el @@ -6,13 +6,9 @@ (setq-default flycheck-indication-mode 'right-fringe ;; Removed checks on idle/change for snappiness flycheck-check-syntax-automatically - '(save new-line mode-enabled) + '(save mode-enabled) flycheck-disabled-checkers - '(emacs-lisp emacs-lisp-checkdoc)) + '(emacs-lisp-checkdoc make)) (add-hook 'after-init-hook #'global-flycheck-mode))) -(use-package flyspell - :commands flyspell-mode - :config - (setq ispell-program-name "aspell" - ispell-list-command "--list")) +(use-package flyspell :commands flyspell-mode) diff --git a/init/init-git.el b/init/init-git.el index 527565da1..8c9c04d58 100644 --- a/init/init-git.el +++ b/init/init-git.el @@ -1,27 +1,73 @@ (provide 'init-git) (use-package git-commit-mode - :mode (("/COMMIT_EDITMSG\\'" . git-commit-mode) - ("/NOTES_EDITMSG\\'" . git-commit-mode) - ("/MERGE_MSG\\'" . git-commit-mode) - ("/TAG_EDITMSG\\'" . git-commit-mode) - ("/PULLREQ_EDITMSG\\'" . git-commit-mode))) + :mode (("/COMMIT_EDITMSG\\'" . git-commit-mode) + ("/NOTES_EDITMSG\\'" . git-commit-mode) + ("/MERGE_MSG\\'" . git-commit-mode) + ("/TAG_EDITMSG\\'" . git-commit-mode) + ("/PULLREQ_EDITMSG\\'" . git-commit-mode))) (use-package git-rebase-mode - :mode ("/git-rebase-todo\\'" . git-rebase-mode)) + :mode ("/git-rebase-todo\\'" . git-rebase-mode)) (use-package gitconfig-mode - :mode (("/\\.?git/?config\\'" . gitconfig-mode) - ("/\\.gitmodules\\'" . gitconfig-mode)) - :config - (add-hook 'gitconfig-mode-hook 'flyspell-mode)) + :mode (("/\\.?git/?config\\'" . gitconfig-mode) + ("/\\.gitmodules\\'" . gitconfig-mode)) + :config (add-hook 'gitconfig-mode-hook 'flyspell-mode)) (use-package gitignore-mode - :mode (("/\\.gitignore\\'" . gitignore-mode) - ("/\\.git/info/exclude\\'" . gitignore-mode) - ("/git/ignore\\'" . gitignore-mode))) + :mode (("/\\.gitignore\\'" . gitignore-mode) + ("/\\.git/info/exclude\\'" . gitignore-mode) + ("/git/ignore\\'" . gitignore-mode))) -(use-package git-gutter - :diminish git-gutter-mode - :init - (global-git-gutter-mode 1)) +(use-package git-gutter-fringe+ + :init (global-git-gutter+-mode +1) + :config + (progn + (fringe-helper-define 'git-gutter-fr+-added nil + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X.......") + + (fringe-helper-define 'git-gutter-fr+-deleted nil + "X......." + "XXXXXXXX" + "X......." + "........" + "........" + "........" + "........" + "........" + "........" + "........" + "........" + "........" + "........" + "........") + + (fringe-helper-define 'git-gutter-fr+-modified nil + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......." + "X......."))) diff --git a/init/init-go.el b/init/init-go.el new file mode 100644 index 000000000..6e5b6c389 --- /dev/null +++ b/init/init-go.el @@ -0,0 +1,7 @@ +(provide 'init-go) + +(use-package go-mode + :mode "\\.go\\'" + :interpreter "go" + :init + (require 'go-autocomplete)) diff --git a/init/init-ido.el b/init/init-ido.el index 38cf72064..7c0e1cec7 100644 --- a/init/init-ido.el +++ b/init/init-ido.el @@ -23,7 +23,6 @@ (ido-ubiquitous-mode 1) (flx-ido-mode 1) -(add-to-list 'ido-ignore-files "\\`.DS_Store\\'") (setq ido-use-faces nil ido-confirm-unique-completion t ido-case-fold t @@ -31,4 +30,11 @@ ido-enable-flex-matching t ido-create-new-buffer 'always ido-enable-tramp-completion t - ido-enable-last-directory-history t) + ido-enable-last-directory-history t + ido-save-directory-list-file (concat *tmp-dir "ido.last")) + +(add-to-list 'ido-ignore-files "\\`.DS_Store$") +(setq ido-ignore-buffers + '("\\` " "^\\*ESS\\*" "^\\*Messages\\*" "^\\*Help\\*" "^\\*Buffer" + "^\\*.*Completions\\*$" "^\\*Ediff" "^\\*tramp" "^\\*cvs-" + "_region_" " output\\*$" "^TAGS$" "^\*Ido")) diff --git a/init/init-eclim.el b/init/init-java.el similarity index 57% rename from init/init-eclim.el rename to init/init-java.el index b81ecce9c..083ffb05f 100644 --- a/init/init-eclim.el +++ b/init/init-java.el @@ -1,4 +1,4 @@ -(provide 'init-eclim) +(provide 'init-java) (use-package eclim :commands (eclim-mode global-eclim-mode) @@ -16,8 +16,15 @@ (use-package eclimd) (require 'ac-emacs-eclim-source) - (add-hook 'java-mode-hook 'ac-emacs-eclim-java-setup) + (add-hook! 'java-mode-hook + (setq ac-sources '(ac-source-emacs-eclim ac-source-yasnippet ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers))) (setq help-at-pt-display-when-idle t) (setq help-at-pt-timer-delay 0.1) - (help-at-pt-set-timer))) + (help-at-pt-set-timer) + + (bind 'motion java-mode-map "gd" 'eclim-java-find-declaration))) + +(use-package groovy-mode :mode "\\.gradle$" + :config + (add-to-list 'ac-modes 'groovy-mode)) diff --git a/init/init-love.el b/init/init-love.el index 81495a271..0e70905a7 100644 --- a/init/init-love.el +++ b/init/init-love.el @@ -4,7 +4,7 @@ (shell-command (format "open -a love.app %s" (my/project-root)))) (use-package lua-mode - :mode "\\.lua\\'" + :mode "\\.lua$" :interpreter "lua" :init (progn @@ -12,8 +12,7 @@ "Buffer local minor mode for Love2D" :init-value nil :lighter " <3" - :keymap (make-sparse-keymap) ; defines love-mode-map - :group lua) + :keymap (make-sparse-keymap)) (add-hook! 'lua-mode-hook (setq my-run-code-interpreter "lua") diff --git a/init/init-org.el b/init/init-org.el index 5ff65cf88..5eda5ee61 100644 --- a/init/init-org.el +++ b/init/init-org.el @@ -40,10 +40,10 @@ :keymap (make-sparse-keymap) ; defines evil-org-mode-map :group 'evil-org) -;; Reset evil to ensure certain evil keybindings are prioritized (add-hook 'org-mode-hook 'evil-org-mode) -(add-hook 'org-mode-hook 'flyspell-mode) -(add-hook 'org-mode-hook 'enable-hard-wrap) +(add-hook 'org-mode-hook 'turn-on-auto-fill) + +;; Reset evil to ensure evil-org-mode's maps work (add-hook! 'org-mode-hook (evil-mode nil) (evil-mode 1)) (shut-up (load-library "ox-opml")) @@ -114,3 +114,82 @@ ("tp" tags "+Projects") ("tg" tags-todo "+gamedev") ("tw" tags-tree "+webdev"))) + + +;; Keymaps +(bind 'insert org-mode-map [remap my.inflate-space-maybe] 'self-insert-command) +(bind org-mode-map (kbd "RET") nil + (kbd "C-j") nil + (kbd "C-k") nil) + +(mapc (lambda (state) + (evil-define-key state evil-org-mode-map + (kbd "M-l") 'org-metaright + (kbd "M-h") 'org-metaleft + (kbd "M-k") 'org-metaup + (kbd "M-j") 'org-metadown + (kbd "M-L") 'org-shiftmetaright + (kbd "M-H") 'org-shiftmetaleft + (kbd "M-K") 'org-shiftmetaup + (kbd "M-J") 'org-shiftmetadown + (kbd "M-o") '(lambda () (interactive) + (evil-org-eol-call + '(lambda() + (org-insert-heading) + (org-metaright)))) + (kbd "M-t") '(lambda () (interactive) + (evil-org-eol-call + '(lambda() + (org-insert-todo-heading nil) + (org-metaright)))) + )) + '(normal insert)) + +;; Formatting shortcuts +(bind 'insert evil-org-mode-map + (kbd "s-b") (λ (my/org-surround "*")) ; bold + (kbd "s-u") (λ (my/org-surround "_")) ; underline + (kbd "s-i") (λ (my/org-surround "/")) ; italics + (kbd "s-`") (λ (my/org-surround "+")) ; strikethrough + + (kbd "") (λ (evil-move-beginning-of-line) (org-insert-heading)) + (kbd "") (λ (org-insert-heading-after-current))) + +(bind '(normal visual) evil-org-mode-map + ",l" 'org-insert-link) + +(bind 'visual evil-org-mode-map + (kbd "s-b") "s*" ; bold + (kbd "s-i") "s/") ; italics + +(bind 'normal evil-org-mode-map + ",d" 'org-time-stamp + ",D" 'org-time-stamp-inactive + ",s" 'org-schedule + ",a" 'org-attach + ",A" 'org-attach-open + ",t" 'org-todo + ",T" 'org-show-todo-tree + ",/" 'org-sparse-tree + ",?" 'org-tags-view + ",+" 'org-align-all-tags + ",r" 'org-refile + "gh" 'outline-up-heading + "gj" 'org-forward-heading-same-level + "gk" 'org-backward-heading-same-level + "gl" 'outline-next-visible-heading + "go" 'org-open-at-point + "ga" 'org-agenda + "gt" 'org-show-todo-tree + "H" 'org-beginning-of-line + "L" 'org-end-of-line + "$" 'org-end-of-line + "^" 'org-beginning-of-line + "<" 'org-metaleft + ">" 'org-metaright + "-" 'org-cycle-list-bullet + (kbd ", SPC") 'org-archive-subtree + (kbd "") (λ (evil-move-beginning-of-line) (org-insert-heading) (evil-insert-state)) + (kbd "") (λ (org-insert-heading-after-current) (evil-insert-state)) + (kbd "RET") (λ (if (org-entry-is-todo-p) (org-todo 'done))) + (kbd "TAB") 'org-cycle) diff --git a/init/init-project.el b/init/init-project.el index 37f66b6e7..8f86509d9 100644 --- a/init/init-project.el +++ b/init/init-project.el @@ -1,32 +1,127 @@ (provide 'init-project) -(add-hook! 'dired-load-hook - (use-package dired+) - (setq dired-recursive-deletes 'always - dired-recursive-copies 'always - - ;; if there is a dired buffer displayed in the next window, use its - ;; current subdir, instead of the current subdir of this dired buffer - dired-dwim-target t)) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(use-package helm :defer t) -(use-package grizzl :defer t) - (use-package neotree :commands (neotree-show neotree-hide neotree-toggle)) -(use-package projectile - :diminish projectile-mode - :config - (progn (projectile-global-mode) - (setq projectile-completion-system 'grizzl))) - (use-package ag :commands (ag ag-search ag-regexp) :config - (setq ag-reuse-window t - ag-reuse-buffers t - ag-highlight-search t)) + (progn (setq ;ag-reuse-window nil + ag-reuse-buffers nil + ag-highlight-search t) + + (push '(ag-mode :position bottom :height 0.5 :stick t) popwin:special-display-config) + + ;; Close Ag on ESC + (bind ag-mode-map [escape] "q"))) + +(use-package dired + :init + (progn (setq dired-recursive-deletes 'always + dired-recursive-copies 'always + dired-auto-revert-buffer t + + ;; if there is a dired buffer displayed in the next + ;; window, use its current subdir, instead of the + ;; current subdir of this dired buffer + dired-dwim-target t) + + (push '(dired-mode :position bottom :height 0.5 :stick t) popwin:special-display-config) + + (add-hook! 'dired-mode-hook + (use-package 'dired+ :config (toggle-diredp-find-file-reuse-dir 1))))) + +(use-package projectile + :init + (progn (setq-default projectile-cache-file (concat *tmp-dir "projectile.cache")) + (setq-default projectile-known-projects-file (concat *tmp-dir "projectile.projects")) + (setq-default projectile-enable-caching t) + + (add-to-list 'projectile-globally-ignored-files "ido.last") + (add-to-list 'projectile-globally-ignored-directories "assets") + (add-to-list 'projectile-other-file-alist '("scss" "css")) + (add-to-list 'projectile-other-file-alist '("css" "scss")) + + (projectile-global-mode +1) + + (defvar persp-modestring-dividers '("" " |" ",")) + (use-package perspective) + (use-package persp-projectile) + (persp-mode 1))) + +(use-package helm + :pre-load (defvar helm-mode-line-string "") + :init + (progn + (use-package helm-ag :commands (helm-do-ag)) + (use-package helm-projectile) + (add-hook! 'scss-mode-hook (use-package helm-css-scss)) + + (push '("^\\*helm.+\\*$" :position bottom :regexp t :height 18) popwin:special-display-config) + + (setq helm-quick-update t + helm-idle-delay 0.01 + helm-input-idle-delay 0.01) + + (bind helm-map (kbd "C-w") 'evil-delete-backward-word) + + ;; All this for a smaller prompt (it was redundant with helm headers) + (defmacro helm-projectile-command (command source prompt) + `(defun ,(intern (concat "helm-projectile-" command)) (&optional arg) + (interactive "P") + (if (projectile-project-p) + (projectile-maybe-invalidate-cache arg)) + (let ((helm-ff-transformer-show-only-basename nil) + ;; for consistency, we should just let Projectile take care of ignored files + (helm-boring-file-regexp-list nil)) + (helm :sources ,source + :buffer "*helm projectile*" + :prompt ">>> ")))) + + (helm-projectile-command "switch-project" 'helm-source-projectile-projects ">>> ") + (helm-projectile-command "find-file" helm-source-projectile-files-and-dired-list ">>> ") + (helm-projectile-command "find-file-in-known-projects" 'helm-source-projectile-files-in-all-projects-list ">>> ") + (helm-projectile-command "find-file-dwim" 'helm-source-projectile-files-dwim-list ">>> ") + (helm-projectile-command "find-dir" helm-source-projectile-directories-and-dired-list ">>> ") + (helm-projectile-command "recentf" 'helm-source-projectile-recentf-list ">>> ") + (helm-projectile-command "switch-to-buffer" 'helm-source-projectile-buffers-list ">>> ") + + ;; Hide the mode-line in helm (<3 minimalism) + (defun helm-display-mode-line (source &optional force) + "Setup mode-line and header-line for `helm-buffer'." + (set (make-local-variable 'helm-mode-line-string) + (helm-interpret-value (or (and (listp source) ; Check if source is empty. + (assoc-default 'mode-line source)) + (default-value 'helm-mode-line-string)) + source)) + (let ((follow (and (eq (cdr (assq 'follow source)) 1) "(HF) "))) + ;; Setup mode-line. + (if helm-mode-line-string + (setq mode-line-format nil) + (setq mode-line-format (default-value 'mode-line-format))) + ;; Setup header-line. + (let* ((hlstr (helm-interpret-value + (and (listp source) + (assoc-default 'header-line source)) + source)) + (hlend (make-string (max 0 (- (window-width) (length hlstr))) ? ))) + (setq header-line-format + (propertize (concat " " hlstr hlend) 'face 'helm-header)))) + (when force (force-mode-line-update))) + + ;; No persistent header + (defadvice helm-display-mode-line (after undisplay-header activate) + (setq header-line-format nil)))) + +;; For setting project-specific settings +(defmacro project-settings (name &rest body) + (declare (indent 1)) + `(progn + (add-hook 'find-file-hook + (lambda () + (when (string-match-p ,name (buffer-file-name)) + ,@body))) + (add-hook 'dired-after-readin-hook + (lambda () + (when (string-match-p ,name (dired-current-directory)) + ,@body))))) diff --git a/init/init-python.el b/init/init-python.el index b0b0cb71e..dd9727925 100644 --- a/init/init-python.el +++ b/init/init-python.el @@ -3,30 +3,41 @@ (use-package python :mode ("\\.py\\'" . python-mode) :interpreter ("python" . python-mode) - :init - (setq python-indent-offset 4) + :init (setq python-indent-offset 4) :config (progn - (use-package jedi) - - (unless (file-directory-p "~/.emacs.d/.python-environments/default/") - (jedi:install-server)) - - (add-hook 'python-mode-hook 'jedi:ac-setup) + (setq python-environment-directory *tmp-dir) (setq python-shell-interpreter "ipython") - ;; Interferes with smartparens - (defmap python-mode-map (kbd "DEL") nil) - (add-hook! 'python-mode-hook (setq my-switch-to-repl-func 'python-shell-switch-to-shell my-send-region-to-repl-func 'python-shell-send-region my-run-code-interpreter "python")) + ;; Interferes with smartparens + (bind python-mode-map (kbd "DEL") nil) + (bind 'motion python-mode-map "gd" 'jedi:goto-definition) + + (use-package jedi + :config + (progn + (unless (file-directory-p python-environment-directory) + (jedi:install-server)) + (add-hook 'python-mode-hook 'jedi:ac-setup))) + (use-package nose :commands (nose-mode) :init (progn ;; Reset nose keymap, we'll set new ones in my-keymaps.el (defvar nose-mode-map (make-sparse-keymap)) - (associate-minor-mode "/test_.+\\.py\\'" nose-mode))))) + (associate-minor-mode "/test_.+\\.py\\'" nose-mode)) + :config + (bind 'normal nose-mode-map + ",tr" 'nosetests-again + ",ta" 'nosetests-all + ",ts" 'nosetests-one + ",tv" 'nosetests-module + ",tA" 'nosetests-pdb-all + ",tO" 'nosetests-pdb-one + ",tV" 'nosetests-pdb-module)))) diff --git a/init/init-ruby.el b/init/init-ruby.el index 105365f61..f60412728 100644 --- a/init/init-ruby.el +++ b/init/init-ruby.el @@ -1,8 +1,5 @@ (provide 'init-ruby) -(defun ac-add-ruby-rsense () - (setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources))) - ;; (use-package ruby-mode :mode (("\\.rb$" . ruby-mode) @@ -17,14 +14,18 @@ :interpreter "ruby" :config (progn + (define-minor-mode rake-mode + "Buffer local minor mode for rake files" + :lighter " Rake") + (use-package inf-ruby :config (progn (evil-set-initial-state 'inf-ruby-mode 'insert) - (use-package ac-inf-ruby) - (add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable)) - :init - (add-to-list 'ac-modes 'inf-ruby-mode)) + ;; (use-package ac-inf-ruby) + ;; (add-hook 'inf-ruby-mode-hook 'ac-inf-ruby-enable) + + (push '(inf-ruby-mode :position bottom :stick t) popwin:special-display-config))) (use-package rspec-mode :defer t @@ -38,15 +39,34 @@ (("task" "namespace") () "end") )) :init - (associate-minor-mode "_spec\\.rb\\'" rspec-mode)) + (progn (associate-minor-mode "\\(/spec_helper\\|_spec\\)\\.rb$" rspec-mode) + (associate-minor-mode "/\\.rspec$" rspec-mode) + (associate-minor-mode "/\\.rake$" rake-mode) + (associate-mode "/\\.rspec$" text-mode)) + :config + (progn (bind 'normal rspec-mode-verifiable-keymap + ",tr" 'rspec-rerun + ",ta" 'rspec-verify-all + ",ts" 'rspec-verify-single + ",tv" 'rspec-verify) + (bind 'normal rspec-dired-mode-keymap + ",tv" 'rspec-dired-verify + ",ts" 'rspec-dired-verify-single + ",ta" 'rspec-verify-all + ",tr" 'rspec-rerun))) - ;;; Auto-completion - ;; 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 'ac-add-ruby-rsense)) + (use-package robe + :config + (progn + (add-hook! 'after-save-hook + (when (and (eq major-mode 'ruby-mode) + (bound-and-true-p robe-running)) + (ruby-load-file (buffer-file-name)))) + (add-hook! 'ruby-mode-hook + (robe-mode 1) + (ac-robe-setup) + (unless robe-running (robe-start 1)) + (ruby-load-file (buffer-file-name))))) (add-hook! 'ruby-mode-hook (setq my-switch-to-repl-func 'ruby-switch-to-inf @@ -57,11 +77,3 @@ (setq ruby-indent-level 2) (setq ruby-deep-indent-paren t) (add-hook 'ruby-mode-hook 'enable-tab-width-2))) - -;; (add-hook! 'find-file-hook -;; (let ((rake-path -;; (f--traverse-upwards (f--exists? "Rakefile" it)))) -;; (when rake-path -;; (use-package rake-mode) -;; (rake-mode t) -;; (rake-mode/visit-rakefile (expand-file-name "Rakefile" rake-path) t)))) diff --git a/init/init-sh.el b/init/init-sh.el new file mode 100644 index 000000000..93dd78b1b --- /dev/null +++ b/init/init-sh.el @@ -0,0 +1,4 @@ +(provide 'init-sh) + +;; Make shell scrips executable on save. Good! +(add-hook 'after-save-hook 'executable-make-buffer-file-executable-if-script-p) diff --git a/init/init-snippets.el b/init/init-snippets.el index cb10cd59b..96f0f334c 100644 --- a/init/init-snippets.el +++ b/init/init-snippets.el @@ -1,41 +1,45 @@ (provide 'init-snippets) (use-package yasnippet - :mode (("emacs.+/snippets/" . snippet-mode)) - :pre-load - (progn - ;; Fix yasnippet keymaps so they only work in insert mode (why they - ;; had to make this so complicated I don't know); must be defined - ;; BEFORE we include yasnippet. - (defvar yas-minor-mode-map - (let ((map (make-sparse-keymap))) - (imap map [(tab)] 'yas-expand) - (imap map (kbd "TAB") 'yas-expand) - map))) - :config - (progn - (defadvice evil-force-normal-state (before evil-esc-quit-yasnippet activate) - (shut-up (yas-exit-all-snippets))) + :mode (("emacs\\.d/.+/snippets/" . snippet-mode)) + :pre-load + (progn + ;; Fix yasnippet keymaps so they only work in insert mode (why they + ;; had to make this so complicated I don't know); must be defined + ;; BEFORE we include yasnippet. + (defvar yas-minor-mode-map + (let ((map (make-sparse-keymap))) + (bind 'insert map [(tab)] 'yas-expand) + (bind 'insert map (kbd "TAB") 'yas-expand) + (bind 'visual map (kbd "") 'yas-insert-snippet) + map))) + :config + (progn + (defadvice evil-force-normal-state (before evil-esc-quit-yasnippet activate) + (shut-up (yas-exit-all-snippets))) - ;; Only load personal snippets - (setq yas-snippet-dirs `(,*snippets-dir)) - (setq yas-prompt-functions '(yas-ido-prompt yas-no-prompt)) + ;; Only load personal snippets + (setq yas-snippet-dirs `(,*snippets-dir)) + (setq yas-prompt-functions '(yas-ido-prompt yas-no-prompt)) + (setq yas-also-auto-indent-first-line t) - (after auto-complete - (add-hook! 'yas-before-expand-snippet-hook (auto-complete-mode -1)) - (add-hook! 'yas-after-exit-snippet-hook (auto-complete-mode t)) - (defadvice ac-expand (before advice-for-ac-expand activate) - (when (yas-expand) (ac-stop)))) + (after auto-complete + ;; (add-hook! 'yas-before-expand-snippet-hook (auto-complete-mode -1)) + ;; (add-hook! 'yas-after-exit-snippet-hook (auto-complete-mode t)) + (defadvice ac-expand (before advice-for-ac-expand activate) + (when (yas-expand) (ac-stop)))) - (defmap yas-keymap (kbd "DEL") 'my/yas-clear-field) + (bind yas-keymap (kbd "DEL") 'my/yas-clear-field) - (yas-reload-all)) - :init - (progn - (add-hook 'prog-mode-hook 'yas-minor-mode) - (add-hook 'snippet-mode-hook 'yas-minor-mode) - (add-hook 'markdown-mode-hook 'yas-minor-mode) - (add-hook 'org-mode-hook 'yas-minor-mode))) + (yas-reload-all)) + :init + (progn + (add-hook 'snippet-mode-hook 'disable-final-newline) + (add-hook 'text-mode-hook 'yas-minor-mode) + (add-hook 'prog-mode-hook 'yas-minor-mode) + (add-hook 'snippet-mode-hook 'yas-minor-mode) + ;; (add-hook 'markdown-mode-hook 'yas-minor-mode) + (add-hook 'org-mode-hook 'yas-minor-mode))) ;; Prevents Yas from stepping on my toes when I use backspace (defun my/yas-clear-field (&optional field) @@ -49,3 +53,10 @@ (eq (point) (marker-position (yas--field-start field)))) (yas--skip-and-clear field)) (t (delete-char -1))))) + +;; yas snippet helpers +(defvaralias '% 'yas-selected-text) +(defun %! () (if % (s-trim-right %))) +(defun !% () (if % (s-trim-left %))) +(defun !%! () (if % (s-trim %))) +(defun --newline-maybe () (if % "\n")) diff --git a/init/init-swift.el b/init/init-swift.el new file mode 100644 index 000000000..7d3e23c15 --- /dev/null +++ b/init/init-swift.el @@ -0,0 +1,5 @@ +(provide 'init-swift) + +;; (use-package swift-mode) + +;; TODO: Set up emacs task runners for fruitstrap diff --git a/init/init-text.el b/init/init-text.el index 5d3c6e877..0d740d1c5 100644 --- a/init/init-text.el +++ b/init/init-text.el @@ -1,5 +1,8 @@ (provide 'init-text) +(add-hook 'text-mode-hook 'turn-on-auto-fill) +(add-hook 'prog-mode-hook 'enable-comment-hard-wrap) + (use-package markdown-mode :mode (("\\.md\\'" . markdown-mode) ("/README\\'" . markdown-mode)) @@ -19,4 +22,28 @@ ;; Bold markup removal, bold word at point, or empty markup insertion (if (thing-at-point-looking-at markdown-regex-del) (markdown-unwrap-thing-at-point nil 2 4) - (markdown-wrap-or-insert delim delim 'word nil nil))))))) + (markdown-wrap-or-insert delim delim 'word nil nil)))))) + :config + (let ((map markdown-mode-map)) + (bind '(normal visual) map + ",i" 'markdown-insert-image + ",l" 'markdown-insert-link + ",L" 'markdown-insert-reference-link-dwim + ",b" 'markdown-preview) + + (bind 'normal map + "[p" 'markdown-promote + "]p" 'markdown-demote) + + (bind 'insert map + (kbd "M--") 'markdown-insert-hr) + + (bind map + (kbd "") nil + (kbd "") nil + (kbd "") nil + + (kbd "s-*") 'markdown-insert-list-item + (kbd "s-b") 'markdown-insert-bold + (kbd "s-i") 'markdown-insert-italic + (kbd "s-`") 'markdown-insert-del))) diff --git a/init/init-webdev.el b/init/init-webdev.el index d0d3e3368..e858a3330 100644 --- a/init/init-webdev.el +++ b/init/init-webdev.el @@ -3,53 +3,85 @@ (use-package rainbow-mode :defer t :init - (add-hook 'scss-mode 'rainbow-mode)) + (progn + (add-hook 'scss-mode-hook 'rainbow-mode) + (add-hook 'sass-mode-hook 'rainbow-mode))) + +(use-package sass-mode + :mode "\\.sass$" + :init (add-hook 'sass-mode-hook 'enable-tab-width-2) + :config + (progn + (add-hook 'sass-mode-hook 'ac-css-mode-setup) + + (add-to-list 'ac-modes 'sass-mode) + (setq-default css-indent-offset 2))) (use-package scss-mode - :mode "\\.scss\\'" + :mode "\\.scss$" + :init (add-hook 'scss-mode-hook 'enable-tab-width-2) :config (progn - (setq scss-compile-at-save nil) - (add-hook 'scss-mode-hook 'ac-css-mode-setup))) + (add-hook 'scss-mode-hook 'ac-css-mode-setup) -(use-package haml-mode :mode "\\.haml\\'") + (add-to-list 'ac-modes 'scss-mode) + (setq-default css-indent-offset 2) + (setq scss-compile-at-save nil) + + (bind '(normal visual) scss-mode-map "gQ" 'web-beautify-css))) ;;; HTML/Markup -(use-package emmet-mode - :defer t - :config - (setq emmet-move-cursor-between-quotes t) - :init - (progn - (add-hook 'scss-mode-hook 'emmet-mode) - (add-hook 'web-mode-hook 'emmet-mode) - (add-hook 'html-mode-hook 'emmet-mode) - (add-hook 'haml-mode-hook 'emmet-mode) - (add-hook 'nxml-mode-hook 'emmet-mode))) +(use-package haml-mode :mode "\\.haml$") (use-package web-mode - :mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode) - ("\\.tpl\\(\\.php\\)?\\'" . web-mode) - ("\\.erb\\'" . web-mode) - ("wp-content/themes/.+/.+\\.php\\'" . web-mode)) + :mode (("\\.\\(p\\)?htm\\(l\\)?$" . web-mode) + ("\\.tpl\\(\\.php\\)?$" . web-mode) + ("\\.erb$" . web-mode) + ("wp-content/themes/.+/.+\\.php$" . web-mode)) :config (progn - (setq web-mode-ac-sources-alist - '(("css" . (ac-source-css-property)))) + (add-hook 'web-mode-hook 'enable-tab-width-2) - (setq web-mode-markup-indent-offset 2 + (setq web-mode-ac-sources-alist + '(("css" . (ac-source-css-property))) + web-mode-markup-indent-offset 2 web-mode-code-indent-offset 2 web-mode-css-indent-offset 2 web-mode-style-padding 2 web-mode-script-padding 2 web-mode-block-padding 2) - (add-hook 'web-mode-hook 'enable-tab-width-2))) + (bind web-mode-map (kbd "s-/") 'web-mode-comment-or-uncomment) + (bind 'normal web-mode-map + "zf" 'web-mode-fold-or-unfold + ",t" 'web-mode-element-rename) + (bind '(normal visual) web-mode-map + "gQ" 'web-beautify-html + "]a" 'web-mode-attribute-next + "]t" 'web-mode-tag-next + "[t" 'web-mode-tag-previous + "]T" 'web-mode-element-child + "[T" 'web-mode-element-parent))) + +(use-package emmet-mode + :defer t + :init + (progn + (add-hook 'scss-mode-hook 'emmet-mode) + (add-hook 'web-mode-hook 'emmet-mode) + (add-hook 'html-mode-hook 'emmet-mode) + (add-hook 'haml-mode-hook 'emmet-mode) + (add-hook 'nxml-mode-hook 'emmet-mode)) + :config + (progn + (setq emmet-move-cursor-between-quotes t) + + (bind 'insert emmet-mode-keymap + (kbd "s-e") 'emmet-expand-yas + (kbd "s-E") 'emmet-expand-line))) (use-package php-mode - :mode (("\\.php\\'" . php-mode) - ("\\.inc\\'" . php-mode)) - :interpreter "php" + :mode "\\.\\(php\\|inc\\)$" :config (progn (add-hook! 'php-mode-hook (setq my-run-code-interpreter "php")) @@ -60,18 +92,36 @@ :commands tern-mode :config (progn - (use-package tern-auto-complete - :config (setq tern-ac-on-dot nil))) - :init + (require 'tern-auto-complete) + + (setq tern-ac-on-dot nil))) + +(use-package js2-mode :mode "\\.js$" + :config + (progn + (use-package js2-refactor + :config + ;; TODO Set up keymaps + ) + (setq-default js2-show-parse-errors nil) + (setq-default js2-global-externs '("module" "require" "buster" "sinon" "assert" "refute" "setTimeout" "clearTimeout" "setInterval" "clearInterval" "location" "__dirname" "console" "JSON" "jQuery" "$" + ;; Launchbar API + "LaunchBar" "File" "Action" "HTTP" "include")) + + (bind 'insert js2-mode-map [remap auto-complete] 'tern-ac-complete) + (bind 'motion js2-mode-map "gd" 'tern-find-definition) + (bind '(normal visual) js2-mode-map "gQ" 'web-beautify-js)) + ;; replace auto-complete with tern-ac-complete only in js-mode - (add-hook! 'js-mode-hook - (tern-mode t) - (tern-ac-setup) - (setq my-run-code-interpreter "node"))) + :init (add-hook! 'js2-mode-hook + (tern-mode t) + (tern-ac-setup) + (setq my-run-code-interpreter "node"))) -;; Jekyll support -(define-minor-mode jekyll-mode - :init-value nil - :lighter " :{") - -(associate-minor-mode "[.-]jekyll/" jekyll-mode) +(use-package web-beautify + :commands (web-beautify-js web-beautify-css web-beautify-html) + :config + (progn + (add-hook! 'scss-mode-hook (setenv "jsbeautify_indent_size" "2")) + (add-hook! 'web-mode-hook (setenv "jsbeautify_indent_size" "4")) + (add-hook! 'js2-mode-hook (setenv "jsbeautify_indent_size" "4")))) diff --git a/init/defuns/coderunner.el b/init/my-coderunner.el similarity index 98% rename from init/defuns/coderunner.el rename to init/my-coderunner.el index e55338df2..27d6a7126 100644 --- a/init/defuns/coderunner.el +++ b/init/my-coderunner.el @@ -1,3 +1,5 @@ +(provide 'my-coderunner) + ;; Variables (defvar my-run-code-interpreter nil) (defvar my-run-code-func 'my/run-code-shell) @@ -27,6 +29,7 @@ (shell-command-on-region beg end my-run-code-interpreter) (message "No interpreter set for %s. See `my-run-code-interpreter'" (symbol-name major-mode)))) +;; (defun my:switch-to-repl () (interactive) (if (functionp my-switch-to-repl-func) diff --git a/init/my-commands.el b/init/my-commands.el index 2f25c1d0d..62f27747b 100644 --- a/init/my-commands.el +++ b/init/my-commands.el @@ -1,10 +1,6 @@ (provide 'my-commands) ;;;; Defun Commands ;;;;;;;;;;;;;;;;;;;; -(defun my:git-gutter-refresh () - (interactive) - (git-gutter+-refresh)) - (defun my:minibuffer-quit () "Abort recursive edit. In Delete Selection mode, if the mark is active, just deactivate it; then it takes a second \\[keyboard-quit] @@ -15,62 +11,32 @@ to abort the minibuffer." (when (get-buffer "*Completions*") (delete-windows-on "*Completions*")) (abort-recursive-edit))) -;; File navigation defuns -(defun my:goto-symbol (&optional symbol-list) - "Refresh imenu and jump to a place in the buffer using Ido." - (interactive) - (unless (featurep 'imenu) - (require 'imenu nil t)) - (cond - ((not symbol-list) - (let ((ido-mode ido-mode) - (ido-enable-flex-matching - (if (boundp 'ido-enable-flex-matching) - ido-enable-flex-matching t)) - name-and-pos symbol-names position) - (unless ido-mode - (ido-mode 1) - (setq ido-enable-flex-matching t)) - (while (progn - (imenu--cleanup) - (setq imenu--index-alist nil) - (my:goto-symbol (imenu--make-index-alist)) - (setq selected-symbol - (ido-completing-read "Symbol? " symbol-names)) - (string= (car imenu--rescan-item) selected-symbol))) - (unless (and (boundp 'mark-active) mark-active) - (push-mark nil t nil)) - (setq position (cdr (assoc selected-symbol name-and-pos))) - (cond - ((overlayp position) - (goto-char (overlay-start position))) - (t - (goto-char position))))) - ((listp symbol-list) - (dolist (symbol symbol-list) - (let (name position) - (cond - ((and (listp symbol) (imenu--subalist-p symbol)) - (my:goto-symbol symbol)) - ((listp symbol) - (setq name (car symbol)) - (setq position (cdr symbol))) - ((stringp symbol) - (setq name symbol) - (setq position - (get-text-property 1 'org-imenu-marker symbol)))) - (unless (or (null position) (null name) - (string= (car imenu--rescan-item) name)) - (add-to-list 'symbol-names name) - (add-to-list 'name-and-pos (cons name position)))))))) - ;; Buffer defuns -(defun my:kill-dired-buffers () - (interactive) - (mapc (lambda (buffer) - (when (eq 'dired-mode (buffer-local-value 'major-mode buffer)) - (kill-buffer buffer))) - (buffer-list))) +(defun my:kill-other-buffers () + "Kill left-over temporary, dired or buried special buffers" + (interactive) + (mapc (lambda (buffer) + (let ((buffer-name (buffer-name buffer))) + (when (and (not (s-matches? buffer-name "\\*\\(scratch\\|Messages\\)\\*")) + (or (eq 'dired-mode (buffer-local-value 'major-mode buffer)) + (s-matches? "^ ?\\*.+\\*$" buffer-name)) + (not (get-buffer-window buffer))) + (kill-buffer buffer)))) + (buffer-list))) + +;; Inspired by http://demonastery.org/2013/04/emacs-evil-narrow-region/ +(defun my:narrow-to-region-indirect (start end) + "Restrict editing in this buffer to the current region, indirectly." + (interactive "r") + (deactivate-mark) + (let ((buf (clone-indirect-buffer nil nil))) + (with-current-buffer buf + (narrow-to-region start end)) + (switch-to-buffer buf))) + +(defun my:kill-persp () + (interactive) + (persp-kill (persp-name persp-curr))) ;;;; Tmux defuns ;;;;;;;;;;;;;;;;; (defun my:tmux-send (command) @@ -86,7 +52,7 @@ to abort the minibuffer." (stringp appName) (not (string= "" appName))) (setq appName (concat "-a " appName ".app"))) - (shell-command (concat "open " appName " " (shell-quote-argument path)))) + (async-shell-command (concat "open " appName " " (shell-quote-argument path)))) (defun my:open-with (appName) (interactive "sApp name: ") @@ -102,58 +68,44 @@ to abort the minibuffer." ;; Ex-commands ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(evil-define-command my:ex:msg-buffer () :repeat nil - (interactive) - (view-echo-area-messages) - (switch-to-buffer-other-window "*Messages*") - ;; Force text-mode for unfettered evil-mode & my keymappings - (text-mode)) - -(evil-define-command my:ex:kill-buffers (&optional bang) :repeat nil +(evil-define-command ex:kill-buffers (&optional bang) :repeat nil (interactive "") - (let ((buffers (if bang - (cdr (buffer-list (current-buffer))) - (buffer-list)))) - (delete-other-windows) - (tags-reset-tags-tables) - (mapc 'kill-buffer buffers))) + (if (and bang (projectile-project-p)) + (projectile-kill-buffers) + (mapc 'kill-buffer (buffer-list))) + (delete-other-windows)) -(evil-define-command my:ex:init-files (&optional bang) :repeat nil +(evil-define-command ex:init-files (&optional bang) :repeat nil (interactive "") (if bang (ido-find-file-in-dir *init-dir) (ido-find-file-in-dir *dir))) -(evil-define-command my:ex:notes () :repeat nil +(evil-define-command ex:notes () :repeat nil (interactive) (ido-find-file-in-dir org-directory)) -(evil-define-command my:ex:snippets (&optional bang) :repeat nil - (interactive "") - (if bang - (yas-new-snippet) - (yas-visit-snippet-file))) - ;; Projects -(evil-define-command my:ex:ag-search (search &optional bang) :repeat nil +(evil-define-command ex:ag-search (search &optional bang regex) :repeat nil (interactive "") (let ((root (my/project-root bang))) - (ag search root))) + (if search + (if regex (ag-regexp search root) (ag search root)) + (helm-do-ag root)))) -(evil-define-command my:ex:ag-regex-search (search &optional bang) :repeat nil +(evil-define-command ex:ag-regex-search (search &optional bang) :repeat nil (interactive "") - (let ((root (my/project-root bang))) - (ag-regexp search root))) + (ex:ag-search search bang t)) ;; Run a command. If , then only type command into tmux -(evil-define-command my:ex:tmux-send (command &optional bang) :repeat nil +(evil-define-command ex:tmux-send (command &optional bang) :repeat nil (interactive "") (let ((cmd-format (if bang "%s" "C-u %s Enter"))) (my:tmux-send (format cmd-format (shell-quote-argument command))) (when (evil-ex-p) (message "[Tmux] %s" command)))) -(evil-define-command my:ex:tmux-chdir (&optional path bang) :repeat nil +(evil-define-command ex:tmux-chdir (&optional path bang) :repeat nil (interactive "") (let ((dir (shell-quote-argument (if (and path @@ -161,36 +113,65 @@ to abort the minibuffer." (file-directory-p path)) (file-truename path) (my/project-root bang))))) - (my:ex:tmux-run (format "cd %s" dir)) + (ex:tmux-send (format "cd %s" dir)) (when (evil-ex-p) (message "[Tmux] cd %s" dir)))) -(evil-define-command my:ex:byte-compile-all (&optional bang) :repeat nil +(evil-define-command ex:byte-compile-all (&optional bang) :repeat nil (interactive "") - (byte-recompile-file (expand-file-name "init.el" *dir) bang 0) - (byte-recompile-directory *init-dir 0 bang) - (byte-recompile-directory *elisp-dir 0 bang)) + (require 'async-bytecomp) + ;; (async-byte-recompile-directory *dir 0 bang) + (byte-recompile-directory *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)))) - -(evil-define-command my:ex:build (arguments &optional bang) :repeat nil +(evil-define-command ex:build (arguments &optional bang) :repeat nil (interactive "") (my:build arguments)) -(evil-define-command my:ex:cd (dir) :repeat nil +(evil-define-command ex:cd (dir) :repeat nil (interactive "") (cd (if (zerop (length dir)) "~" dir))) +(defun --save-exit() (save-buffer) (kill-buffer) (remove-hook 'yas-after-exit-snippet-hook '--save-exit)) +(evil-define-command ex:create-file (path &optional bang) :repeat nil + "Deploy files (and their associated templates) quickly. Will prompt +you to fill in each snippet field before buffer closes unless BANG is +provided." + (interactive "") + (let ((dir (f-dirname path)) + (fullpath (f-full path)) + (is-auto t)) + (when (and bang (not (f-exists? dir))) (f-mkdir dir)) + (if (f-exists? dir) + (if (f-exists? fullpath) + (error "File already exists: %s" path) + (find-file fullpath) + (add-hook 'yas-after-exit-snippet-hook '--save-exit) + (if bang (--save-exit))) + (error "Directory doesn't exist: %s" dir)))) + +(evil-define-command ex:rename-this-file (new-name &optional bang) :repeat nil + "Renames current buffer and file it is visiting." + (interactive "") + (let ((name (buffer-name)) + (filename (buffer-file-name))) + (if (not (and filename (file-exists-p filename))) + (error "Buffer '%s' is not visiting a file!" name) + (let ((new-name (if new-name new-name (read-file-name "New name: " filename)))) + (if (get-buffer new-name) + (error "A buffer named '%s' already exists!" new-name) + (rename-file filename new-name 1) + (rename-buffer new-name) + (set-visited-file-name new-name) + (set-buffer-modified-p nil) + (when bang + (delete-file filename)) + (message "File '%s' successfully renamed to '%s'" + name (file-name-nondirectory new-name))))))) + ;;; -(evil-define-operator my:ex:scratch-buffer (beg end) - :motion nil +(evil-define-operator ex:scratch-buffer (beg end) :move-point nil :type inclusive - :repeat nil (interactive "") (let ((mode major-mode) (text (when (and beg end) (buffer-substring beg end)))) @@ -198,11 +179,9 @@ to abort the minibuffer." (if text (insert text)) (funcall mode))) -(evil-define-operator my:ex:org-capture (beg end) - :motion nil +(evil-define-operator ex:org-capture (beg end) :move-point nil :type inclusive - :repeat nil (interactive "") (let ((mode major-mode) (text (when (and beg end) (buffer-substring beg end)))) @@ -210,7 +189,7 @@ to abort the minibuffer." (org-capture-string text) (org-capture)))) -(evil-define-operator my:ex:retab (beg end) +(evil-define-operator ex:retab (beg end) :motion nil :move-point nil :type line @@ -224,18 +203,15 @@ spaces-to-tabs, depending on `indent-tab-mode'. Untested." (tabify beg end) (untabify beg end))) -(evil-define-operator my:ex:run-code (beg end) :repeat nil - :motion nil +(evil-define-operator ex:run-code (beg end) :move-point nil - :type exclusive - :repeat nil (interactive "") (cond ((and beg end) (my:run-code-region beg end)) (t (my:run-code-buffer)))) -(evil-define-operator my:ex:send-region-to-repl (beg end &optional bang) :repeat nil +(evil-define-operator ex:send-region-to-repl (beg end &optional bang) :motion nil :move-point nil :type exclusive @@ -245,3 +221,28 @@ spaces-to-tabs, depending on `indent-tab-mode'. Untested." (my:send-region-to-repl beg end)) (t (my:switch-to-repl)))) + +(evil-define-operator ex:snippets (beg end &optional name) + :motion nil + :move-point nil + :type exclusive + :repeat nil + "Create a new snippet (called `name'), or select from all the + current mode's snippets to edit." + (interactive "") + (cond ((and beg end) + (yas-insert-snippet)) + (t + (if name + (find-file (concat *snippets-dir (symbol-name major-mode) "/" name)) + (yas-visit-snippet-file))))) + +(evil-define-operator ex:narrow-indirect (beg end) + :motion nil + :move-point nil + :type exclusive + :repeat nil + "Indirectly narrow the region from BEG to END." + (interactive "") + (evil-normal-state) + (narrow-to-region-indirect beg end)) diff --git a/init/my-defuns.el b/init/my-defuns.el deleted file mode 100644 index d13577b51..000000000 --- a/init/my-defuns.el +++ /dev/null @@ -1,8 +0,0 @@ -(provide 'my-defuns) - -(shut-up - (load "defuns/utility") - (load "defuns/config") - (load "defuns/text") - (load "defuns/hooks") - (load "defuns/coderunner")) diff --git a/init/my-keymaps.el b/init/my-keymaps.el index 3c9b7bf21..869efeb8f 100644 --- a/init/my-keymaps.el +++ b/init/my-keymaps.el @@ -4,160 +4,168 @@ ;; Global keymaps ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(global-set-key (kbd "M-x") 'smex) -(global-set-key (kbd "M-X") 'smex-major-mode-commands) -(global-set-key (kbd "C-:") 'eval-expression) -(global-set-key (kbd "C-j") "5j") -(global-set-key (kbd "C-k") "5k") +(bind (kbd "M-x") 'smex + (kbd "M-X") 'smex-major-mode-commands + (kbd "C-;") 'eval-expression + (kbd "C-`") 'popwin:popup-last-buffer -(when is-mac - (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) + (kbd "s-=") 'text-scale-increase + (kbd "s--") 'text-scale-decrease + (kbd "s-w") 'evil-window-delete + (kbd "s-/") 'evilnc-comment-or-uncomment-lines + (kbd "s-") 'toggle-frame-fullscreen) - ;; 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)) +;; Faster scrolling +(bind '(normal visual) + (kbd "s-j") "7j" + (kbd "s-k") "7k" + (kbd "s-r") 'my:run-code-buffer + (kbd "s-R") 'my:switch-to-repl) - (nmap! (kbd "s-t") 'projectile-find-file - (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-b") 'my:ex:build) +(bind 'normal (kbd "s-t") 'projectile-find-file + (kbd "s-T") 'projectile-find-tag + (kbd "s-p") 'projectile-switch-project + (kbd "s-P") 'persp-switch + (kbd "s-f") 'projectile-ag + (kbd "s-S-f") 'helm-do-ag + (kbd "s-m") ",m" + (kbd "s-M") ",M" + (kbd "s-o") 'ido-find-file + (kbd "s-d") 'dash-at-point) - (nvmap! (kbd "s-r") ",r" - (kbd "s-R") ",R"))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Local keymaps ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use -;; define-key instead of n/vmap for this one to register. -(-nvmap ";" 'evil-ex) -(-nvmap "X" 'evil-exchange) +(bind 'god + ;; + ":" 'linum-mode + "\\" 'neotree-toggle + "=" 'toggle-transparency -;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;; -(nmap! ",r" 'my:run-code-buffer - ",R" 'my:switch-to-repl - ",b" 'my:build - ",a" 'projectile-find-other-file - ",e" 'ido-find-file - ",E" 'my:ex:init-files - ",m" 'my:ex:mru ; recent GLOBAL files - ",M" 'projectile-recentf ; recent PROJECT files - ",p" 'projectile-switch-project - ",g" 'git-gutter+-show-hunk - ",;" 'helm-imenu - ",:" 'my:goto-symbol - ",," 'ido-switch-buffer - ",." 'projectile-find-file) + "of" 'my:send-dir-to-finder + "ou" 'my:send-to-transmit + "ol" 'my:send-to-launchbar + "oL" 'my:send-dir-to-launchbar -(vmap! ",r" 'my:run-code-region - ",R" 'my:send-region-to-repl) + ;; tmux: cd (default-directory) + "ot" (λ (ex:tmux-chdir nil t)) + ;; tmux: cd [project root] + "oT" 'ex:tmux-chdir) -(nvmap! ",=" 'align-regexp) +(bind '(normal visual) + ";" 'evil-ex ; Remap ; to : - SPC and shift-SPC replace ; and , + "\\" 'evil-execute-in-god-state ; localleader + "X" 'evil-exchange -;;;; ;;;;;;;;;;;;;;;;;;;;; -(-nmap "\\" 'evil-execute-in-god-state) -(gmap! ":" 'linum-mode - "\\" 'neotree-show - "|" 'neotree-hide + "gc" 'evil-ace-jump-char-mode + "gw" 'evil-ace-jump-word-mode ; overwrites evil-fill + "gl" 'evil-ace-jump-line-mode + "gt" 'ace-window + "gT" (λ (ace-window 4)) - "oo" 'my:send-dir-to-finder - "ou" 'my:send-to-transmit - "ol" 'my:send-to-launchbar - "oL" 'my:send-dir-to-launchbar + "]e" 'next-error + "[e" 'previous-error + "]g" 'git-gutter+-next-hunk + "[g" 'git-gutter+-previous-hunk - ;; tmux: cd (default-directory) - "ot" (λ (my:ex:tmux-chdir nil t)) - ;; tmux: cd [project root] - "oT" 'my:ex:tmux-chdir) + "]\\" 'er/expand-region + "[\\" 'er/contract-region) -;;;; Keybindings ;;;;;;;;;;;;;;;;;;;;;;; -(nvmap! "gc" 'evil-ace-jump-char-mode - "gw" 'evil-ace-jump-word-mode ; overwrites evil-fill - "gl" 'evil-ace-jump-line-mode +(bind 'normal + ",r" 'my:run-code-buffer + ",R" 'my:switch-to-repl + ",a" 'helm-projectile-find-other-file + ",e" 'ido-find-file + ",E" 'ex:init-files + ",m" 'helm-recentf + ",M" 'helm-projectile-recentf ; recent PROJECT files + ",p" 'helm-projectile-switch-project + ",g" 'git-gutter+-show-hunk + ",;" 'helm-imenu + ",," 'helm-projectile-switch-to-buffer + ",<" 'helm-buffers-list + ",]" 'helm-etags-select + ",/" 'helm-projectile-find-file + ",." 'helm-projectile-find-file-dwim - "]\\" 'er/expand-region - "[\\" 'er/contract-region + ;; Moving rows rather than lines (in case of wrapping) + "j" 'evil-next-visual-line + "k" 'evil-previous-visual-line - "]g" 'git-gutter+-stage-hunks - "[g" 'git-gutter+-revert-hunks) + ;; behave like D and C; yank to end of line + "Y" (λ (evil-yank (point) (point-at-eol))) -(nmap! ;; Moving rows rather than lines (in case of wrapping) - "j" 'evil-next-visual-line - "k" 'evil-previous-visual-line + "zz" 'kill-this-buffer + "zx" 'bury-buffer - ;; behave like D and C; yank to end of line - "Y" (λ (evil-yank (point) (point-at-eol))) + "]b" 'next-buffer + "[b" 'previous-buffer + "]p" 'persp-next + "[p" 'persp-prev - "zz" 'kill-this-buffer - "zx" 'bury-buffer + ;; winner-mode: window layout undo/redo (see init-core.el) + (kbd "C-w u") 'winner-undo + (kbd "C-w C-r") 'winner-redo - "]b" 'next-buffer - "[b" 'previous-buffer - "]e" 'next-error - "[e" 'previous-error - "]h" 'git-gutter+-next-hunk - "[h" 'git-gutter+-previous-hunk + ;; Increment/decrement number under cursor + (kbd "C--") 'evil-numbers/inc-at-pt + (kbd "C-+") 'evil-numbers/dec-at-pt) - ;; winner-mode: window layout undo/redo (see init-core.el) - (kbd "C-w u") 'winner-undo - (kbd "C-w C-r") 'winner-redo +(bind 'visual + ",=" 'align-regexp + ",r" 'my:run-code-region + ",R" 'my:send-region-to-repl - ;; Increment/decrement number under cursor - (kbd "C--") 'evil-numbers/inc-at-pt - (kbd "C-+") 'evil-numbers/dec-at-pt) + ;; vnoremap < >gv + ">" (λ (evil-shift-right (region-beginning) (region-end)) + (evil-normal-state) + (evil-visual-restore))) -(vmap! ;; vnoremap < >gv - ">" (λ (evil-shift-right (region-beginning) (region-end)) - (evil-normal-state) - (evil-visual-restore))) +(bind 'insert + ;; Join lines from insert mode + (kbd "") (λ (evil-forward-word) (evil-delete-backward-word)) -(imap! ;; Join lines from insert mode - (kbd "") 'evil-join + ;; Newline magic + (kbd "") 'backward-delete-char-untabify + (kbd "") 'backward-delete-char + (kbd "") 'evil-ret-and-indent + (kbd "") (kbd " DEL") ; newline and dedent - ;; Newline magic - (kbd "") 'backward-delete-char - (kbd "") 'backward-delete-char-untabify - (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-[")) - ;; 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-[")) +(bind 'emacs + ;; Preserve buffer-movement in emacs mode + "\C-j" 'evil-next-line + "\C-k" 'evil-previous-line -(emap! ;; Preserve buffer-movement in emacs mode - "\C-j" 'evil-next-line - "\C-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) + (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! "!" 'rotate-word-at-point) -(vmap! "!" 'rotate-region) +(bind 'normal "!" 'rotate-word-at-point) +(bind 'visual "!" 'rotate-region) ;; Easy escape from insert mode -(ichmap "jj" 'evil-normal-state) +(ibind "jj" 'evil-normal-state) ;; Enable TAB to do matchit -(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items) +(bind '(normal visual) evil-matchit-mode-map [tab] 'evilmi-jump-items) + +;; Additional operators +(bind '(normal motion) "gr" 'ex:run-code) ; code eval +(bind '(normal motion) "gR" 'ex:send-region-to-repl) ; eval in repl +(bind '(normal motion) "gx" 'ex:scratch-buffer) ; send to scratch buffer ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -165,217 +173,64 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Real go-to-definition for elisp -(mmap emacs-lisp-mode-map "gd" +(bind 'motion emacs-lisp-mode-map "gd" (λ (let ((func (function-called-at-point))) (if func (find-function func))))) +(bind 'motion emacs-lisp-mode-map "gD" + (λ (let ((func (function-called-at-point))) + (if func (find-function-other-window func))))) -(after ag - (defmap ag-mode-map - [escape] 'ag-kill-buffers - "h" nil)) +;; Peek at file from dired +(bind dired-mode-map "o" (λ (popwin:find-file (dired-get-file-for-visit)))) -(after auto-complete - (imap ac-mode-map - (kbd "C-x C-f") 'ac-complete-filename - (kbd "C-SPC") 'auto-complete) +;; Evil registers ;;;;;;;;;;;;;;;;;;;;;; +(bind evil-ex-completion-map + (kbd "C-r") #'evil-ex-paste-from-register ; registers in ex-mode + (kbd "C-a") 'move-beginning-of-line + (kbd "") 'move-beginning-of-line + (kbd "") 'move-beginning-of-line + (kbd "") 'evil-delete-whole-line) +;; Quickly close/kill the command window +(bind 'normal evil-command-window-mode-map + [escape] 'kill-buffer-and-window + "q" 'kill-buffer-and-window) - (defmap ac-completing-map - (kbd "") 'ac-complete - (kbd "C-n") 'ac-next - (kbd "C-p") 'ac-previous - (kbd "S-C-SPC") 'ac-quick-help - (kbd "ESC") 'ac-stop - (kbd "RET") 'ac-complete)) - -(after emmet-mode - (imap emmet-mode-keymap - (kbd "s-e") 'emmet-expand-yas - (kbd "s-E") 'emmet-expand-line)) - -(after js-mode - (imap js-mode-map [remap auto-complete] 'tern-ac-complete)) - -(after markdown-mode - (let ((map markdown-mode-map)) - (nvmap map - (kbd ",i") 'markdown-insert-image - (kbd ",l") 'markdown-insert-link - (kbd ",L") 'markdown-insert-reference-link-dwim) - - (nmap map - "[p" 'markdown-promote - "]p" 'markdown-demote) - - (imap map (kbd "M--") 'markdown-insert-hr) - - (defmap map - (kbd "") nil - (kbd "") nil - (kbd "") nil - - (kbd "s-*") 'markdown-insert-list-item - (kbd "s-b") 'markdown-insert-bold - (kbd "s-i") 'markdown-insert-italic - (kbd "s-`") 'markdown-insert-del))) - -(after multiple-cursors - (imap mc/keymap - (kbd "s-'") 'mc/mark-next-like-this - (kbd "s-\"") 'mc/mark-previous-like-this - (kbd "C-s-'") 'mc/mark-all-like-this) - - (vmap mc/keymap - (kbd "s-'") 'mc/mark-next-like-this - (kbd "s-\"") 'mc/mark-previous-like-this - (kbd "C-s-'") 'mc/mark-all-like-this)) - -(after nose - (nmap nose-mode-map - ",tr" 'nosetests-again - ",ta" 'nosetests-all - ",ts" 'nosetests-one - ",tv" 'nosetests-module - ",tA" 'nosetests-pdb-all - ",tO" 'nosetests-pdb-one - ",tV" 'nosetests-pdb-module)) - -(after org - (imap org-mode-map [remap my.inflate-space-maybe] 'self-insert-command) - (define-key org-mode-map (kbd "RET") nil) - (define-key org-mode-map (kbd "C-j") nil) - (define-key org-mode-map (kbd "C-k") nil) - - (mapc (lambda (state) - (evil-define-key state evil-org-mode-map - (kbd "M-l") 'org-metaright - (kbd "M-h") 'org-metaleft - (kbd "M-k") 'org-metaup - (kbd "M-j") 'org-metadown - (kbd "M-L") 'org-shiftmetaright - (kbd "M-H") 'org-shiftmetaleft - (kbd "M-K") 'org-shiftmetaup - (kbd "M-J") 'org-shiftmetadown - (kbd "M-o") '(lambda () (interactive) - (evil-org-eol-call - '(lambda() - (org-insert-heading) - (org-metaright)))) - (kbd "M-t") '(lambda () (interactive) - (evil-org-eol-call - '(lambda() - (org-insert-todo-heading nil) - (org-metaright)))) - )) - '(normal insert)) - - ;; Formatting shortcuts - (imap evil-org-mode-map - (kbd "s-b") (λ (my/org-surround "*")) ; bold - (kbd "s-u") (λ (my/org-surround "_")) ; underline - (kbd "s-i") (λ (my/org-surround "/")) ; italics - (kbd "s-`") (λ (my/org-surround "+")) ; strikethrough - - (kbd "") (λ (evil-move-beginning-of-line) (org-insert-heading)) - (kbd "") (λ (org-insert-heading-after-current)) - ) - - (nvmap evil-org-mode-map - ",l" 'org-insert-link) - - (vmap evil-org-mode-map - (kbd "s-b") "s*" ; bold - (kbd "s-i") "s/") ; italics - - (nmap evil-org-mode-map - ",d" 'org-time-stamp - ",D" 'org-time-stamp-inactive - ",s" 'org-schedule - ",a" 'org-attach - ",A" 'org-attach-open - ",t" 'org-todo - ",T" 'org-show-todo-tree - ",/" 'org-sparse-tree - ",?" 'org-tags-view - ",+" 'org-align-all-tags - ",r" 'org-refile - "gh" 'outline-up-heading - "gj" 'org-forward-heading-same-level - "gk" 'org-backward-heading-same-level - "gl" 'outline-next-visible-heading - "go" 'org-open-at-point - "ga" 'org-agenda - "gt" 'org-show-todo-tree - "H" 'org-beginning-of-line - "L" 'org-end-of-line - "$" 'org-end-of-line - "^" 'org-beginning-of-line - "<" 'org-metaleft - ">" 'org-metaright - "-" 'org-cycle-list-bullet - (kbd ", SPC") 'org-archive-subtree - (kbd "") (λ (evil-move-beginning-of-line) (org-insert-heading) (evil-insert-state)) - (kbd "") (λ (org-insert-heading-after-current) (evil-insert-state)) - (kbd "RET") (λ (if (org-entry-is-todo-p) (org-todo 'done))) - (kbd "TAB") 'org-cycle) - ) - -(after ruby-mode - (nmap ruby-mode-map "gd" 'rsense-jump-to-definition)) - -(after rspec-mode - (nmap rspec-mode-verifiable-keymap - ",tr" 'rspec-rerun - ",ta" 'rspec-verify-all - ",ts" 'rspec-verify-single - ",tv" 'rspec-verify) - (nmap rspec-dired-mode-keymap - ",tv" 'rspec-dired-verify - ",ts" 'rspec-dired-verify-single - ",ta" 'rspec-verify-all - ",tr" 'rspec-rerun)) - -(after web-mode - (defmap web-mode-map (kbd "s-/") 'web-mode-comment-or-uncomment) - - (nvmap web-mode-map - "]a" 'web-mode-attribute-next - "]t" 'web-mode-tag-next - "[t" 'web-mode-tag-previous - "]T" 'web-mode-element-child - "[T" 'web-mode-element-parent) - - (nmap web-mode-map - "zf" 'web-mode-fold-or-unfold - ",t" 'web-mode-element-rename)) - -(after re-builder - (nmap reb-mode-map - ",r" 'reb-enter-subexp-mode - ",b" 'reb-copy - ",i" 'reb-change-syntax - "\C-n" 'reb-next-match - "\C-p" 'reb-prev-match)) +;; Make C-g work like +(bind '(normal visual insert) (kbd "C-g") 'evil-normal-state) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Ex Commands ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(exmap "msg" 'my:ex:msg-buffer) -(exmap "recompile" 'my:ex:byte-compile-all) -(exmap "n[otes]" 'my:ex:notes) -(exmap "ini" 'my:ex:init-files) -(exmap "snip[pets]" 'my:ex:snippets) -(exmap "mru" 'my:ex:mru) +(defcmd "msg" 'popwin:messages) +(defcmd "recompile" 'ex:byte-compile-all) +(defcmd "n[otes]" 'ex:notes) +(defcmd "ini" 'ex:init-files) +(defcmd "rec[ent]" 'ex:recent-files) +(defcmd "snip[pets]" 'ex:snippets) +(defcmd "retab" 'ex:retab) +(defcmd "ag" 'ex:ag-search) +(defcmd "agr" 'ex:ag-regex-search) +(defcmd "x" 'ex:scratch-buffer) +(defcmd "X" 'ex:org-capture) +(defcmd "a" 'helm-projectile-find-other-file) +(defcmd "cd" 'ex:cd) +(defcmd "tcd" 'ex:tmux-chdir) +(defcmd "t[mux]" 'ex:tmux-send) +(defcmd "r[ege]x" 'regex-tool) +(defcmd "en[ew]" 'ex:create-file) +(defcmd "l[ast]" 'popwin:popup-last-buffer) +(defcmd "run" 'ex:run-code) +(defcmd "build" 'ex:build) +(defcmd "k[ill]" 'kill-this-buffer) ; Kill current buffer +(defcmd "k[ill]all" 'ex:kill-buffers) ; Kill all buffers (bang = project buffers only) +(defcmd "k[ill]persp" 'my:kill-persp) ; Kill current perspective +(defcmd "k[ill]o" 'my:kill-other-buffers) ; Kill current project buffers +(defcmd "sq[uint]" 'ex:narrow-indirect) ; Narrow buffer to selection +(defcmd "ren[ame]" 'ex:rename-this-file) ; Rename file . Bang: Delete old one -(exmap "retab" 'my:ex:retab) -(exmap "ag" 'my:ex:ag-search) -(exmap "agr" 'my:ex:ag-regex-search) -(exmap "x" 'my:ex:scratch-buffer) -(exmap "X" 'my:ex:org-capture) -(exmap "a" 'projectile-find-other-file) -(exmap "bx" 'my:ex:kill-buffers) -(exmap "tcd" 'my:ex:tmux-chdir) -(exmap "t[mux]" 'my:ex:tmux-send) -(exmap "build" 'my:ex:build) -(exmap "re[gex]" 're-builder) +(after git-gutter+ + (defcmd "gstage" 'git-gutter+-stage-hunks) + (defcmd "grevert" 'git-gutter+-revert-hunks) + (defcmd "gdiff" 'git-gutter+-show-hunk)) diff --git a/init/my-settings.el b/init/my-settings.el index b1514aa25..a53d0e720 100644 --- a/init/my-settings.el +++ b/init/my-settings.el @@ -6,7 +6,10 @@ ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. '(git-gutter:lighter " !") - ) + ;; Make brin theme safe + '(custom-safe-themes + (quote + ("7fa3f2865322ee4e3fcf061efcf020465d691aed02e6756191fbf1cfb8648ccf" default)))) (set-face-background 'show-paren-match-face "#1f1f1f") (set-face-foreground 'show-paren-match-face "orange") diff --git a/themes/brin-theme.el b/themes/brin-theme.el index ab0f64939..9b5710313 100644 --- a/themes/brin-theme.el +++ b/themes/brin-theme.el @@ -28,7 +28,7 @@ (custom-theme-set-variables 'brin) - (let ((background "#1f1f1f") + (let ((background "#222222") ;; (gutters "#262E34") (gutters "#1f252a") (gutter-fg "#55616A") @@ -49,12 +49,18 @@ (delimiters "#c0c5ce") (operators "#c0c5ce") (keywords "#b48ead") - (variables "#bf616a") + (variables "#CBECFF") (functions "#8fa1b3") (methods "#8fa1b3") (strings "#a3be8c") (constants "#d08770") - (white "#ffffff")) + (white "#ffffff") + + (git-modified "#B4924E") + (git-added "#91E331") + ;; (git-added "#55811D") + (git-deleted "#A12121") + ) (custom-theme-set-faces 'brin @@ -67,7 +73,7 @@ `(region ((t (:background ,selection) ))) `(cursor ((t (:background ,white) ))) `(fringe ((t (:background ,background :foreground ,white) ))) - `(linum ((t (:background ,linum :foreground ,gutter-fg) ))) + `(linum ((t (:background ,background :foreground ,gutter-fg) ))) `(vertical-border ((t (:foreground ,gutters-active) ))) @@ -76,35 +82,55 @@ :box (:line-width 3 :color ,gutters-active) )))) `(mode-line-inactive ((t (:foreground ,gutter-fg - :background ,gutters + :background ,background :box (:line-width 3 :color ,gutters) )))) - `(highlight-indentation-face ((t (:background ,linum) ))) - `(highlight-indentation-current-column-face ((t (:background ,gutters-active) ))) + `(mode-line-modified-face ((t (:foreground ,builtin)))) + + ;; `(highlight-indentation-face ((t (:background ,linum) ))) + ;; `(highlight-indentation-current-column-face ((t (:background ,gutters-active) ))) `(flyspell-incorrect ((t (:underline "#ff5555" :inherit unspecified)))) + `(helm-source-header ((t (:background ,gutters-active :foreground ,strings :weight bold :height 1.0)))) + `(helm-selection ((t (:background ,selection)))) + ;; Font lock faces ;; ***************************************************************************************** - `(font-lock-keyword-face ((t (:foreground ,keywords)))) - `(font-lock-type-face ((t (:foreground ,punctuation)))) - `(font-lock-constant-face ((t (:foreground ,constants)))) - `(font-lock-variable-name-face ((t (:foreground ,variables)))) - `(font-lock-builtin-face ((t (:foreground ,builtin)))) - `(font-lock-string-face ((t (:foreground ,strings)))) - `(font-lock-comment-face ((t (:foreground ,comments)))) - `(font-lock-comment-delimiter-face ((t (:foreground ,comments)))) - `(font-lock-function-name-face ((t (:foreground ,functions)))) - `(font-lock-doc-string-face ((t (:foreground ,strings)))) + `(font-lock-keyword-face ((t (:foreground ,keywords)))) + `(font-lock-type-face ((t (:foreground ,punctuation)))) + `(font-lock-constant-face ((t (:foreground ,constants)))) + `(font-lock-variable-name-face ((t (:foreground ,variables)))) + `(font-lock-builtin-face ((t (:foreground ,builtin)))) + `(font-lock-string-face ((t (:foreground ,strings)))) + `(font-lock-comment-face ((t (:foreground ,comments)))) + `(font-lock-comment-delimiter-face ((t (:foreground ,comments)))) + `(font-lock-function-name-face ((t (:foreground ,functions)))) + `(font-lock-doc-string-face ((t (:foreground ,comments)))) + `(font-lock-doc-face ((t (:foreground ,comments)))) + + `(trailing-whitespace ((t (:background "#884444")))) + `(whitespace-tab ((t (:foreground "#444444")))) + `(whitespace-newline ((t (:foreground "#444444")))) + + `(git-gutter+-modified ((t (:foreground ,git-modified)))) + `(git-gutter+-added ((t (:foreground ,git-added)))) + `(git-gutter+-deleted ((t (:foreground ,git-deleted)))) + +;; js2-mode +;; ***************************************************************************************** + + `(js2-function-param ((t (:foreground ,variables)))) + `(js2-jsdoc-tag ((t (:foreground ,comments :weight bold :bold t)))) - `(my-carriage-return-face ((t (:foreground "#555555")))) - `(my-tab-face ((t (:foreground "#555555")))) - `(trailing-whitespace ((t (:background "#884444"))))) ;; ***************************************************************************************** - ) + `(persp-selected-face ((t (:foreground ,builtin)))) + + )) + ;; *****************************************************************************************