bind! -> map!; new minimalistic keybinding macro

This commit is contained in:
Henrik Lissner 2015-11-30 05:31:20 -05:00
parent 2e4a083bbb
commit 81df2830a9
19 changed files with 431 additions and 441 deletions

View file

@ -110,54 +110,52 @@ Examples:
`((add-hook 'find-file-hook ',hook-name)))))))))) `((add-hook 'find-file-hook ',hook-name))))))))))
(after! evil (after! evil
;; Register keywords for proper indentation (see `bind!') ;; Register keywords for proper indentation (see `map!')
(put ':prefix 'lisp-indent-function 'defun) (put ':prefix 'lisp-indent-function 'defun)
(put ':map 'lisp-indent-function 'defun) (put ':map 'lisp-indent-function 'defun)
(put ':after 'lisp-indent-function 'defun) (put ':after 'lisp-indent-function 'defun)
(put ':when 'lisp-indent-function 'defun) (put ':when 'lisp-indent-function 'defun)
(put ':unless 'lisp-indent-function 'defun) (put ':unless 'lisp-indent-function 'defun)
(put ':leader 'lisp-indent-function 'defun)
(put ':localleader 'lisp-indent-function 'defun)
(defmacro bind! (&rest rest) (defmacro map! (&rest rest)
(let ((i 0) (let ((i 0)
key def
first-set
prefix
internal
(default-keymaps '((current-global-map)))
(keymaps (if (boundp 'keymaps) keymaps))
(states (if (boundp 'states) states '()))
(forms '()) (forms '())
(keymaps (if (boundp 'keymaps) keymaps))
(default-keymaps '((current-global-map)))
(state-map '(("n" . normal) (state-map '(("n" . normal)
("v" . visual) ("v" . visual)
("i" . insert) ("i" . insert)
("e" . emacs) ("e" . emacs)
("o" . operator) ("o" . operator)
("m" . motion) ("m" . motion)
("r" . replace)))) ("r" . replace)))
key def prefix states)
(unless keymaps (unless keymaps
(setq keymaps default-keymaps)) (setq keymaps default-keymaps))
(while rest (while rest
(setq key (pop rest)) (setq key (pop rest))
(add-to-list (add-to-list
'forms 'forms
(cond ((eq key '-) nil) ; skip this (cond ((listp key) ; it's a sub exp
`(,(macroexpand `(map! ,@key))))
((listp key) ; it's a sub exp
`((bind! ,@key)))
((keywordp key) ((keywordp key)
(when (memq key '(:leader :localleader))
(push (pcase key
(:leader narf-leader-prefix)
(:localleader narf-localleader-prefix))
rest)
(setq key :prefix))
(pcase key (pcase key
;; TODO: Data checks ;; TODO: Data checks
(:prefix (setq prefix (kbd (pop rest))) (:prefix (setq prefix (kbd (pop rest))) nil)
(if (= i 0) (setq first-set `(:prefix . ,prefix))) (:map (setq keymaps (-list (pop rest))) nil)
nil) (:unset `(,(macroexpand `(map! ,(kbd (pop rest)) nil))))
(:map (setq keymaps (-list (pop rest))) (:after (prog1 `((after! ,(pop rest) ,(macroexpand `(map! ,@rest)))) (setq rest '())))
(if (= i 0) (setq first-set `(:map . ,keymaps))) (:when (prog1 `((if ,(pop rest) ,(macroexpand `(map! ,@rest)))) (setq rest '())))
nil) (:unless (prog1 `((if (not ,(pop rest)) ,(macroexpand `(map! ,@rest)))) (setq rest '())))
(:unset `((bind! ,(kbd (pop rest)) nil)))
(:after (prog1 `((after! ,(pop rest) (bind! ,@rest))) (setq rest '())))
(:when (prog1 `((if ,(pop rest) (bind! ,@rest))) (setq rest '())))
(:unless (prog1 `((if (not ,(pop rest)) (bind! ,@rest))) (setq rest '())))
(otherwise ; might be a state prefix (otherwise ; might be a state prefix
(mapc (lambda (letter) (mapc (lambda (letter)
(if (assoc letter state-map) (if (assoc letter state-map)
@ -179,16 +177,12 @@ Examples:
(unless (> (length rest) 0) (unless (> (length rest) 0)
(user-error "Map has no definition for %s" key)) (user-error "Map has no definition for %s" key))
(setq def (pop rest)) (setq def (pop rest))
(let ((first-key (car first-set)) (let (out-forms)
(first-value (cdr first-set))
out-forms)
(dolist (keymap keymaps) (dolist (keymap keymaps)
(if (not states) (if (not states)
(add-to-list 'out-forms `(evil-define-key nil ,keymap ,key ,def) t) (add-to-list 'out-forms `(evil-define-key nil ,keymap ,key ,def) t)
(dolist (state states) (dolist (state states)
(add-to-list 'out-forms `(evil-define-key ',state ,keymap ,key ,def) t)))) (add-to-list 'out-forms `(evil-define-key ',state ,keymap ,key ,def) t))))
(setq prefix (if (eq first-key :prefix) first-value))
(setq keymaps (if (eq first-key :map) first-value default-keymaps))
(setq states '()) (setq states '())
out-forms)) out-forms))

View file

@ -11,14 +11,14 @@
flycheck-disabled-checkers '(emacs-lisp-checkdoc make)) flycheck-disabled-checkers '(emacs-lisp-checkdoc make))
:config :config
(evil-initial-state 'flycheck-error-list-mode 'emacs) (evil-initial-state 'flycheck-error-list-mode 'emacs)
(bind! (:map flycheck-error-list-mode-map (map! (:map flycheck-error-list-mode-map
:n [escape] 'kill-this-buffer :n [escape] 'kill-this-buffer
:n "q" 'kill-this-buffer :n "q" 'kill-this-buffer
:n "C-n" 'flycheck-error-list-next-error :n "C-n" 'flycheck-error-list-next-error
:n "C-p" 'flycheck-error-list-previous-error :n "C-p" 'flycheck-error-list-previous-error
:n "j" 'flycheck-error-list-next-error :n "j" 'flycheck-error-list-next-error
:n "k" 'flycheck-error-list-previous-error :n "k" 'flycheck-error-list-previous-error
:n "RET" 'flycheck-error-list-goto-error)) :n "RET" 'flycheck-error-list-goto-error))
;; Check buffer when normal mode is entered ;; Check buffer when normal mode is entered
(add-hook! evil-normal-state-entry 'narf*flycheck-buffer) (add-hook! evil-normal-state-entry 'narf*flycheck-buffer)

View file

@ -32,24 +32,24 @@
(mapc (lambda (r) (add-to-list 'helm-boring-file-regexp-list r)) (mapc (lambda (r) (add-to-list 'helm-boring-file-regexp-list r))
(list "\\.projects$" "\\.DS_Store$")) (list "\\.projects$" "\\.DS_Store$"))
(bind! (:map (helm-map helm-generic-files-map helm-find-files-map helm-swoop-map helm-projectile-find-file-map) (map! (:map (helm-map helm-generic-files-map helm-find-files-map helm-swoop-map helm-projectile-find-file-map)
"C-w" 'backward-kill-word "C-w" 'backward-kill-word
"C-r" 'evil-ex-paste-from-register ; Evil registers in helm! Glorious! "C-r" 'evil-ex-paste-from-register ; Evil registers in helm! Glorious!
"<escape>" 'helm-keyboard-quit "<escape>" 'helm-keyboard-quit
[escape] 'helm-keyboard-quit) [escape] 'helm-keyboard-quit)
(:map helm-find-files-map (:map helm-find-files-map
"C-w" 'helm-find-files-up-one-level "C-w" 'helm-find-files-up-one-level
;; "TAB" 'helm-execute-persistent-action ;; "TAB" 'helm-execute-persistent-action
"/" 'helm-execute-persistent-action) "/" 'helm-execute-persistent-action)
(:map helm-ag-map (:map helm-ag-map
"<backtab>" 'helm-ag-edit) "<backtab>" 'helm-ag-edit)
(:map helm-ag-edit-map (:map helm-ag-edit-map
"<escape>" 'helm-ag--edit-abort "<escape>" 'helm-ag--edit-abort
:n "zx" 'helm-ag--edit-abort) :n "zx" 'helm-ag--edit-abort)
(:map helm-map (:map helm-map
"C-S-n" 'helm-next-source "C-S-n" 'helm-next-source
"C-S-p" 'helm-previous-source "C-S-p" 'helm-previous-source
"C-u" 'helm-delete-minibuffer-contents)) "C-u" 'helm-delete-minibuffer-contents))
;;; Helm hacks ;;; Helm hacks
(defun narf*helm-hide-source-header-maybe () (defun narf*helm-hide-source-header-maybe ()

View file

@ -33,13 +33,13 @@
(ido-vertical-mode 1) (ido-vertical-mode 1)
(require 'flx-ido) (require 'flx-ido)
(flx-ido-mode 1) (flx-ido-mode 1)
(bind! :map (ido-common-completion-map (map! :map (ido-common-completion-map
ido-completion-map ido-completion-map
ido-file-completion-map) ido-file-completion-map)
"C-n" 'ido-next-match "C-n" 'ido-next-match
"C-p" 'ido-prev-match "C-p" 'ido-prev-match
"C-w" 'ido-delete-backward-word-updir "C-w" 'ido-delete-backward-word-updir
"C-u" 'ido-up-directory)) "C-u" 'ido-up-directory))
(advice-add 'ido-sort-mtime :override 'narf*ido-sort-mtime) (advice-add 'ido-sort-mtime :override 'narf*ido-sort-mtime)
(add-hook! (ido-make-file-list ido-make-dir-list) 'narf*ido-sort-mtime) (add-hook! (ido-make-file-list ido-make-dir-list) 'narf*ido-sort-mtime)
@ -68,22 +68,22 @@
neo-modern-sidebar t) neo-modern-sidebar t)
:config :config
(defun narf|neotree-init-keymap () (defun narf|neotree-init-keymap ()
(bind! :map evil-motion-state-local-map (map! :map evil-motion-state-local-map
"ESC" 'neotree-hide "ESC" 'neotree-hide
"\\\\" 'neotree-hide "\\\\" 'neotree-hide
"RET" 'neotree-enter "RET" 'neotree-enter
"J" 'neotree-select-next-sibling-node "J" 'neotree-select-next-sibling-node
"K" 'neotree-select-previous-sibling-node "K" 'neotree-select-previous-sibling-node
"H" 'neotree-select-up-node "H" 'neotree-select-up-node
"L" 'neotree-select-down-node "L" 'neotree-select-down-node
"v" 'neotree-enter-vertical-split "v" 'neotree-enter-vertical-split
"s" 'neotree-enter-horizontal-split "s" 'neotree-enter-horizontal-split
"c" 'neotree-create-node "c" 'neotree-create-node
"d" 'neotree-delete-node "d" 'neotree-delete-node
"g" 'neotree-refresh "g" 'neotree-refresh
"q" 'neotree-hide "q" 'neotree-hide
"r" 'neotree-rename-node "r" 'neotree-rename-node
"R" 'neotree-change-root)) "R" 'neotree-change-root))
(add-hook! neotree-mode 'narf|neotree-init-keymap) (add-hook! neotree-mode 'narf|neotree-init-keymap)
(add-hook! window-configuration-change 'narf|neotree-close-on-window-change) (add-hook! window-configuration-change 'narf|neotree-close-on-window-change)

View file

@ -23,8 +23,8 @@
yas-snippet-dirs `(,@narf-snippet-dirs) yas-snippet-dirs `(,@narf-snippet-dirs)
yas-prompt-functions '(yas-ido-prompt yas-no-prompt)) yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
(bind! :i [(tab)] 'yas-expand (map! :i [(tab)] 'yas-expand
:v "<backtab>" 'narf/yas-insert-snippet) :v "<backtab>" 'narf/yas-insert-snippet)
(defvar yas-minor-mode-map (defvar yas-minor-mode-map
(let ((map (make-sparse-keymap))) (let ((map (make-sparse-keymap)))
@ -40,21 +40,21 @@
;; Simpler `yas-selected-text' alias for templates ;; Simpler `yas-selected-text' alias for templates
(defvaralias '% 'yas-selected-text) (defvaralias '% 'yas-selected-text)
;; Undo global maps ;; Undo global maps
(bind! :i [(tab)] nil (map! :i [(tab)] nil
:v "<backtab>" nil) :v "<backtab>" nil)
;; keybinds ;; keybinds
(bind! :map yas-keymap (map! :map yas-keymap
"C-e" 'narf/yas-goto-end-of-field "C-e" 'narf/yas-goto-end-of-field
"C-a" 'narf/yas-goto-start-of-field "C-a" 'narf/yas-goto-start-of-field
"<M-right>" 'narf/yas-goto-end-of-field "<M-right>" 'narf/yas-goto-end-of-field
"<M-left>" 'narf/yas-goto-start-of-field "<M-left>" 'narf/yas-goto-start-of-field
"<S-tab>" 'yas-prev-field "<S-tab>" 'yas-prev-field
"<M-backspace>" 'narf/yas-clear-to-sof "<M-backspace>" 'narf/yas-clear-to-sof
"<escape>" 'evil-normal-state "<escape>" 'evil-normal-state
[backspace] 'narf/yas-backspace [backspace] 'narf/yas-backspace
"<delete>" 'narf/yas-delete) "<delete>" 'narf/yas-delete)
;; Once you're in normal mode, you're out ;; Once you're in normal mode, you're out
(add-hook! evil-normal-state-entry 'yas-abort-snippet) (add-hook! evil-normal-state-entry 'yas-abort-snippet)

View file

@ -18,11 +18,12 @@
:init :init
(add-hook! csharp-mode '(emr-initialize omnisharp-mode)) (add-hook! csharp-mode '(emr-initialize omnisharp-mode))
:config :config
(evil-define-key 'normal omnisharp-mode-map (map! :map omnisharp-mode-map
(kbd "gd") 'omnisharp-go-to-definition "gd" 'omnisharp-go-to-definition
(kbd ",tr") (λ (omnisharp-unit-test "fixture")) (:prefix "\\"
(kbd ",ts") (λ (omnisharp-unit-test "single")) "tr" (λ (omnisharp-unit-test "fixture"))
(kbd ",ta") (λ (omnisharp-unit-test "all"))) "ts" (λ (omnisharp-unit-test "single"))
"ta" (λ (omnisharp-unit-test "all"))))
(after! company (after! company
(define-company-backend! csharp-mode (omnisharp)) (define-company-backend! csharp-mode (omnisharp))

View file

@ -26,13 +26,13 @@
;; em-prompt ;; em-prompt
(setq eshell-prompt-function 'narf/eshell-prompt) (setq eshell-prompt-function 'narf/eshell-prompt)
(bind! :map eshell-mode-map (map! :map eshell-mode-map
:n "i" 'narf/eshell-evil-prepend-maybe :n "i" 'narf/eshell-evil-prepend-maybe
:n "I" 'narf/eshell-evil-prepend :n "I" 'narf/eshell-evil-prepend
:n "a" 'narf/eshell-evil-append-maybe :n "a" 'narf/eshell-evil-append-maybe
:n "A" 'narf/eshell-evil-append :n "A" 'narf/eshell-evil-append
:n "r" 'narf/eshell-evil-replace-maybe :n "r" 'narf/eshell-evil-replace-maybe
:n "R" 'narf/eshell-evil-replace-state-maybe)) :n "R" 'narf/eshell-evil-replace-state-maybe))
(provide 'module-eshell) (provide 'module-eshell)
;;; module-eshell.el ends here ;;; module-eshell.el ends here

View file

@ -36,14 +36,14 @@
:config :config
(define-company-backend! go-mode (go yasnippet))) (define-company-backend! go-mode (go yasnippet)))
(bind! (map! :map go-mode-map
(:map go-mode-map :n "gd" 'godef-jump
:n "gd" 'godef-jump :n "gD" 'godef-describe
:n "gD" 'godef-describe (:localleader
:n ",i" 'helm-go-package :n "p" 'helm-go-package
:n ",tr" 'narf:go-test-run-all :n "tr" 'narf:go-test-run-all
:n ",ta" 'narf:go-test-run-all :n "ta" 'narf:go-test-run-all
:n ",ts" 'narf:go-test-run-package))) :n "ts" 'narf:go-test-run-package)))
(provide 'module-go) (provide 'module-go)
;;; module-go.el ends here ;;; module-go.el ends here

View file

@ -23,7 +23,7 @@
:functions company-emacs-eclim-setup :functions company-emacs-eclim-setup
:config (company-emacs-eclim-setup))) :config (company-emacs-eclim-setup)))
(bind! :map java-mode-map :m "gd" 'eclim-java-find-declaration)) (map! :map java-mode-map :m "gd" 'eclim-java-find-declaration))
(use-package android-mode (use-package android-mode
:commands android-mode :commands android-mode

View file

@ -16,7 +16,7 @@
(after! web-beautify (after! web-beautify
(add-hook! js2-mode (setenv "jsbeautify_indent_size" "4")) (add-hook! js2-mode (setenv "jsbeautify_indent_size" "4"))
(bind! :map js2-mode-map :m "gQ" 'web-beautify-js)) (map! :map js2-mode-map :m "gQ" 'web-beautify-js))
(use-package js2-refactor (use-package js2-refactor
:init (add-hook! js2-mode 'emr-initialize) :init (add-hook! js2-mode 'emr-initialize)

View file

@ -22,7 +22,7 @@
;; Highlight extra NARF keywords ;; Highlight extra NARF keywords
(let ((keywords '("add-hook!" (let ((keywords '("add-hook!"
"bind!" "map!"
"after!" "after!"
"λ" "λ"
"in!" "in!"
@ -38,9 +38,9 @@
'emacs-lisp-mode `(("\\(lambda\\)" (0 (narf/show-as ))))) 'emacs-lisp-mode `(("\\(lambda\\)" (0 (narf/show-as )))))
;; Real go-to-definition for elisp ;; Real go-to-definition for elisp
(bind! :map emacs-lisp-mode-map (map! :map emacs-lisp-mode-map
:m "gd" 'narf/elisp-find-function-at-pt :m "gd" 'narf/elisp-find-function-at-pt
:m "gD" 'narf/elisp-find-function-at-pt-other-window) :m "gD" 'narf/elisp-find-function-at-pt-other-window)
(use-package slime :defer t (use-package slime :defer t
:config :config

View file

@ -14,29 +14,30 @@
(add-hook! markdown-mode (add-hook! markdown-mode
(exmap! "preview" 'narf/markdown-preview) (exmap! "preview" 'narf/markdown-preview)
(exmap! "export" 'narf:org-export)) (exmap! "export" 'narf:org-export))
(bind! (:map markdown-mode-map (map! (:map markdown-mode-map
"<backspace>" nil "<backspace>" nil
"<M-left>" nil "<M-left>" nil
"<M-right>" nil "<M-right>" nil
;; Assumes you have a markdown renderer plugin in chrome ;; Assumes you have a markdown renderer plugin in chrome
:nv "M-r" (λ (narf-open-with "Google Chrome")) :nv "M-r" (λ (narf-open-with "Google Chrome"))
"M-*" 'markdown-insert-list-item "M-*" 'markdown-insert-list-item
"M-b" 'markdown-insert-bold "M-b" 'markdown-insert-bold
"M-i" 'markdown-insert-italic "M-i" 'markdown-insert-italic
"M-`" 'narf/markdown-insert-del "M-`" 'narf/markdown-insert-del
:nv ",i" 'markdown-insert-image (:localleader
:nv ",l" 'markdown-insert-link :nv "i" 'markdown-insert-image
:nv ",L" 'markdown-insert-reference-link-dwim :nv "l" 'markdown-insert-link
:nv ",b" 'markdown-preview :nv "L" 'markdown-insert-reference-link-dwim
:nv "b" 'markdown-preview)
;; TODO: Make context sensitive ;; TODO: Make context sensitive
:n "[p" 'markdown-promote :n "[p" 'markdown-promote
:n "]p" 'markdown-demote :n "]p" 'markdown-demote
:i "M--" 'markdown-insert-hr))) :i "M--" 'markdown-insert-hr)))
;; TODO: Test previewing capability ;; TODO: Test previewing capability

View file

@ -399,117 +399,128 @@ will function properly."
(define-key org-mode-map (kbd "C-j") nil) (define-key org-mode-map (kbd "C-j") nil)
(define-key org-mode-map (kbd "C-k") nil) (define-key org-mode-map (kbd "C-k") nil)
;; Keybinds ;; Keybinds
(bind! (:map org-mode-map (map! (:map org-mode-map
:i [remap narf/inflate-space-maybe] 'org-self-insert-command :i [remap narf/inflate-space-maybe] 'org-self-insert-command
:i "RET" 'org-return-indent) :i "RET" 'org-return-indent)
(:map evil-org-mode-map (:map evil-org-mode-map
:ni "A-l" 'org-metaright :ni "A-l" 'org-metaright
:ni "A-h" 'org-metaleft :ni "A-h" 'org-metaleft
:ni "A-k" 'org-metaup :ni "A-k" 'org-metaup
:ni "A-j" 'org-metadown :ni "A-j" 'org-metadown
;; Expand tables (or shiftmeta move) ;; Expand tables (or shiftmeta move)
:ni "A-L" 'narf/org-table-append-field-or-shift-right :ni "A-L" 'narf/org-table-append-field-or-shift-right
:ni "A-H" 'narf/org-table-prepend-field-or-shift-left :ni "A-H" 'narf/org-table-prepend-field-or-shift-left
:ni "A-K" 'narf/org-table-prepend-row-or-shift-up :ni "A-K" 'narf/org-table-prepend-row-or-shift-up
:ni "A-J" 'narf/org-table-append-row-or-shift-down :ni "A-J" 'narf/org-table-append-row-or-shift-down
:i "C-L" 'narf/org-table-next-field :i "C-L" 'narf/org-table-next-field
:i "C-H" 'narf/org-table-previous-field :i "C-H" 'narf/org-table-previous-field
:i "C-K" 'narf/org-table-previous-row :i "C-K" 'narf/org-table-previous-row
:i "C-J" 'narf/org-table-next-row :i "C-J" 'narf/org-table-next-row
:i "C-e" 'org-end-of-line :i "C-e" 'org-end-of-line
:i "C-a" 'org-beginning-of-line :i "C-a" 'org-beginning-of-line
:nv "j" 'evil-next-visual-line :nv "j" 'evil-next-visual-line
:nv "k" 'evil-previous-visual-line :nv "k" 'evil-previous-visual-line
:v "<S-tab>" 'narf/yas-insert-snippet :v "<S-tab>" 'narf/yas-insert-snippet
:i "M-a" (λ (evil-visual-state) (org-mark-element)) :i "M-a" (λ (evil-visual-state) (org-mark-element))
:n "M-a" 'org-mark-element :n "M-a" 'org-mark-element
:v "M-a" 'mark-whole-buffer :v "M-a" 'mark-whole-buffer
:ni "<M-return>" (λ (narf/org-insert-item 'below)) :ni "<M-return>" (λ (narf/org-insert-item 'below))
:ni "<S-M-return>" (λ (narf/org-insert-item 'above)) :ni "<S-M-return>" (λ (narf/org-insert-item 'above))
:i "M-b" (λ (narf/org-surround "*")) ; bold :i "M-b" (λ (narf/org-surround "*")) ; bold
:i "M-u" (λ (narf/org-surround "_")) ; underline :i "M-u" (λ (narf/org-surround "_")) ; underline
:i "M-i" (λ (narf/org-surround "/")) ; italics :i "M-i" (λ (narf/org-surround "/")) ; italics
:i "M-`" (λ (narf/org-surround "+")) ; strikethrough :i "M-`" (λ (narf/org-surround "+")) ; strikethrough
:v "M-b" "S*" :v "M-b" "S*"
:v "M-u" "S_" :v "M-u" "S_"
:v "M-i" "S/" :v "M-i" "S/"
:v "M-`" "S+" :v "M-`" "S+"
:n ",;" 'helm-org-in-buffer-headings (:leader
:nv ",l" 'org-insert-link :n ";" 'helm-org-in-buffer-headings
:n ",L" 'org-store-link :n "oa" 'narf/org-attachment-reveal
;; TODO narf/org-replace-link-by-link-description )
:n ",=" 'org-align-all-tags
:n ",f" 'org-sparse-tree
:n ",?" 'org-tags-view
:n ",e" 'org-edit-special
:n ",a" 'org-agenda
:n ",D" 'org-time-stamp-inactive
:n ",i" 'narf/org-toggle-inline-images-at-point
:n ",t" 'org-todo
:n ",T" 'org-show-todo-tree
:n ",d" 'org-time-stamp
:n ",r" 'org-refile
:n ",s" 'org-schedule
:n ",oa" 'narf/org-attachment-reveal
:n ", SPC" 'narf/org-toggle-checkbox
:n ", RET" 'org-archive-subtree
:n "za" 'org-cycle (:localleader
:n "zA" 'org-shifttab :n "/" 'org-sparse-tree
:n "zm" 'hide-body :n "?" 'org-tags-view
:n "zr" 'show-all
:n "zo" 'show-subtree
:n "zO" 'show-all
:n "zc" 'hide-subtree
:n "zC" 'hide-all
:m "]]" (λ (call-interactively 'org-forward-heading-same-level) (org-beginning-of-line)) :n "n" (λ (if (buffer-narrowed-p) (widen) (org-narrow-to-subtree)))
:m "[[" (λ (call-interactively 'org-backward-heading-same-level) (org-beginning-of-line)) :n "e" 'org-edit-special
:m "]l" 'org-next-link :n "=" 'org-align-all-tags
:m "[l" 'org-previous-link :nv "l" 'org-insert-link
:n "L" 'org-store-link
:n "x" 'narf/org-remove-link
:n "w" 'writing-mode
:n "SPC" 'narf/org-toggle-checkbox
:n "RET" 'org-archive-subtree
:n "RET" 'narf/org-dwim-at-point :n "a" 'org-agenda
:n "A" 'narf:org-attachment-list
:m "gh" 'outline-up-heading :n "d" 'org-time-stamp
:m "gj" 'org-forward-heading-same-level :n "D" 'org-time-stamp-inactive
:m "gk" 'org-backward-heading-same-level :n "i" 'narf/org-toggle-inline-images-at-point
:m "gl" (λ (call-interactively 'outline-next-visible-heading) (show-children)) :n "t" (λ (org-todo (if (org-entry-is-todo-p) 'none 'todo)))
:n "T" 'org-todo
:n "r" 'org-refile
:n "s" 'org-schedule
)
:n "go" 'org-open-at-point :n "za" 'org-cycle
:n "gO" (λ (let ((org-link-frame-setup (append '((file . find-file-other-window)) org-link-frame-setup)) :n "zA" 'org-shifttab
(org-file-apps '(("\\.org$" . emacs) :n "zm" 'hide-body
(t . "open \"%s\"")))) :n "zr" 'show-all
(call-interactively 'org-open-at-point))) :n "zo" 'show-subtree
:n "zO" 'show-all
:n "zc" 'hide-subtree
:n "zC" 'hide-all
:n "gQ" 'org-fill-paragraph :m "]]" (λ (call-interactively 'org-forward-heading-same-level) (org-beginning-of-line))
:m "$" 'org-end-of-line :m "[[" (λ (call-interactively 'org-backward-heading-same-level) (org-beginning-of-line))
:m "^" 'org-beginning-of-line :m "]l" 'org-next-link
:n "<" 'org-metaleft :m "[l" 'org-previous-link
:n ">" 'org-metaright
:v "<" (λ (org-metaleft) (evil-visual-restore))
:v ">" (λ (org-metaright) (evil-visual-restore))
:n "-" 'org-cycle-list-bullet
:n [tab] 'org-cycle)
(:map org-src-mode-map :n "RET" 'narf/org-dwim-at-point
:n "<escape>" (λ (message "Exited") (org-edit-src-exit)))
(:after org-agenda :m "gh" 'outline-up-heading
(:map org-agenda-mode-map :m "gj" 'org-forward-heading-same-level
:e "<escape>" 'org-agenda-Quit :m "gk" 'org-backward-heading-same-level
:e "C-j" 'org-agenda-next-item :m "gl" (λ (call-interactively 'outline-next-visible-heading) (show-children))
:e "C-k" 'org-agenda-previous-item
:e "C-n" 'org-agenda-next-item :n "go" 'org-open-at-point
:e "C-p" 'org-agenda-previous-item))) :n "gO" (λ (let ((org-link-frame-setup (append '((file . find-file-other-window)) org-link-frame-setup))
(org-file-apps '(("\\.org$" . emacs)
(t . "open \"%s\""))))
(call-interactively 'org-open-at-point)))
:n "gQ" 'org-fill-paragraph
:m "$" 'org-end-of-line
:m "^" 'org-beginning-of-line
:n "<" 'org-metaleft
:n ">" 'org-metaright
:v "<" (λ (org-metaleft) (evil-visual-restore))
:v ">" (λ (org-metaright) (evil-visual-restore))
:n "-" 'org-cycle-list-bullet
:n [tab] 'org-cycle)
(:map org-src-mode-map
:n "<escape>" (λ (message "Exited") (org-edit-src-exit)))
(:after org-agenda
(:map org-agenda-mode-map
:e "<escape>" 'org-agenda-Quit
:e "C-j" 'org-agenda-next-item
:e "C-k" 'org-agenda-previous-item
:e "C-n" 'org-agenda-next-item
:e "C-p" 'org-agenda-previous-item)))
;;; OS-Specific ;;; OS-Specific
(cond (IS-MAC (narf-org-init-for-osx)) (cond (IS-MAC (narf-org-init-for-osx))

View file

@ -22,14 +22,15 @@
:init :init
(associate! nose-mode :pattern "/test_.+\\.py\\'") (associate! nose-mode :pattern "/test_.+\\.py\\'")
:config :config
(bind! :map nose-mode-map (map! :map nose-mode-map
:n ",tr" 'nosetests-again (:localleader
:n ",ta" 'nosetests-all :n "tr" 'nosetests-again
:n ",ts" 'nosetests-one :n "ta" 'nosetests-all
:n ",tv" 'nosetests-module :n "ts" 'nosetests-one
:n ",tA" 'nosetests-pdb-all :n "tv" 'nosetests-module
:n ",tO" 'nosetests-pdb-one :n "tA" 'nosetests-pdb-all
:n ",tV" 'nosetests-pdb-module)) :n "tO" 'nosetests-pdb-one
:n "tV" 'nosetests-pdb-module)))
(use-package anaconda-mode (use-package anaconda-mode
:diminish anaconda-mode :diminish anaconda-mode
@ -39,8 +40,8 @@
(add-hook! python-mode '(anaconda-mode eldoc-mode)) (add-hook! python-mode '(anaconda-mode eldoc-mode))
(setq anaconda-mode-installation-directory (concat narf-temp-dir "anaconda/")) (setq anaconda-mode-installation-directory (concat narf-temp-dir "anaconda/"))
:config :config
(bind! :map anaconda-mode-map :m "gd" 'anaconda-mode-goto-definitions) (map! :map anaconda-mode-map :m "gd" 'anaconda-mode-goto-definitions)
(bind! :map anaconda-nav-mode-map :n [escape] 'anaconda-nav-quit) (map! :map anaconda-nav-mode-map :n [escape] 'anaconda-nav-quit)
(advice-add 'anaconda-mode-doc-buffer :after 'narf*anaconda-mode-doc-buffer) (advice-add 'anaconda-mode-doc-buffer :after 'narf*anaconda-mode-doc-buffer)

View file

@ -5,14 +5,14 @@
:config :config
(require 'pcre2el) (require 'pcre2el)
(setq reb-re-syntax 'pcre) (setq reb-re-syntax 'pcre)
(bind! :map rxt-help-mode-map :n [escape] 'kill-buffer-and-window) (map! :map rxt-help-mode-map :n [escape] 'kill-buffer-and-window)
(add-hook! reb-mode 'narf|reb-cleanup) (add-hook! reb-mode 'narf|reb-cleanup)
(evil-set-initial-state 'reb-mode 'insert) (evil-set-initial-state 'reb-mode 'insert)
(bind! :map reb-mode-map (map! :map reb-mode-map
:n "C-g" 'reb-quit :n "C-g" 'reb-quit
:n [escape] 'reb-quit :n [escape] 'reb-quit
:n [backtab] 'reb-change-syntax)) :n [backtab] 'reb-change-syntax))
(provide 'module-regex) (provide 'module-regex)
;;; module-regex.el ends here ;;; module-regex.el ends here

View file

@ -49,11 +49,12 @@
;; Rake ;; Rake
(("task" "namespace") () "end"))) (("task" "namespace") () "end")))
:config :config
(bind! (:map rspec-mode-map (map! :map rspec-mode-map
:n ",tr" 'rspec-rerun (:localleader
:n ",ta" 'rspec-verify-all :n "tr" 'rspec-rerun
:n ",ts" 'rspec-verify-single :n "ta" 'rspec-verify-all
:n ",tv" 'rspec-verify))) :n "ts" 'rspec-verify-single
:n "tv" 'rspec-verify)))
(use-package inf-ruby (use-package inf-ruby
:commands (inf-ruby inf-ruby-console-auto) :commands (inf-ruby inf-ruby-console-auto)

View file

@ -14,7 +14,9 @@
:config :config
(setq racer-cmd "/usr/local/bin/racer" (setq racer-cmd "/usr/local/bin/racer"
racer-rust-src-path "~/Dropbox/lib/rust/src/") racer-rust-src-path "~/Dropbox/lib/rust/src/")
(bind! :map rust-mode-map :m "gd" 'racer-find-definition) (map! :map rust-mode-map :m "gd" 'racer-find-definition)
;; TODO Unit test keybinds
(add-hook! rust-mode '(racer-mode eldoc-mode flycheck-rust-setup)) (add-hook! rust-mode '(racer-mode eldoc-mode flycheck-rust-setup))
(define-company-backend! rust-mode (racer)))) (define-company-backend! rust-mode (racer))))

View file

@ -14,14 +14,15 @@
(setq-default css-indent-offset 2) (setq-default css-indent-offset 2)
(setq scss-compile-at-save nil) (setq scss-compile-at-save nil)
:config :config
(bind! :map scss-mode-map (map! :map scss-mode-map
:n "M-r" 'narf/web-refresh-browser :n "M-r" 'narf/web-refresh-browser
:n ",;" 'helm-css-scss (:leader
:n ",:" 'helm-css-scss-multi) :n ";" 'helm-css-scss
:n ":" 'helm-css-scss-multi))
(after! web-beautify (after! web-beautify
(add-hook! scss-mode (setenv "jsbeautify_indent_size" "2")) (add-hook! scss-mode (setenv "jsbeautify_indent_size" "2"))
(bind! :map scss-mode-map :m "gQ" 'web-beautify-css)) (map! :map scss-mode-map :m "gQ" 'web-beautify-css))
(after! emr (after! emr
(emr-declare-command 'narf/scss-toggle-inline-or-block (emr-declare-command 'narf/scss-toggle-inline-or-block
@ -36,7 +37,7 @@
:init :init
(after! css-mode (after! css-mode
(add-hook! css-mode (setenv "jsbeautify_indent_size" "2")) (add-hook! css-mode (setenv "jsbeautify_indent_size" "2"))
(bind! :map css-mode-map :m "gQ" 'web-beautify-css))) (map! :map css-mode-map :m "gQ" 'web-beautify-css)))
(use-package jade-mode (use-package jade-mode
:mode "\\.jade$" :mode "\\.jade$"
@ -56,26 +57,26 @@
:config :config
(after! web-beautify (after! web-beautify
(add-hook! web-mode (setenv "jsbeautify_indent_size" "4")) (add-hook! web-mode (setenv "jsbeautify_indent_size" "4"))
(bind! :map web-mode-map :m "gQ" 'web-beautify-html)) (map! :map web-mode-map :m "gQ" 'web-beautify-html))
(after! nlinum (after! nlinum
;; Fix blank line numbers after unfolding ;; Fix blank line numbers after unfolding
(advice-add 'web-mode-fold-or-unfold :after 'nlinum--flush)) (advice-add 'web-mode-fold-or-unfold :after 'nlinum--flush))
(bind! :map web-mode-map (map! :map web-mode-map
"M-/" 'web-mode-comment-or-uncomment "M-/" 'web-mode-comment-or-uncomment
:n "za" 'web-mode-fold-or-unfold :n "za" 'web-mode-fold-or-unfold
:n ",t" 'web-mode-element-rename (:localleader :n "t" 'web-mode-element-rename)
:n "M-r" 'narf/web-refresh-browser :n "M-r" 'narf/web-refresh-browser
:nv "]a" 'web-mode-attribute-next :nv "]a" 'web-mode-attribute-next
:nv "[a" 'web-mode-attribute-previous :nv "[a" 'web-mode-attribute-previous
:nv "]t" 'web-mode-tag-next :nv "]t" 'web-mode-tag-next
:nv "[t" 'web-mode-tag-previous :nv "[t" 'web-mode-tag-previous
:nv "]T" 'web-mode-element-child :nv "]T" 'web-mode-element-child
:nv "[T" 'web-mode-element-parent)) :nv "[T" 'web-mode-element-parent))
(use-package emmet-mode (use-package emmet-mode
:defer t :defer t
@ -85,10 +86,10 @@
(defvar emmet-mode-keymap (make-sparse-keymap)) (defvar emmet-mode-keymap (make-sparse-keymap))
:config :config
(setq emmet-move-cursor-between-quotes t) (setq emmet-move-cursor-between-quotes t)
(bind! :map emmet-mode-keymap (map! :map emmet-mode-keymap
:v "M-e" 'emmet-wrap-with-markup :v "M-e" 'emmet-wrap-with-markup
:i "M-e" 'emmet-expand-yas :i "M-e" 'emmet-expand-yas
:i "M-E" 'emmet-expand-line)) :i "M-E" 'emmet-expand-line))
(define-minor-mode jekyll-mode (define-minor-mode jekyll-mode
"Jekyll development mode." "Jekyll development mode."

View file

@ -6,46 +6,35 @@
(eval-when-compile (require 'core-defuns)) (eval-when-compile (require 'core-defuns))
(bind! ;; See `narf-leader-prefix' & `narf-localleader-prefix' in ../core/core-vars.el
-
(map!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Global keymaps ;; ;; Global keymaps ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
"M-x" 'helm-M-x "M-x" 'helm-M-x
"M-;" 'eval-expression "M-;" 'eval-expression
"M-/" 'evil-commentary-line "M-/" 'evil-commentary-line
"A-x" 'helm-M-x
"A-;" 'eval-expression
"A-/" 'evil-commentary-line
"A-x" 'helm-M-x "M-0" (λ (text-scale-set 0))
"A-;" 'eval-expression "M-=" 'text-scale-increase
"A-/" 'evil-commentary-line "M--" 'text-scale-decrease
(:when window-system "M-b" 'narf:build
"M-0" (λ (text-scale-set 0)) "M-t" 'helm-projectile-find-file
"M-=" 'text-scale-increase "<f9>" 'what-face
"M--" 'text-scale-decrease) "A-`" 'narf-switch-to-iterm
"C-`" 'narf/popup-toggle
"C-~" 'rtog/toggle-repl
"M-b" 'narf:build "M-w" 'evil-window-delete
"M-t" 'helm-projectile-find-file "M-W" 'delete-frame
"A-`" 'narf-switch-to-iterm "M-n" 'narf/new-buffer
"C-`" 'narf/popup-toggle "M-N" 'narf/new-frame
"C-~" 'rtog/toggle-repl
"<f9>" 'what-face
"M-w" 'evil-window-delete
"M-W" 'delete-frame
"M-n" (λ (switch-to-buffer (generate-new-buffer "*new*")))
"M-N" (λ (let ((nlinum-p (and (featurep 'nlinum)
(memq 'nlinum--setup-window window-configuration-change-hook))))
;; Disable nlinum to fix elusive "invalid face linum" bug
(remove-hook 'window-configuration-change-hook 'nlinum--setup-window t)
(let ((frame (new-frame))
(frame-name (format "*new-%s*" (length narf-wg-frames))))
(with-selected-frame frame
(wg-create-workgroup frame-name t)
(add-to-list 'narf-wg-frames (cons frame frame-name))))
(when nlinum-p
(add-hook 'window-configuration-change-hook 'nlinum--setup-window nil t))))
;; Simpler window navigation ;; Simpler window navigation
"C-j" 'evil-window-down "C-j" 'evil-window-down
@ -72,21 +61,6 @@
:m "M-9" (λ (narf:switch-to-workgroup-at-index 8)) :m "M-9" (λ (narf:switch-to-workgroup-at-index 8))
(:when IS-MAC (:when IS-MAC
:ni "M-d" 'dash-at-point
;; Add animated transitions to OSX emacs
"M-w" 'evil-window-delete
"M-W" (λ (let ((data (assq (selected-frame) narf-wg-frames)))
(if data
(progn (wg-delete-workgroup (wg-get-workgroup (cdr data)))
(delete-frame (car data)))
(delete-frame))))
"M-n" (λ (switch-to-buffer (generate-new-buffer "*new*")))
;; Textmate-esque indent shift left/right
:i "M-[" (kbd "C-o m l C-o I DEL C-o ` l")
:i "M-]" (λ (evil-shift-right (point-at-bol) (point-at-eol)))
"<A-left>" 'backward-word "<A-left>" 'backward-word
"<A-right>" 'forward-word "<A-right>" 'forward-word
"<M-backspace>" 'narf/backward-kill-to-bol-and-indent "<M-backspace>" 'narf/backward-kill-to-bol-and-indent
@ -98,7 +72,17 @@
"M-q" 'evil-quit-all "M-q" 'evil-quit-all
"M-z" 'undo "M-z" 'undo
"M-Z" 'redo "M-Z" 'redo
"C-M-f" 'narf:toggle-fullscreen) "C-M-f" 'narf:toggle-fullscreen
:ni "M-d" 'dash-at-point
;; Textmate-esque indent shift left/right
:i "M-[" (kbd "C-o m l C-o I DEL C-o ` l")
:i "M-]" (λ (evil-shift-right (point-at-bol) (point-at-eol)))
;; Restore osx text objects
:i "<A-backspace>" 'evil-delete-backward-word
:i "<A-delete>" (λ (evil-forward-word) (evil-delete-backward-word)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -106,69 +90,67 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:m ";" 'evil-ex :m ";" 'evil-ex
(:leader
:nv "," (λ (if (narf/project-p) (helm-projectile-switch-to-buffer) (helm-buffers-list)))
:nv "<" 'helm-buffers-list
:nv "." 'helm-find-files
:nv ">" 'helm-projectile-find-file-in-known-projects
:nv "/" 'helm-projectile-find-file
:nv ";" 'helm-semantic-or-imenu
:nv ":" 'helm-imenu-in-all-buffers
:nv "]" 'helm-etags-select
:nv "a" 'helm-projectile-find-other-file
:nv "E" (λ (in! narf-emacs-dir (helm-projectile-find-file)))
:nv "m" 'helm-recentf
:nv "M" 'helm-projectile-recentf ; recent PROJECT files
:nv "P" 'helm-projectile-switch-project
:v "=" 'align-regexp
:nv "r" 'emr-show-refactor-menu
:n "R" 'narf/reset-theme
;; <leader> :n "s" (λ (narf:yas-snippets t)) ; ido snippets dir
(:prefix "," :n "h" 'diff-hl-diff-goto-hunk
:nv "," (λ (if (narf/project-p) (helm-projectile-switch-to-buffer) (helm-buffers-list))) :n "e" 'narf/flycheck-errors
:nv "<" 'helm-buffers-list :nv "p" 'helm-show-kill-ring
:nv "." 'helm-find-files
:nv ">" 'helm-projectile-find-file-in-known-projects
:nv "/" 'helm-projectile-find-file
:nv ";" 'helm-semantic-or-imenu
:nv ":" 'helm-imenu-in-all-buffers
:nv "]" 'helm-etags-select :n "b" 'helm-bookmarks
:nv "a" 'helm-projectile-find-other-file :n "w" 'narf:workgroup-display
:nv "E" (λ (in! narf-emacs-dir (helm-projectile-find-file))) :n "W" 'narf:helm-wg
:nv "m" 'helm-recentf
:nv "M" 'helm-projectile-recentf ; recent PROJECT files
:nv "p" 'helm-projectile-switch-project
:v "=" 'align-regexp
:nv "r" 'emr-show-refactor-menu
:nv "qq" 'evil-save-and-quit :nv "n" 'narf/neotree-toggle
:nv "QQ" 'narf/kill-all-buffers-do-not-remember :nv "N" 'narf/neotree-find
:nv "t" 'narf-switch-to-iterm
:nv "l" 'narf/nlinum-toggle
:nv "\\" 'evil-emacs-state
:n "oo" 'narf-open-with :nv "qq" 'evil-save-and-quit
:n "ob" (λ (narf-open-with "Google Chrome")) :nv "QQ" 'narf/kill-all-buffers-do-not-remember
:n "of" (λ (narf-open-with "Finder.app" default-directory))
:n "oF" (λ (narf-open-with "Finder.app" (narf/project-root)))
:n "ou" (λ (narf-open-with "Transmit"))
:n "oU" (λ (narf-open-with "Transmit" default-directory))
:n "ol" (λ (narf-open-with "LaunchBar"))
:n "oL" (λ (narf-open-with "LaunchBar" default-directory))
:n "ot" (λ (narf:tmux-chdir nil t))
:n "oT" 'narf:tmux-chdir
;; Org ;; Open with O/S
:nv "n." (λ (in! org-directory (let ((helm-ff-skip-boring-files t)) (helm-find-files-1 org-directory)))) :n "oo" 'narf-open-with
:nv "n/" 'narf/helm-org :n "ob" (λ (narf-open-with "Google Chrome"))
:nv "np" 'narf/helm-org-projects :n "of" (λ (narf-open-with "Finder.app" default-directory))
:nv "nc" 'narf/helm-org-contacts :n "oF" (λ (narf-open-with "Finder.app" (narf/project-root)))
:nv "ni" 'narf/helm-org-invoices :n "ou" (λ (narf-open-with "Transmit"))
:nv "nw" 'narf/helm-org-writing) :n "oU" (λ (narf-open-with "Transmit" default-directory))
:n "ol" (λ (narf-open-with "LaunchBar"))
:n "oL" (λ (narf-open-with "LaunchBar" default-directory))
:n "ot" (λ (narf:tmux-chdir nil t))
:n "oT" 'narf:tmux-chdir
;; <localleader> ;; Org notes
(:prefix "\\" :nv "x." (λ (in! org-directory (let ((helm-ff-skip-boring-files t)) (helm-find-files-1 org-directory))))
:nv "\\" 'narf/neotree-toggle :nv "x/" 'narf/helm-org
:nv "|" 'narf-switch-to-iterm :nv "xp" 'narf/helm-org-projects
:nv "." 'narf/neotree-find :nv "xc" 'narf/helm-org-contacts
:nv ";" 'narf/nlinum-toggle :nv "xi" 'narf/helm-org-invoices
:nv "E" 'evil-emacs-state :nv "xw" 'narf/helm-org-writing)
:n "]" 'next-buffer (:localleader
:n "[" 'previous-buffer :n "\\" 'narf/neotree-toggle
:n "." 'narf/neotree-find)
:n "c" 'narf/reset-theme :nv "K" 'smart-up
:n "s" (λ (narf:yas-snippets t)) ; ido snippets dir
:n "g" 'diff-hl-diff-goto-hunk
:n "e" (λ (call-interactively 'flycheck-buffer) (flycheck-list-errors))
:n "p" 'helm-show-kill-ring
:n "b" 'helm-bookmarks
:n "w" 'narf:helm-wg
:n "W" 'narf:workgroup-display)
:nv "K" 'smart-up
;; Don't move cursor on indent ;; Don't move cursor on indent
:n "=" (λ (save-excursion (call-interactively 'evil-indent))) :n "=" (λ (save-excursion (call-interactively 'evil-indent)))
@ -195,10 +177,10 @@
:n "g=" 'evil-numbers/inc-at-pt :n "g=" 'evil-numbers/inc-at-pt
:n "g-" 'evil-numbers/dec-at-pt :n "g-" 'evil-numbers/dec-at-pt
:n "gR" 'narf:eval-buffer
:n "gc" 'evil-commentary :n "gc" 'evil-commentary
:n "gx" 'evil-exchange :n "gx" 'evil-exchange
:n "gr" 'narf:eval-region :n "gr" 'narf:eval-region
:n "gR" 'narf:eval-buffer
:v "gR" 'narf:eval-region-and-replace :v "gR" 'narf:eval-region-and-replace
:m "gl" 'avy-goto-line :m "gl" 'avy-goto-line
:m "g]" 'smart-right :m "g]" 'smart-right
@ -242,15 +224,10 @@
(hs-toggle-hiding) (hs-toggle-hiding)
(call-interactively 'evilmi-jump-items))))) (call-interactively 'evilmi-jump-items)))))
;; Restore osx text objects ;; Textmate-esque newlines
:i "<A-backspace>" 'evil-delete-backward-word
:i "<A-delete>" (λ (evil-forward-word) (evil-delete-backward-word))
;; Newline magic
:i "<backspace>" 'backward-delete-char-untabify :i "<backspace>" 'backward-delete-char-untabify
:i "<M-backspace>" 'narf/backward-kill-to-bol-and-indent :i "<M-backspace>" 'narf/backward-kill-to-bol-and-indent
:i "<C-return>" 'evil-ret-and-indent :i "<C-return>" 'evil-ret-and-indent
:i "<C-SPC>" (λ (insert ", "))
;; escape from insert mode (more responsive than using key-chord-define) ;; escape from insert mode (more responsive than using key-chord-define)
:ir "j" 'narf:exit-mode-maybe :ir "j" 'narf:exit-mode-maybe
@ -262,7 +239,7 @@
:n "!" 'rotate-word-at-point :n "!" 'rotate-word-at-point
:v "!" 'rotate-region :v "!" 'rotate-region
:e [escape] 'evil-normal-state :e "<escape>" 'evil-normal-state
(:map evil-window-map ; prefix "C-w" (:map evil-window-map ; prefix "C-w"
"u" 'narf/undo-window-change "u" 'narf/undo-window-change
@ -290,6 +267,7 @@
;; Vim omni-complete emulation ;; Vim omni-complete emulation
:i "C-SPC" 'company-complete-common :i "C-SPC" 'company-complete-common
:i "C-x C-l" 'narf/company-whole-lines
:i "C-x C-k" 'company-dict :i "C-x C-k" 'company-dict
:i "C-x C-f" 'company-files :i "C-x C-f" 'company-files
:i "C-x C-]" 'company-tags :i "C-x C-]" 'company-tags
@ -313,12 +291,12 @@
"C-SPC" 'company-complete-common-or-cycle "C-SPC" 'company-complete-common-or-cycle
[tab] 'narf/company-complete-common-or-complete-full [tab] 'narf/company-complete-common-or-complete-full
"<backtab>" 'company-select-previous "<backtab>" 'company-select-previous
[escape] 'company-abort [escape] (λ (company-abort) (evil-normal-state 1))
"<C-return>" 'helm-company) "<C-return>" 'helm-company)
(:map company-search-map (:map company-search-map
"C-n" 'company-search-repeat-forward "C-n" 'company-search-repeat-forward
"C-p" 'company-search-repeat-backward "C-p" 'company-search-repeat-backward
[escape] 'company-abort)) [escape] 'company-search-abort))
(:after help-mode (:after help-mode
(:map help-mode-map (:map help-mode-map
@ -354,67 +332,67 @@
;; Restores "dumb" indentation to the tab key. This rustles a lot of ;; Restores "dumb" indentation to the tab key. This rustles a lot of
;; peoples' jimmies, apparently, but it's how I like it. ;; peoples' jimmies, apparently, but it's how I like it.
(bind! :i "<tab>" 'narf/dumb-indent (map! :i "<tab>" 'narf/dumb-indent
:i "<C-tab>" 'indent-for-tab-command :i "<C-tab>" 'indent-for-tab-command
;; No dumb-tab for lisp ;; No dumb-tab for lisp
:i :map lisp-mode-map [remap narf/dumb-indent] 'indent-for-tab-command :i :map lisp-mode-map [remap narf/dumb-indent] 'indent-for-tab-command
:i :map emacs-lisp-mode-map [remap narf/dumb-indent] 'indent-for-tab-command :i :map emacs-lisp-mode-map [remap narf/dumb-indent] 'indent-for-tab-command
;; Highjacks space/backspace to: ;; Highjacks space/backspace to:
;; a) delete spaces on either side of the cursor, if present ( | ) -> (|) ;; a) delete spaces on either side of the cursor, if present ( | ) -> (|)
;; b) allow backspace to delete space-indented blocks intelligently ;; b) allow backspace to delete space-indented blocks intelligently
;; c) and not do any of this magic when inside a string ;; c) and not do any of this magic when inside a string
:i "SPC" 'narf/inflate-space-maybe :i "SPC" 'narf/inflate-space-maybe
:i [remap backward-delete-char-untabify] 'narf/deflate-space-maybe :i [remap backward-delete-char-untabify] 'narf/deflate-space-maybe
:i [remap newline] 'narf/newline-and-indent :i [remap newline] 'narf/newline-and-indent
;; Smarter move-to-beginning-of-line ;; Smarter move-to-beginning-of-line
:i [remap move-beginning-of-line] 'narf/move-to-bol :i [remap move-beginning-of-line] 'narf/move-to-bol
;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist
:i "C-e" 'narf/move-to-eol :i "C-e" 'narf/move-to-eol
:i "C-u" 'narf/backward-kill-to-bol-and-indent :i "C-u" 'narf/backward-kill-to-bol-and-indent
;; Fixes delete ;; Fixes delete
:i "<kp-delete>" 'delete-char :i "<kp-delete>" 'delete-char
;; Fix osx keymappings and then some ;; Fix osx keymappings and then some
:i "<M-left>" 'narf/move-to-bol :i "<M-left>" 'narf/move-to-bol
:i "<M-right>" 'narf/move-to-eol :i "<M-right>" 'narf/move-to-eol
:i "<M-up>" 'beginning-of-buffer :i "<M-up>" 'beginning-of-buffer
:i "<M-down>" 'end-of-buffer :i "<M-down>" 'end-of-buffer
:i "<C-up>" 'smart-up :i "<C-up>" 'smart-up
:i "<C-down>" 'smart-down :i "<C-down>" 'smart-down
;; Fix emacs motion keys ;; Fix emacs motion keys
:i "A-b" 'evil-backward-word-begin :i "A-b" 'evil-backward-word-begin
:i "A-w" 'evil-forward-word-begin :i "A-w" 'evil-forward-word-begin
:i "A-e" 'evil-forward-word-end :i "A-e" 'evil-forward-word-end
;; Textmate-esque insert-line before/after ;; Textmate-esque insert-line before/after
:i "<M-return>" 'evil-open-below :i "<M-return>" 'evil-open-below
:i "<S-M-return>" 'evil-open-above :i "<S-M-return>" 'evil-open-above
;; insert lines in-place) ;; insert lines in-place)
:n "<M-return>" (λ (save-excursion (evil-insert-newline-below))) :n "<M-return>" (λ (save-excursion (evil-insert-newline-below)))
:n "<S-M-return>" (λ (save-excursion (evil-insert-newline-above))) :n "<S-M-return>" (λ (save-excursion (evil-insert-newline-above)))
;; Make ESC quit all the things ;; Make ESC quit all the things
:e [escape] 'narf-minibuffer-quit :e [escape] 'narf-minibuffer-quit
(:map (minibuffer-local-map (:map (minibuffer-local-map
minibuffer-local-ns-map minibuffer-local-ns-map
minibuffer-local-completion-map minibuffer-local-completion-map
minibuffer-local-must-match-map minibuffer-local-must-match-map
minibuffer-local-isearch-map) minibuffer-local-isearch-map)
[escape] 'narf-minibuffer-quit) [escape] 'narf-minibuffer-quit)
:map read-expression-map "C-w" 'backward-kill-word) :map read-expression-map "C-w" 'backward-kill-word)
(bind! :i "A-o" (λ (insert "ø")) (map! :i "A-o" (λ (insert "ø"))
:i "A-O" (λ (insert "Ø")) :i "A-O" (λ (insert "Ø"))
:i "A--" (λ (insert "")) :i "A--" (λ (insert ""))
:i "A-_" (λ (insert ""))) :i "A-_" (λ (insert "")))
;; Disable the global drag-mouse map; clicking in new buffers often sends evil ;; Disable the global drag-mouse map; clicking in new buffers often sends evil
;; into visual mode, which is UN...ACCEPTAABBLLLEEEE! ;; into visual mode, which is UN...ACCEPTAABBLLLEEEE!