emenel/doomemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Major overhaul

Browse source
This commit is contained in:
Henrik Lissner 2014-12-10 15:54:36 -05:00
parent 4ab3ae1125
commit 6bda25da1f
76 changed files with 7431 additions and 571 deletions
Download patch file Download diff file Expand all files Collapse all files

89
modules/init-auto-complete.el Normal file
View file

@ -0,0 +1,89 @@
(provide 'init-auto-complete)
(defconst my-dicts-dir (concat my-dir "dict/"))
(setq tags-case-fold-search nil)
(use-package pos-tip)
(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 nil ; Don't show tooltips unless invoked (see core-keymaps.el)
ac-use-fuzzy nil
ac-use-comphist t
ac-candidate-limit 25)
(setq ac-comphist-file (concat my-tmp-dir "ac-comphist.dat"))
(setq-default ac-sources '(ac-source-yasnippet)))
: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)))
(defun auto-complete--backend (hook &rest backends)
(add-hook hook
`(lambda()
(set (make-local-variable 'ac-sources) (append '(,@backends) ac-sources)))))
(global-auto-complete-mode t)
(let ((bg (face-attribute 'default :background)))
(require 'color)
(custom-set-faces
;; `(company-scrollbar-bg ((t (:background ,(color-lighten-name bg 15)))))
;; `(company-scrollbar-fg ((t (:background ,(color-lighten-name bg 5)))))
`(ac-yasnippet-candidate-face ((t (:inherit ac-candidate-face :background ,(color-lighten-name bg 5)))))
`(ac-yasnippet-selection-face ((t (:inherit ac-selection-face :background ,(color-lighten-name bg 10)))))
`(ac-completion-face ((t (:background ,(color-lighten-name bg 15)))))
`(ac-candidate-face ((t (:inherit font-lock-function-name-face :background ,(color-lighten-name bg 4)))))
`(ac-selection-face ((t (:background ,(color-lighten-name bg 9)))))))
(add-to-list 'ac-dictionary-directories my-dicts-dir)
(auto-complete--backend 'emacs-lisp-mode-hook 'ac-source-features 'ac-source-functions 'ac-source-variables 'ac-source-symbols)
(auto-complete--backend 'scss-mode-hook 'ac-source-css-property)
(push '("*Popup Help*" :position bottom :height 0.35 :noselect t) popwin:special-display-config)
;; 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") (λ (let ((ac-sources '(ac-source-filename ac-source-files-in-current-dir)))
(auto-complete)))
(kbd "C-x C-]") 'ac-complete-etags
(kbd "C-x s") 'ac-complete-ispell
(kbd "C-x C-s") 'ac-complete-yasnippet
(kbd "C-x C-n") 'ac-complete-words-in-all-buffer
(kbd "C-x C-p") 'ac-complete-words-in-same-mode-buffers
(kbd "C-x C-o") 'auto-complete
(kbd "C-SPC") 'auto-complete)
(bind ac-completing-map
(kbd "<tab>") 'ac-complete
(kbd "C-n") 'ac-next
(kbd "C-p") 'ac-previous
(kbd "C-h") 'ac-quick-help
(kbd "C-S-h") '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)))))

87
modules/init-auto-insert.el Normal file
View file

@ -0,0 +1,87 @@
(use-package autoinsert
:init (auto-insert-mode 1)
:config
(progn
;; (setq auto-insert-directory "%/.emacs.d/templates/")
(setq auto-insert-query nil) ; Don't prompt before insertion
(setq auto-insert-alist '())))
(after "yasnippet"
(defun template (file-regexp uuid mode &optional project-only)
(define-auto-insert file-regexp `(lambda () (my--template-insert ,uuid ',mode ,project-only))))
(defun my--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/.+\\.el$" "%initfile%" 'emacs-lisp-mode)
(template "\\.emacs\\.d/snippets/.+$" "%%" 'snippet-mode))
(provide 'init-auto-insert)
;;; init-auto-insert.el ends here

174
modules/init-cc.el Normal file
View file

@ -0,0 +1,174 @@
(use-package cmake-mode
:disabled t
:mode "CMakeLists\\.txt$"
:config
(progn
(after "auto-complete" (add-to-list 'ac-modes 'cmake-mode))
(after "company"
(use-package company-cmake
:config (company--backend-on 'cmake-mode-hook 'company-cmake)))))
;; Shaders
(use-package glsl-mode
:mode (("\\.glsl\\'" . glsl-mode)
("\\.vert\\'" . glsl-mode)
("\\.frag\\'" . glsl-mode)
("\\.geom\\'" . glsl-mode)))
(use-package cc-mode
:defer t
:init
(progn
(associate-minor-mode "\\.h$" 'c++-mode)
(associate-minor-mode "\\.mm$" 'objc-mode))
;; (add-hook 'c-mode-hook 'irony-mode)
;; (add-hook 'c++-mode-hook 'irony-mode)
;; (add-hook 'objc-mode-hook 'irony-mode)
;; (add-hook 'irony-mode-hook 'irony-cdb-autosetup-compile-options)
:config
(progn
(setq-default c-basic-offset 4
c-default-style "linux"
c-tab-always-indent nil)
(when is-mac
(setq my--clang-includes
'("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1"
"/usr/local/include"
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.0/include"
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include"
"/usr/include"
"/System/Library/Frameworks"
"/Library/Frameworks"))
(defun my--clang-includes () my--clang-includes)
(defun my--clang-includes-flags ()
(mapcar (lambda (item) (concat "-I" item)) my--clang-includes)))
(progn ; C++
(defun my--setup-c++-mode-flycheck ()
(setq flycheck-clang-language-standard "c++11"
flycheck-clang-standard-library "libc++"
flycheck-c/c++-clang-executable "clang++"
;; flycheck-clang-include-path (my--clang-includes)
))
(after "flycheck"
(add-hook 'c++-mode-hook 'my--setup-c++-mode-flycheck)))
(progn ; Obj-C
(add-to-list 'magic-mode-alist
`(,(lambda ()
(and (string= (file-name-extension buffer-file-name) "h")
(re-search-forward "@\\<interface\\>"
magic-mode-regexp-match-limit t)))
. objc-mode))
(after "flycheck" (add-hook! 'objc-mode-hook (use-package flycheck-objc))))
(after "auto-complete"
(when is-mac (setq ac-clang-flags (my--clang-includes-flags)))
(add-hook! 'c-mode-common-hook
(use-package auto-complete-clang)
(use-package auto-complete-c-headers)
(setq ac-sources
'(ac-source-clang
ac-source-c-headers
ac-source-yasnippet
ac-source-words-in-same-mode-buffers))))
(after "company"
(use-package company-irony
:config
(progn
(use-package company-c-headers
:config (setq company-c-headers-path-system (my--clang-includes)))
(company--backend-on 'c-mode-hook 'company-clang 'company-c-headers)
(company--backend-on 'c++-mode-hook 'company-clang 'company-c-headers)
(company--backend-on 'objc-mode-hook 'company-xcode 'company-c-headers))))
(add-hook! 'c-mode-common-hook
(c-toggle-electric-state -1)
(c-toggle-auto-newline -1)
(c-set-offset 'substatement-open '0) ; brackets should be at same indentation level as the statements they open
(c-set-offset 'inline-open '+)
(c-set-offset 'block-open '+)
(c-set-offset 'brace-list-open '+) ; all "opens" should be indented by the c-indent-level
(c-set-offset 'case-label '+) ; indent case labels by c-indent-level, too
;; DEL mapping interferes with smartparens and my.deflate-maybe
(bind c-mode-map (kbd "DEL") nil))
;; C++11 syntax support (until cc-mode is updated)
(require 'font-lock)
(defun --copy-face (new-face face)
"Define NEW-FACE from existing FACE."
(copy-face face new-face)
(eval `(defvar ,new-face nil))
(set new-face new-face))
(--copy-face 'font-lock-label-face ; labels, case, public, private, proteced, namespace-tags
'font-lock-keyword-face)
(--copy-face 'font-lock-doc-markup-face ; comment markups such as Javadoc-tags
'font-lock-doc-face)
(--copy-face 'font-lock-doc-string-face ; comment markups
'font-lock-comment-face)
(global-font-lock-mode t)
(setq font-lock-maximum-decoration t)
(add-hook 'c++-mode-hook
'(lambda()
;; We could place some regexes into `c-mode-common-hook', but
;; note that their evaluation order matters.
(font-lock-add-keywords
nil '(;; complete some fundamental keywords
("\\<\\(void\\|unsigned\\|signed\\|char\\|short\\|bool\\|int\\|long\\|float\\|double\\)\\>" . font-lock-keyword-face)
;; namespace names and tags - these are rendered as constants by cc-mode
("\\<\\(\\w+::\\)" . font-lock-function-name-face)
;; new C++11 keywords
("\\<\\(alignof\\|alignas\\|constexpr\\|decltype\\|noexcept\\|nullptr\\|static_assert\\|thread_local\\|override\\|final\\)\\>" . font-lock-keyword-face)
("\\<\\(char16_t\\|char32_t\\)\\>" . font-lock-keyword-face)
;; PREPROCESSOR_CONSTANT, PREPROCESSORCONSTANT
("\\<[A-Z]*_[A-Z_]+\\>" . font-lock-constant-face)
("\\<[A-Z]\\{3,\\}\\>" . font-lock-constant-face)
;; hexadecimal numbers
("\\<0[xX][0-9A-Fa-f]+\\>" . font-lock-constant-face)
;; integer/float/scientific numbers
("\\<[\\-+]*[0-9]*\\.?[0-9]+\\([ulUL]+\\|[eE][\\-+]?[0-9]+\\)?\\>" . font-lock-constant-face)
;; c++11 string literals
;; L"wide string"
;; L"wide string with UNICODE codepoint: \u2018"
;; u8"UTF-8 string", u"UTF-16 string", U"UTF-32 string"
("\\<\\([LuU8]+\\)\".*?\"" 1 font-lock-keyword-face)
;; R"(user-defined literal)"
;; R"( a "quot'd" string )"
;; R"delimiter(The String Data" )delimiter"
;; R"delimiter((a-z))delimiter" is equivalent to "(a-z)"
("\\(\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\)" 1 font-lock-keyword-face t) ; start delimiter
( "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\(.*?\\))[^\\s-\\\\()]\\{0,16\\}\"" 1 font-lock-string-face t) ; actual string
( "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(.*?\\()[^\\s-\\\\()]\\{0,16\\}\"\\)" 1 font-lock-keyword-face t) ; end delimiter
;; user-defined types (rather project-specific)
("\\<[A-Za-z_]+[A-Za-z_0-9]*_\\(type\\|ptr\\)\\>" . font-lock-type-face)
("\\<\\(xstring\\|xchar\\)\\>" . font-lock-type-face)
))
) t)
;; Fix enum and C++11 lambda indentation
(defadvice c-lineup-arglist (around my activate)
"Improve indentation of continued C++11 lambda function opened as argument."
(setq ad-return-value
(if (and (equal major-mode 'c++-mode)
(ignore-errors
(save-excursion
(goto-char (c-langelem-pos langelem))
;; Detect "[...](" or "[...]{". preceded by "," or "(",
;; and with unclosed brace.
(looking-at ".*[(,][ \t]*\\[[^]]*\\][ \t]*[({][^}]*$"))))
0 ; no additional indent
ad-do-it))) ; default behavior
))
(provide 'init-cc)
;;; init-cc.el ends here

130
modules/init-company.el Normal file
View file

@ -0,0 +1,130 @@
(provide 'init-company)
(use-package company
:init
(global-company-mode 1)
:config
(progn
(setq company-idle-delay nil)
(setq company-minimum-prefix-length 1)
(setq company-show-numbers nil)
(setq company-tooltip-limit 20)
(setq company-dabbrev-downcase nil)
(setq company-dabbrev-ignore-case nil)
(setq company-tooltip-align-annotations t)
(setq company-require-match 'never)
(setq company-global-modes
'(not eshell-mode comint-mode org-mode erc-mode message-mode help-mode))
(require 'color)
(let ((bg (face-attribute 'default :background)))
(custom-set-faces
`(company-tooltip ((t (:inherit default :background ,(color-lighten-name bg 9)))))
`(company-scrollbar-bg ((t (:background ,(color-lighten-name bg 15)))))
`(company-scrollbar-fg ((t (:background ,(color-lighten-name bg 5)))))
`(company-search ((t (:background ,(color-lighten-name bg 15)))))
`(company-tooltip-selection ((t (:inherit font-lock-function-name-face))))
`(company-tooltip-common ((t (:inherit font-lock-constant-face))))))
;; Sort candidates by
(add-to-list 'company-transformers 'company-sort-by-occurrence)
;; (add-to-list 'company-transformers 'company-sort-by-backend-importance)
(progn ; frontends
(setq-default company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
company-echo-metadata-frontend
company-preview-if-just-one-frontend)))
(progn ; backends
(setq-default company-backends '((company-capf company-yasnippet) (company-dictionary company-keywords)))
(defun company--backend-on (hook &rest backends)
(add-hook hook
`(lambda()
(set (make-local-variable 'company-backends)
(append '((,@backends company-yasnippet)) company-backends)))))
(company--backend-on 'nxml-mode-hook 'company-nxml)
(company--backend-on 'emacs-lisp-mode-hook 'company-elisp)
;; Rewrite evil-complete to use company-dabbrev
(setq company-dabbrev-code-other-buffers t)
(setq company-dabbrev-code-buffers nil)
(setq evil-complete-next-func
(lambda(arg)
(call-interactively 'company-dabbrev)
(if (eq company-candidates-length 1)
(company-complete))))
(setq evil-complete-previous-func
(lambda (arg)
(let ((company-selection-wrap-around t))
(call-interactively 'company-dabbrev)
(if (eq company-candidates-length 1)
(company-complete)
(call-interactively 'company-select-previous)))))
;; Simulates ac-source-dictionary (without global dictionary)
(defconst my-dicts-dir (concat my-dir "dict/"))
(defvar company-dictionary-alist '())
(defun company-dictionary (command &optional arg &rest ignored)
"`company-mode' back-end for programming language keywords."
(interactive (list 'interactive))
(unless company-dictionary-alist
(dolist (file (f-files my-dicts-dir))
(add-to-list 'company-dictionary-alist `(,(intern (f-base file)) ,@(s-split "\n" (f-read file) t)))))
(cl-case command
(interactive (company-begin-backend 'company-dictionary))
(prefix (and (assq major-mode company-dictionary-alist)
(or (company-grab-symbol) 'stop)))
(candidates
(let ((completion-ignore-case nil)
(symbols (cdr (assq major-mode company-dictionary-alist))))
(all-completions arg (if (consp symbols)
symbols
(cdr (assq symbols company-dictionary-alist))))))
(sorted t)))
(progn ; keybinds
(bind 'insert company-mode-map
"C-SPC" 'company-complete-common
"C-x C-k" 'company-dictionary
"C-x C-f" 'company-files
"C-x C-]" 'company-etags
"C-x s" 'company-ispell
"C-x C-s" 'company-yasnippet
"C-x C-o" 'company-complete
"C-x C-n" 'company-dabbrev-code
"C-x C-p" (λ (let ((company-selection-wrap-around t))
(call-interactively 'company-dabbrev-code)
(company-select-previous-or-abort))))
(bind company-active-map
"C-w" nil
"C-o" 'company-search-kill-others
"C-n" 'company-select-next-or-abort
"C-p" 'company-select-previous-or-abort
"C-h" 'company-show-doc-buffer
"C-S-h" 'company-show-location
"C-S-s" 'company-search-candidates
"C-s" 'company-filter-candidates
"C-SPC" 'company-complete-common
[tab] 'company-complete
"<backtab>" 'company-select-previous
[escape] 'company-abort)
(bind company-search-map
"C-n" 'company-search-repeat-forward
"C-p" 'company-search-repeat-backward
[escape] 'company-abort)
;; (bind company-filter-map
;; [escape] 'company-filterd)
(after "helm-company"
(bind company-mode-map "<C-return>" 'helm-company)
(bind company-active-map "<C-return>" 'helm-company))))))

7
modules/init-cscope.el Normal file
View file

@ -0,0 +1,7 @@
(provide 'init-cscope)
(use-package xcscope
:init (cscope-setup)
:config (push '("*cscope*" :position bottom) popwin:special-display-config))
(add-hook 'ruby-mode-hook (function cscope-minor-mode))

28
modules/init-csharp.el Normal file
View file

@ -0,0 +1,28 @@
(provide 'init-csharp)
(use-package omnisharp :defer t
:config
(progn
(setq omnisharp-server-executable-path "~/Dropbox/projects/lib/Omnisharp/server/OmniSharp/bin/Debug/OmniSharp.exe")
(bind 'normal omnisharp-mdoe-map
"gd" 'omnisharp-go-to-definition
"")
(after "company"
(company--backend-on 'csharpmode 'company-omnisharp)
(add-hook 'csharp-mode-hook 'eldoc-mode))
))
(use-package csharp-mode :mode "\\.cs$")
;; (use-package csharp-mode
;; :mode "\\.cs$"
;; :config
;; (bind 'insert csharp-mode-map (kbd "C-SPC") 'omnisharp-auto-complete))
;; :init
;; (add-hook! 'csharp-mode-hook (omnisharp-mode t) (flycheck-mode t)))
;; unity shaders
(use-package shaderlab-mode :mode "\\.shader$")
;; TODO Make more Unity-friendly

42
modules/init-dev.el Normal file
View file

@ -0,0 +1,42 @@
(use-package dash-at-point
:if is-mac
:commands (dash-at-point dash-at-point-with-docset))
(use-package rainbow-delimiters
:commands rainbow-delimiters-mode
:config
(progn
(setq rainbow-delimiters-outermost-only-face-count 1)
(set-face-attribute 'rainbow-delimiters-depth-1-face nil
:foreground 'unspecified
:inherit 'my-outermost-paren-face))
:init
(progn
(add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode)
(add-hook 'js2-mode-hook 'rainbow-delimiters-mode)
(add-hook 'scss-mode-hook 'rainbow-delimiters-mode)
(add-hook 'ruby-mode-hook 'rainbow-delimiters-mode)))
;;; Config modes
(use-package yaml-mode
:defer t
:config (add-hook 'yaml-mode-hook 'enable-tab-width-2))
(use-package emr
:commands (emr-initialize emr-show-refactor-menu)
:init (add-hook 'prog-mode-hook 'emr-initialize)
:config
(progn
(bind 'normal "gR" 'emr-show-refactor-menu)
(bind popup-menu-keymap [escape] 'keyboard-quit)
(after "evil" (evil-ex-define-cmd "ref[actor]" 'emr-show-refactor-menu))))
;; todo's
(use-package hl-todo :init (add-hook 'find-file-hook 'hl-todo-mode))
(use-package helm-todo :commands my:helm-todo-search)
(evil-ex-define-cmd "todo" 'my:helm-todo)
(provide 'init-dev)
;;; init-dev.el ends here

31
modules/init-elisp.el Normal file
View file

@ -0,0 +1,31 @@
(provide 'init-elisp)
(defun remove-elc-on-save ()
"If you're saving an elisp file, likely the .elc is no longer valid."
(make-local-variable 'after-save-hook)
(add-hook 'after-save-hook
(lambda ()
(if (file-exists-p (concat buffer-file-name "c"))
(delete-file (concat buffer-file-name "c"))))))
(add-hook 'after-save-hook 'remove-elc-on-save)
(add-hook 'emacs-lisp-mode-hook 'turn-on-eldoc-mode)
(evil-define-operator my:elisp-eval (beg end)
:move-point nil
(interactive "<r>")
(cond ((and beg end)
(eval-region beg end))
(t (eval-buffer))))
;; Real go-to-definition for elisp
(bind 'motion emacs-lisp-mode-map "gd"
(λ (let ((func (function-called-at-point)))
(if func (find-function func)))))
;; Go-to-definition in other buffer
(bind 'motion emacs-lisp-mode-map "gD"
(λ (let ((func (function-called-at-point)))
(if func (find-function-other-window func)))))
(bind 'motion emacs-lisp-mode-map "g r" 'my:elisp-eval)

48
modules/init-eshell.el Normal file
View file

@ -0,0 +1,48 @@
(provide 'init-eshell)
;; (evil-set-initial-state 'eshell-mode 'emacs)
;; (push '("*eshell*" :position left :width 80 :stick t) popwin:special-display-config)
;; ;; eshell
;; (setq eshell-directory-name (concat my-tmp-dir "eshell"))
;; (setq eshell-scroll-to-bottom-on-input 'all)
;; (setq eshell-buffer-shorthand t)
;; ;; em-alias
;; (setq eshell-aliases-file (concat my-tmp-dir ".eshell-aliases"))
;; ;; em-glob
;; (setq eshell-glob-case-insensitive t)
;; (setq eshell-error-if-no-glob t)
;; ;; em-hist
;; (setq eshell-history-size 1024)
;; ;; plan 9 smart shell
;; ;; (after "esh-module"
;; ;; (add-to-list 'eshell-modules-list 'eshell-smart)
;; ;; (setq eshell-where-to-jump 'begin)
;; ;; (setq eshell-review-quick-commands nil)
;; ;; (setq eshell-smart-space-goes-to-end t))
;; (defun my-current-git-branch ()
;; (let ((branch (car (loop for match in (split-string (shell-command-to-string "git branch") "\n")
;; when (string-match "^\*" match)
;; collect match))))
;; (if (not (eq branch nil))
;; (concat " [" (substring branch 2) "]")
;; "")))
;; (defun my-eshell-prompt ()
;; (concat (propertize (abbreviate-file-name (eshell/pwd)) 'face 'eshell-prompt)
;; (propertize (my-current-git-branch) 'face 'font-lock-function-name-face)
;; (propertize " $ " 'face 'font-lock-constant-face)))
;; ;; em-prompt
;; (setq eshell-prompt-function 'my-eshell-prompt)

12
modules/init-floobits.el Normal file
View file

@ -0,0 +1,12 @@
(use-package floobits
:commands (floobits-join-workspace
floobits-share-dir-public
floobits-share-dir-private
floobits-leave-workspace
floobits-summon
floobits-follow-mode-toggle
floobits-clear-highlights))
(provide 'init-floobits)
;;; init-floobits.el ends here

36
modules/init-fly.el Normal file
View file

@ -0,0 +1,36 @@
(provide 'init-fly)
(use-package flycheck
:defer t
:init (add-hook 'prog-mode-hook 'flycheck-mode)
:config
(progn ; flycheck settings
(setq-default flycheck-indication-mode 'right-fringe
;; Removed checks on idle/change for snappiness
flycheck-check-syntax-automatically '(save mode-enabled)
flycheck-disabled-checkers '(emacs-lisp-checkdoc make))
(my--cleanup-buffers-add "^\\*Flycheck.*\\*$")
(bind 'normal flycheck-error-list-mode-map
[escape] 'kill-this-buffer
"q" 'kill-this-buffer)
(evil-initial-state 'flycheck-error-list-mode 'emacs)
(evil-ex-define-cmd "er[rors]" (λ (flycheck-buffer) (flycheck-list-errors)))
(defun my--evil-flycheck-buffer ()
(if (and (featurep 'flycheck) flycheck-mode)
(flycheck-buffer)))
;; Check buffer when normal mode is entered
(add-hook 'evil-normal-state-entry-hook 'my--evil-flycheck-buffer)
;; And on ESC in normal mode.
(defadvice evil-force-normal-state (after evil-esc-flycheck-buffer activate)
(my--evil-flycheck-buffer))
(push '("^\\*Flycheck.*\\*$" :regexp t :position bottom :height 0.25 :noselect t)
popwin:special-display-config)))
(use-package flyspell :commands flyspell-mode)

113
modules/init-git.el Normal file
View file

@ -0,0 +1,113 @@
(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)))
(use-package 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))
(use-package gitignore-mode
:mode (("/\\.gitignore\\'" . gitignore-mode)
("/\\.git/info/exclude\\'" . gitignore-mode)
("/git/ignore\\'" . gitignore-mode)))
;;
(use-package git-gutter-fringe+
:init (global-git-gutter+-mode +1)
:config
(progn
(evil-ex-define-cmd "gstage" 'git-gutter+-stage-hunks)
(evil-ex-define-cmd "grevert" 'git-gutter+-revert-hunks)
(evil-ex-define-cmd "gdiff" 'git-gutter+-show-hunk)
(fringe-helper-define 'git-gutter-fr+-added nil
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"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......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X......."
"X.......")))
(evil-set-initial-state 'git-commit-mode 'insert)
(evil-set-initial-state 'git-rebase-mode 'insert)

7
modules/init-go.el Normal file
View file

@ -0,0 +1,7 @@
(provide 'init-go)
;; (use-package go-mode
;; :mode "\\.go\\'"
;; :interpreter "go"
;; :init
;; (require 'go-autocomplete))

199
modules/init-helm.el Normal file
View file

@ -0,0 +1,199 @@
(provide 'init-helm)
(use-package helm
:config
(progn ; helm settings
(defvar helm-global-prompt ">>> ")
(setq helm-quick-update t
helm-idle-delay 0.01
helm-input-idle-delay 0.01
helm-reuse-last-window-split-state t
helm-buffers-fuzzy-matching nil
helm-bookmark-show-location t)
(my--cleanup-buffers-add "^\\*[Hh]elm.*\\*$")
(evil-ex-define-cmd "a" 'helm-projectile-find-other-file)
(evil-ex-define-cmd "proj[ect]" 'helm-projectile-switch-project)
(evil-ex-define-cmd "ag" 'my:helm-ag-search)
(evil-ex-define-cmd "ag[cw]d" 'my:helm-ag-search-cwd)
(evil-ex-define-cmd "sw[oop]" 'my:helm-swoop)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package helm-ag
:commands (my:helm-ag-search my:helm-ag-search-cwd helm-ag helm-do-ag my:helm-ag-search)
:config
(progn
;; Ex-mode interface for `helm-ag'. If `bang', then `search' is interpreted as
;; regexp.
(evil-define-operator my:helm-ag-search (beg end &optional bang search pwd-p)
:motion nil
:move-point nil
:type inclusive
:repeat nil
(interactive "<r><!><a>")
(let* ((helm-ag-default-directory (my--project-root pwd-p))
(header-name (format "Search in %s" helm-ag-default-directory))
(input "")
(helm-ag--last-input ""))
(if search
(progn
(helm-attrset 'search-this-file nil helm-ag-source)
(setq helm-ag--last-query
(concat "ag " (unless bang "-Q") " --nogroup --nocolor -- "
(shell-quote-argument search))))
(helm-ag-save-current-context)
(if (and beg end)
(setq input (buffer-substring-no-properties beg end))))
(helm-attrset 'name header-name helm-ag-source)
(helm :sources (if search (helm-ag--select-source) '(helm-source-do-ag))
:buffer "*helm-ag*"
:input input
:prompt helm-global-prompt)))
;; Ex-mode interface for `helm-do-ag'. If `bang', then `search' is interpreted
;; as regexp
(evil-define-operator my:helm-ag-search-cwd (beg end &optional bang search)
:motion nil
:move-point nil
:type inclusive
:repeat nil
(interactive "<r><!><a>")
(my:helm-ag-search beg end search bang t))))
(use-package helm-css-scss ; https://github.com/ShingoFukuyama/helm-css-scss
:commands (helm-css-scss
helm-css-scss-multi
helm-css-scss-insert-close-comment))
(use-package helm-swoop ; https://github.com/ShingoFukuyama/helm-swoop
:commands (my:helm-swoop helm-swoop helm-multi-swoop)
:config
(progn
(setq helm-swoop-use-line-number-face t
helm-swoop-split-with-multiple-windows t
helm-swoop-speed-or-color t
helm-swoop-split-window-function 'popwin:popup-buffer)
;; Ex-mode interface for `helm-swoop', `helm-multi-swoop-all' (if `bang'), or
;; `helm-css-scss' and `helm-css-scss-multi' (if `bang') if major-mode is
;; `scss-mode'
(evil-define-command my:helm-swoop (&optional search bang)
:repeat nil
(interactive "<a><!>")
(if (eq major-mode 'scss-mode)
(if bang (helm-css-scss-multi search) (helm-css-scss search))
(if bang (helm-multi-swoop-all search) (helm-swoop :$query search))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(after "winner"
;; Tell winner-mode to ignore helm buffers
(dolist (bufname '("*helm recentf*"
"*helm projectile*"
"*helm imenu*"
"*helm company*"
"*helm buffers*"
;; "*helm tags*"
"*helm-ag*"
"*Helm Swoop*"))
(push bufname winner-boring-buffers)))
(after "company"
(use-package helm-company
:config
(defun helm-company ()
(interactive)
(unless company-candidates
(company-complete))
(when company-point
(helm :sources 'helm-source-company
:buffer "*helm company*"
:prompt helm-global-prompt
:candidate-number-limit helm-company-candidate-number-limit)))))
(after "projectile"
(use-package helm-projectile
:config
(setq projectile-switch-project-action 'helm-projectile))
;; Don't show the project name in the prompts; I already know.
(defun projectile-prepend-project-name (string)
(format helm-global-prompt string))
;; 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-global-prompt))))
(helm-projectile-command "switch-project" 'helm-source-projectile-projects helm-global-prompt)
(helm-projectile-command "find-file" helm-source-projectile-files-and-dired-list helm-global-prompt)
(helm-projectile-command "find-file-in-known-projects" 'helm-source-projectile-files-in-all-projects-list helm-global-prompt)
(helm-projectile-command "find-file-dwim" 'helm-source-projectile-files-dwim-list helm-global-prompt)
(helm-projectile-command "find-dir" helm-source-projectile-directories-and-dired-list helm-global-prompt)
(helm-projectile-command "recentf" 'helm-source-projectile-recentf-list helm-global-prompt)
(helm-projectile-command "switch-to-buffer" 'helm-source-projectile-buffers-list helm-global-prompt))
(progn ; helm hacks
;; No persistent header
(defadvice helm-display-mode-line (after undisplay-header activate)
(setq header-line-format nil))
;; Reconfigured `helm-recentf' to use `helm', instead of `helm-other-buffer'
(defun helm-recentf ()
(interactive)
(let ((helm-ff-transformer-show-only-basename nil))
(helm :sources '(helm-source-recentf)
:buffer "*helm recentf*"
:prompt helm-global-prompt)))
;; Hide the mode-line in helm (<3 minimalism)
(defun helm-display-mode-line (source &optional force)
(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) ")))
(if helm-mode-line-string
(setq mode-line-format nil)
(setq mode-line-format (default-value 'mode-line-format)))
(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))))
(progn ; popwin
(push '("^\\*helm.*\\*$" :position bottom :regexp t :height 18)
popwin:special-display-config))
(progn ; evil
(evil-set-initial-state 'helm-mode 'emacs)
;; Ex-mode interface for `helm-recentf' and `helm-projectile-recentf'. If
;; `bang', then `search' is interpreted as regexp
(evil-ex-define-cmd "rec[ent]" 'my:helm-recentf)
(evil-define-command my:helm-recentf (&optional bang)
:repeat nil
(interactive "<!>")
(if bang (helm-recentf) (helm-projectile-recentf))))
(bind helm-map
"C-w" 'evil-delete-backward-word
"C-u" 'helm-delete-minibuffer-contents
"C-r" 'evil-ex-paste-from-register ; Evil registers in helm! Glorious!
[escape] 'helm-keyboard-quit)))

40
modules/init-ido.el Normal file
View file

@ -0,0 +1,40 @@
(provide 'init-ido)
;; ido remaps its keys every time it's invoked, this screws with
;; custom mappings. So we've gotta neuter ido.
;; (defun ido-init-completion-maps ())
;; (setq ido-common-completion-map (make-sparse-keymap)
;; ido-file-dir-completion-map (make-sparse-keymap)
;; ido-file-completion-map (make-sparse-keymap)
;; ido-buffer-completion-map (make-sparse-keymap))
;; (set-keymap-parent ido-common-completion-map minibuffer-local-map)
;; (set-keymap-parent ido-file-dir-completion-map ido-common-completion-map)
;; (set-keymap-parent ido-file-completion-map ido-file-dir-completion-map)
;; (set-keymap-parent ido-buffer-completion-map ido-common-completion-map)
(require 'ido-ubiquitous)
(require 'ido-vertical-mode)
(require 'flx-ido)
(ido-mode 1)
(ido-vertical-mode 1)
(ido-everywhere 1)
(ido-ubiquitous-mode 1)
(flx-ido-mode 1)
(setq ido-use-faces nil
ido-confirm-unique-completion t
ido-case-fold t
ido-enable-tramp-completion nil
ido-enable-flex-matching t
ido-create-new-buffer 'always
ido-enable-tramp-completion t
ido-enable-last-directory-history t
ido-save-directory-list-file (concat my-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"))

43
modules/init-java.el Normal file
View file

@ -0,0 +1,43 @@
(provide 'init-java)
(use-package eclim
:commands (eclim-mode global-eclim-mode)
:init
(progn
(setq eclim-eclipse-dirs '("/Applications/eclipse")
eclim-executable "/Applications/eclipse/eclim")
(add-hook 'java-mode-hook 'eclim-mode))
:config
(progn
;; (use-package eclim-ant)
;; (use-package eclim-maven)
(use-package eclim-problems)
(use-package eclim-project)
(use-package eclimd)
(setq help-at-pt-display-when-idle t)
(setq help-at-pt-timer-delay 0.1)
(help-at-pt-set-timer)
(after "company"
(use-package company-emacs-eclim
:init (company-emacs-eclim-setup)))
(after "auto-complete"
(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))))
(bind 'motion java-mode-map "gd" 'eclim-java-find-declaration)))
(use-package groovy-mode
:mode "\\.gradle$"
:config (after "auto-complete" (add-to-list 'ac-modes 'groovy-mode)))
(use-package java-mode
:config
(sp-with-modes '(java-mode)
(sp-local-pair "/**" "*/" :post-handlers '(("* ||\n[i]" "RET")))))

49
modules/init-js.el Normal file
View file

@ -0,0 +1,49 @@
(use-package js2-mode
:mode "\\.js$"
:interpreter "node"
:config
(progn
(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"))
(after "emr" (use-package js2-refactor))
(use-package tern
:commands tern-mode
;; replace auto-complete with tern-ac-complete only in js-mode
:init
(progn
(add-hook 'js2-mode-hook 'tern-mode)
(after "auto-complete" (add-hook 'js2-mode-hook 'tern-ac-setup)))
:config
(progn
(after "auto-complete"
(use-package tern-auto-complete
:config
(progn
(setq tern-ac-on-dot nil)
(bind 'insert js2-mode-map [remap auto-complete] 'tern-ac-complete)
(bind 'motion js2-mode-map "gd" 'tern-find-definition))))
(after "company"
(use-package company-tern
:config
(company--backend-on 'js2-mode-hook 'company-tern)
;; (setq company-tern-meta-as-single-line t)
;; (setq company-tern-property-marker "")
;; (setq company-tooltip-align-annotations t)
))))))
(use-package json-mode
:mode (("\\.json\\'" . json-mode)
("\\.jshintrc\\'" . json-mode)))
(provide 'init-js)
;;; init-js.el ends here

21
modules/init-lua.el Normal file
View file

@ -0,0 +1,21 @@
(provide 'init-lua)
(use-package lua-mode
:mode "\\.lua$"
:interpreter "lua"
:init
(progn
(define-minor-mode love-mode
"Buffer local minor mode for Love2D"
:init-value nil
:lighter " <3"
:keymap (make-sparse-keymap))
(associate-minor-mode "[\\.-]love/.+\\.lua$" 'love-mode)
(add-hook 'lua-mode-hook 'enable-tab-width-2)
(add-hook! 'lua-mode-hook (setq lua-indent-level tab-width))
(defun my--build-love ()
(shell-command (format "open -a love.app %s" (my--project-root))))
))

195
modules/init-org.el Normal file
View file

@ -0,0 +1,195 @@
(provide 'init-org)
;; Defuns
(defun my/org-insert-list-item ()
"Force insertion of org item"
(interactive)
(if (not (org-in-item-p))
(insert "\n- ")
(org-insert-item)))
(defun my/org-eol-call (fun)
"Go to end of line and call provided function"
(end-of-line)
(funcall fun)
(evil-append nil))
(defun my/org-surround (delim)
(insert delim) (save-excursion (insert delim)))
(defun set-buffer-file-format-to-opml ()
(when (string-match "\.opml$" (buffer-file-name))
(setq buffer-file-format '(opml))))
(defun opml-encode (begin end buffer)
"Export Org mode buffer to OPML."
(let ((org-export-show-temporary-export-buffer nil)
(name "*OPML Export Buffer*"))
(org-export-to-buffer 'opml name)
(erase-buffer)
(insert-buffer-substring (get-buffer name))
(point-max)))
;;
(require 'org)
(define-minor-mode evil-org-mode
"Buffer local minor mode for evil-org"
:init-value nil
:lighter " EvilOrg"
:keymap (make-sparse-keymap) ; defines evil-org-mode-map
:group 'evil-org)
(add-hook 'org-mode-hook 'evil-org-mode)
(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"))
;; Remove occur highlights on ESC in normal mode
(defadvice evil-force-normal-state (before evil-esc-org-remove-highlights activate)
(org-remove-occur-highlights))
(setq org-export-backends '(ascii html latex md opml))
(add-hook 'find-file-hooks 'set-buffer-file-format-to-opml)
(add-to-list 'auto-mode-alist '("\\.opml$" . org-mode))
(add-to-list 'format-alist '(opml "Outline Processor Markup Language"
"<[?]xml version=\"1.0\"[^>]*[?]>[\n]?.*[\n]?.*[\n]?<opml version=\"[1|2].0\">"
"~/.emacs.d/elisp/org-opml/opml2org.py" opml-encode t))
(setq org-directory "~/Dropbox/notes"
org-default-notes-file "~/Dropbox/notes/notes.org"
org-mobile-inbox-for-pull "~/Dropbox/notes/notes.org"
org-mobile-directory "~/Dropbox/Apps/MobileOrg"
org-agenda-files '("~/Dropbox/notes")
org-src-tab-acts-natively t)
(setq org-completion-use-ido t
org-hide-leading-stars t
org-todo-keywords
'((sequence "TODO(t)" "|" "DONE(d)")
(sequence "DOING(s)" "PENDING(p)")
(sequence "|" "CANCELLED(c)")))
(org-babel-do-load-languages 'org-babel-load-languages
'((python . t)
(ruby . t)
(sh . t)
(matlab . t)
(latex . t)))
(setq org-tag-alist '(("@work" . ?b)
("@home" . ?h)
("@writing" . ?w)
("@errands" . ?e)
("@drawing" . ?d)
("@coding" . ?c)
("@phone" . ?p)
("@reading" . ?r)
("projects" . ?q)
("easy" . ?0)
("hard" . ?1)))
(setq org-capture-templates
'(("t" "TODO" entry (file+headline "~/Dropbox/notes/gtd.org" "Inbox") "* TODO %? %u\n%i")
("T" "TODO Someday" entry (file+headline "~/Dropbox/notes/gtd.org" "Someday") "* TODO %? %u :someday:\n%i")
("c" "Changelog" entry (file+headline (concat (projectile-project-root) "/CHANGELOG.org") "Unsorted") "** %u %? :unsorted:\n%i" :prepend t)
("i" "Invoice" entry (file+headline "~/Dropbox/notes/invoices.org" "Invoices") "** TODO %?\n%i" :prepend t)
("n" "Note" entry (file+datetree org-default-notes-file) "** %?\n%i")
("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %i%?")
("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\nAdded: %U\n%i")
("a" "Trivia" entry (file "~/Dropbox/notes/trivia.org") "* %u %?\n%i" :prepend t)
("s" "Writing Scraps" entry (file "~/Dropbox/notes/writing.org") "* %u %?\n%i" :prepend t)
("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %u %?\n%i" :prepend t)
("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %u %?\n%i" :prepend t)))
(setq org-agenda-custom-commands
'(("x" agenda)
("y" agenda*)
("w" todo "WAITING")
("W" todo-tree "WAITING")
("to" todo)
("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 "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading))
(kbd "<s-return>") (λ (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 "<S-s-return>") (λ (evil-move-beginning-of-line) (org-insert-heading) (evil-insert-state))
(kbd "<s-return>") (λ (org-insert-heading-after-current) (evil-insert-state))
(kbd "RET") (λ (if (org-entry-is-todo-p) (org-todo 'done)))
(kbd "TAB") 'org-cycle)

10
modules/init-php.el Normal file
View file

@ -0,0 +1,10 @@
(use-package php-mode
:mode "\\.\\(php\\|inc\\)$"
:config
(progn
(add-hook! 'php-mode-hook (setq my-run-code-interpreter "php"))
(setq php-template-compatibility nil)))
(provide 'init-php)
;;; init-php.el ends here

41
modules/init-project.el Normal file
View file

@ -0,0 +1,41 @@
;; Project nav+search tools (projectile, helm, ag)
(provide 'init-project)
(use-package neotree
:commands (neotree-show neotree-hide neotree-toggle)
:config
(progn (setq neo-create-file-auto-open t
neo-smart-open t
neo-persist-show nil)
(add-hook! 'neotree-mode-hook
(setq mode-line-format nil)
(bind evil-motion-state-local-map
(kbd "TAB") 'neotree-enter
(kbd "RET") 'neotree-enter))))
(use-package perspective
:init (persp-mode 1)
:config
(progn
(defun my-kill-persp ()
(interactive)
(persp-kill (persp-name persp-curr)))
(evil-ex-define-cmd "k[ill]persp" 'my-kill-persp)))
(use-package dired
:disabled t
: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)))))

29
modules/init-projectile.el Normal file
View file

@ -0,0 +1,29 @@
(provide 'init-projectile)
(use-package projectile
:pre-load
(setq-default projectile-cache-file (concat my-tmp-dir "projectile.cache")
projectile-known-projects-file (concat my-tmp-dir "projectile.projects")
projectile-enable-caching t
projectile-indexing-method 'alien)
:init
(projectile-global-mode +1)
:config
(progn
(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"))
;; For setting project-specific settings
(defmacro my-project-settings (project-name &rest body)
(declare (indent 1))
`(progn
(add-hook 'find-file-hook
(lambda ()
(when (string-match-p ,project-name (projectile-project-name))
,@body)))))
(after "perspective"
(defvar persp-modestring-dividers '("" " |" ","))
(use-package persp-projectile))))

98
modules/init-python.el Normal file
View file

@ -0,0 +1,98 @@
(provide 'init-python)
(use-package python
:mode ("\\.py\\'" . python-mode)
:interpreter ("python" . python-mode)
:init (setq python-indent-offset 4)
:config
(progn
(setq python-environment-directory my-tmp-dir)
(setq python-shell-interpreter "ipython")
;; Interferes with smartparens
(bind python-mode-map (kbd "DEL") nil)
(use-package anaconda-mode
:init
(progn
(add-hook 'python-mode-hook 'anaconda-mode)
(add-hook 'python-mode-hook 'eldoc-mode)
(add-hook! 'anaconda-mode-hook
(process-buffer (python-shell-get-or-create-process python-shell-interpreter t nil))))
:config
(progn
(bind 'motion anaconda-mode-map "gd" 'anaconda-mode-goto-definitions)
(bind 'normal anaconda-nav-mode-map [escape] 'anaconda-nav-quit)
(push '("*anaconda-doc*" :position bottom :height 15 :noselect t) popwin:special-display-config)
(push '("*anaconda-nav*" :position bottom :height 15 :stick t) popwin:special-display-config)
(push '("^\\*Python.+\\*$" :regexp t :position bottom :height 20 :noselect t) popwin:special-display-config)
;; Delete the window on escape or C-g
(defadvice anaconda-mode-doc-buffer (after anaconda-doc-buffer-escape-to-close activate)
(with-current-buffer (get-buffer "*anaconda-doc*")
(local-set-key [escape] 'anaconda-nav-quit)
(local-set-key [?\C-g] 'anaconda-nav-quit)))
(after "emr"
(emr-declare-command 'anaconda-mode-view-doc
:title "view documentation"
:modes 'python-mode
:predicate (lambda () (and (anaconda-mode-running-p)
(not (use-region-p))
(not (sp-point-in-string-or-comment)))))
(emr-declare-command 'anaconda-mode-goto-assignments
:title "go to assignments"
:modes 'python-mode
:predicate (lambda () (and (anaconda-mode-running-p)
(not (use-region-p))
(not (sp-point-in-string-or-comment)))))
(emr-declare-command 'anaconda-mode-goto-definitions
:title "go to definition"
:modes 'python-mode
:predicate (lambda () (and (anaconda-mode-running-p)
(not (use-region-p))
(not (sp-point-in-string-or-comment)))))
(emr-declare-command 'anaconda-mode-usages
:title "show usages"
:modes 'python-mode
:predicate (lambda () (and (anaconda-mode-running-p)
(not (use-region-p))
(not (sp-point-in-string-or-comment))))))
(after "auto-complete"
(use-package ac-anaconda
:init (add-hook 'python-mode-hook 'ac-anaconda-setup)))
(after "company"
(use-package company-anaconda
:config (company--backend-on 'python-mode-hook 'company-anaconda)))))
(use-package jedi
:disabled t
:config
(progn
(unless (file-directory-p python-environment-directory)
(jedi:install-server))
(add-hook 'python-mode-hook 'jedi:ac-setup)
(bind 'motion python-mode-map "gd" 'jedi:goto-definition)))
(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))
: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))))

29
modules/init-regex.el Normal file
View file

@ -0,0 +1,29 @@
(provide 'init-regex)
(use-package re-builder
:defer t
:config
(progn
(bind 'normal reb-mode-map
[escape] 'reb-quit
(kbd "C-g") 'reb-quit
[backtab] 'reb-change-syntax)
(defun my--reb-cleanup ()
(replace-regexp "^[ \n]*" "" nil (point-min) (point-max))
(text-scale-set 1.5)
(goto-char 2))
(add-hook 'reb-mode-hook 'my--reb-cleanup)
(after "evil"
(evil-set-initial-state 'reb-mode 'insert)
(evil-ex-define-cmd "re[gex]" 're-builder))))
(use-package pcre2el
:config
(progn
(bind 'normal rxt-help-mode-map [escape] 'kill-buffer-and-window)
(after "re-builder" (setq reb-re-syntax 'pcre))
(after "popwin"
(push '("* Regexp Explain *" :position top :height 0.35) popwin:special-display-config))))

109
modules/init-ruby.el Normal file
View file

@ -0,0 +1,109 @@
(provide 'init-ruby)
(use-package ruby-mode
:mode (("\\.rb$" . ruby-mode)
("\\.ru$" . ruby-mode)
("\\.rake$" . ruby-mode)
("\\.gemspec$" . ruby-mode)
("\\.?pryrc$" . ruby-mode)
("Gemfile$" . ruby-mode)
("Capfile$" . ruby-mode)
("Vagrantfile$" . ruby-mode)
("Rakefile$" . ruby-mode))
:interpreter "ruby"
:init
(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
;;; Formatting
(setq ruby-indent-level 2)
(setq ruby-deep-indent-paren t)
(add-hook 'ruby-mode-hook 'enable-tab-width-2)
(define-key ruby-mode-map [?\n] nil)
(after "emr"
(use-package ruby-refactor)
(emr-declare-command 'ruby-refactor-extract-to-method
:title "extract method"
:modes 'ruby-mode
:predicate (lambda () (use-region-p)))
(emr-declare-command 'ruby-refactor-extract-local-variable
:title "extract local variable"
:modes 'ruby-mode
:predicate (lambda () (use-region-p)))
(emr-declare-command 'ruby-refactor-extract-constant
:title "extract constant"
:modes 'ruby-mode
:predicate (lambda () (use-region-p)))
(emr-declare-command 'ruby-refactor-add-parameter
:title "add parameter"
:modes 'ruby-mode)
(emr-declare-command 'ruby-refactor-extract-to-let
:title "extract to let"
:modes 'ruby-mode
:predicate (lambda () (use-region-p))))
(define-minor-mode rake-mode
"Buffer local minor mode for rake files"
:lighter " Rake")
(use-package inf-ruby
:commands (inf-ruby inf-ruby-console-auto)
:config
(progn
(evil-set-initial-state 'inf-ruby-mode 'insert)
(push '(inf-ruby-mode :position bottom :stick t) popwin:special-display-config)
(after "company"
(use-package company-inf-ruby
:config (company--backend-on 'inf-ruby-mode-hook 'company-inf-ruby)))))
(use-package rspec-mode
:defer t
:pre-load
(progn
(defvar rspec-mode-verifiable-map (make-sparse-keymap))
(defvar evilmi-ruby-match-tags
'((("unless" "if") ("elsif" "else") "end")
("begin" ("rescue" "ensure") "end")
("case" ("when" "else") "end")
(("class" "def" "while" "do" "module" "for" "until") () "end")
;; Rake
(("task" "namespace") () "end"))))
:config
(bind 'normal
",tr" 'rspec-rerun
",ta" 'rspec-verify-all
",ts" 'rspec-verify-single
",tv" 'rspec-verify))
(use-package robe
:config
(progn
(after "company"
(use-package company-robe
:config (company--backend-on 'ruby-mode-hook 'company-robe)))
(add-hook! 'ruby-mode-hook
(robe-mode 1)
;; (after "auto-complete" (ac-robe-setup))
(unless robe-running (robe-start 1))
(my--ruby-load-file buffer-file-name))
(defun my--ruby-load-file (&optional file)
(let ((file (or file buffer-file-name)))
(when (and (eq major-mode 'ruby-mode)
(bound-and-true-p robe-running)
(file-exists-p buffer-file-name))
(ruby-load-file file))))
(add-hook 'after-save-hook 'my--ruby-load-file)))))

20
modules/init-scss.el Normal file
View file

@ -0,0 +1,20 @@
(use-package scss-mode
:mode "\\.scss$"
:config
(progn
(add-hook 'scss-mode-hook 'enable-tab-width-2)
(add-hook 'scss-mode-hook 'ac-css-mode-setup)
(setq-default css-indent-offset 2)
(setq scss-compile-at-save nil)
(after "company"
(company--backend-on 'scss-mode-hook 'company-css))))
(use-package rainbow-mode
:defer t
:init (add-hook 'scss-mode-hook 'rainbow-mode))
(provide 'init-scss)
;;; init-scss.el ends here

22
modules/init-sh.el Normal file
View file

@ -0,0 +1,22 @@
(provide 'init-sh)
(after "popwin"
(push '("*ansi-term*" :position bottom :height 0.45 :stick t) popwin:special-display-config)
(push '("*terminal*" :position bottom :height 0.45 :stick t) popwin:special-display-config)
(push '("*Async Shell Command*" :position bottom) popwin:special-display-config))
(my--cleanup-buffers-add "^\\*Shell Command Output\\*$")
(my--cleanup-buffers-add "^\\*Async Shell Command\\*$")
;; Make shell scrips executable on save. Good!
(add-hook 'after-save-hook 'executable-make-buffer-file-executable-if-script-p)
;; Color in *Shell Command Output*
(require 'ansi-color)
(defadvice display-message-or-buffer (before ansi-color activate)
"Process ANSI color codes in shell output."
(let ((buf (ad-get-arg 0)))
(and (bufferp buf)
(string= (buffer-name buf) "*Shell Command Output*")
(with-current-buffer buf
(ansi-color-apply-on-region (point-min) (point-max))))))

10
modules/init-swift.el Normal file
View file

@ -0,0 +1,10 @@
(provide 'init-swift)
(use-package swift-mode
:mode "\\.swift$"
:config
(progn
(after "flycheck" (add-to-list 'flycheck-cehckers 'swift))
(after "company" (company--backend-on 'swift-mode-hook 'company-xcode))))
;; TODO: Set up emacs task runners for fruitstrap

49
modules/init-text.el Normal file
View file

@ -0,0 +1,49 @@
(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))
:pre-load
(progn
;; Implement strike-through formatting
(defvar markdown-regex-del "\\(^\\|[^\\]\\)\\(\\(~\\{2\\}\\)\\([^ \n \\]\\|[^ \n ]\\(?:.\\|\n[^\n]\\)*?[^\\ ]\\)\\(\\3\\)\\)")
(defun markdown-insert-del ()
(interactive)
(let ((delim "~~"))
(if (markdown-use-region-p)
;; Active region
(let ((bounds (markdown-unwrap-things-in-region
(region-beginning) (region-end)
markdown-regex-del 2 4)))
(markdown-wrap-or-insert delim delim nil (car bounds) (cdr bounds)))
;; 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))))))
: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 "<backspace>") nil
(kbd "<M-left>") nil
(kbd "<M-right>") nil
(kbd "s-*") 'markdown-insert-list-item
(kbd "s-b") 'markdown-insert-bold
(kbd "s-i") 'markdown-insert-italic
(kbd "s-`") 'markdown-insert-del)))

34
modules/init-tmux.el Normal file
View file

@ -0,0 +1,34 @@
(provide 'init-tmux)
(defun my--tmux-send (command)
(shell-command (format "tmux send-keys %s" command)))
(after "evil"
(evil-define-interactive-code "<tmux>"
"Ex tmux argument (a mix between <sh> <f> and <fsh>)"
:ex-arg shell
(list (when (evil-ex-p) (evil-ex-file-arg))))
(evil-ex-define-cmd "t" 'ex:tmux-run)
(evil-define-command ex:tmux-run (&optional command bang)
"Sends input to tmux. Use `bang' to append to tmux"
(interactive "<tmux><!>")
(my--tmux-send (format (if bang "C-u %s Enter" "%s")
(shell-quote-argument command)))
(when (evil-ex-p)
(message "[Tmux] %s" command)))
(evil-ex-define-cmd "tcd" 'ex:tmux-chdir)
(evil-define-command ex:tmux-chdir (&optional path bang)
"CDs in tmux using `my--project-root'"
(interactive "<f><!>")
(let ((dir (shell-quote-argument
(if (and path (not (s-blank? path)))
(if (file-directory-p path)
(file-truename path)
(error "Directory doesn't exist %s" path))
(my--project-root bang)))))
(my--tmux-send (format "C-u cd Space %s Enter" (shell-quote-argument dir)))
(when (evil-ex-p)
(message "[Tmux] cd %s" dir)))))

64
modules/init-web.el Normal file
View file

@ -0,0 +1,64 @@
(use-package web-mode
:mode (("\\.\\(p\\)?htm\\(l\\)?$" . web-mode)
("\\.tpl\\(\\.php\\)?$" . web-mode)
("\\.erb$" . web-mode)
("wp-content/themes/.+/.+\\.php$" . web-mode))
:config
(progn
(add-hook 'web-mode-hook 'enable-tab-width-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)
(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
"]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 web-beautify
:commands (web-beautify-js web-beautify-css web-beautify-html)
:config
(progn
(after "scss-mode"
(add-hook! 'scss-mode-hook (setenv "jsbeautify_indent_size" "2"))
(bind 'motion scss-mode-map "gQ" 'web-beautify-css))
(after "web-mode"
(add-hook! 'web-mode-hook (setenv "jsbeautify_indent_size" "4"))
(bind 'motion web-mode-map "gQ" 'web-beautify-html))
(after "js2-mode"
(add-hook! 'js2-mode-hook (setenv "jsbeautify_indent_size" "4"))
(bind 'motion js2-mode-map "gQ" 'web-beautify-js))))
(provide 'init-web)
;;; init-web.el ends here

135
modules/init-yasnippet.el Normal file
View file

@ -0,0 +1,135 @@
(provide 'init-yasnippet)
(use-package yasnippet
:mode (("emacs\\.d/snippets/.+$" . snippet-mode))
:pre-load
(defvar yas-minor-mode-map
;; Fix yasnippet keymaps so they only work in insert mode
(let ((map (make-sparse-keymap)))
(bind 'insert map [(tab)] 'yas-expand)
(bind 'insert map (kbd "TAB") 'yas-expand)
(bind 'visual map (kbd "<backtab>") 'yas-insert-snippet)
map))
:init
(progn
(add-hook 'snippet-mode-hook 'disable-final-newline)
(add-hook 'snippet-mode-hook 'yas-minor-mode)
(add-hook 'text-mode-hook 'yas-minor-mode)
(add-hook 'prog-mode-hook 'yas-minor-mode)
;; (add-hook 'markdown-mode-hook 'yas-minor-mode)
(add-hook 'org-mode-hook 'yas-minor-mode))
:config
(progn
(setq yas-verbosity 0)
(setq yas-indent-line 'auto)
(setq yas-also-auto-indent-first-line t)
(setq yas-wrap-around-region nil)
;; Only load personal snippets
(setq yas-snippet-dirs `(,my-snippets-dir))
(setq yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
(push '(snippet-mode :position bottom :stick t) popwin:special-display-config)
(yas-reload-all)
(after "auto-complete"
(defadvice ac-expand (before advice-for-ac-expand activate)
(when (yas-expand) (ac-stop))))
(after "evil"
;; Exit snippets on ESC in normal mode
(defadvice evil-force-normal-state (before evil-esc-quit-yasnippet activate)
(yas-exit-all-snippets))
;; Once you're in normal mode, you're out
(add-hook 'evil-normal-state-entry-hook 'yas-abort-snippet)
;; Fixes: evil's visual-line mode gobbles up the newline on the right.
;; This prevents that by essentially doing (1- (region-end)).
(defadvice yas-expand-snippet (around yas-expand-snippet-visual-line activate)
(if (evil-visual-line-state-p)
(ad-set-arg 2 (1- (ad-get-arg 2)))) ad-do-it)
;; Fixes: visual-line includes indentation before the selection. This
;; strips it out.
(add-hook! 'yas-before-expand-snippet-hook
(if (evil-visual-line-state-p)
(setq-local yas-selected-text
(replace-regexp-in-string
"\\(^ *\\|\n? $\\)" ""
(buffer-substring-no-properties (region-beginning)
(1- (region-end)))))))
;; Previous hook causes yas-selected-text to persist between expansions.
;; This little hack gets around it.
(add-hook! 'yas-after-exit-snippet-hook
(setq-local yas-selected-text nil))
(evil-ex-define-cmd "snip[pets]" 'ex:snippets)
(evil-define-operator ex:snippets (beg end &optional name)
:motion nil
:move-point nil
:type exclusive
:repeat nil
(interactive "<r><a>")
(if (and beg end)
(yas-insert-snippet)
(if name
(popwin:find-file (concat my-snippets-dir
(symbol-name major-mode) "/" name))
(yas-visit-snippet-file)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Snippet helpers
(defvaralias '% 'yas-selected-text)
;; Shorthand defun to surround text with newlines if more than one line.
(defun !%! ()
(when %
(if (> (s-count-lines %) 1)
(concat "\n" % "\n")
(s-trim %))))
;; Shorthand defun for snippets: prepends a newline to `yas-selected-text'
;; IF it contains more than one line.
(defun !% ()
(when %
(if (> (s-count-lines %) 1)
(concat "\n" %)
(s-trim %))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Inter-field navigation
(defun my/yas-goto-start-of-field ()
(interactive)
(let* ((snippet (car (yas--snippets-at-point)))
(position (yas--field-start (yas--snippet-active-field snippet))))
(if (= (point) position)
(move-beginning-of-line 1)
(goto-char position))))
(defun my/yas-goto-end-of-field ()
(interactive)
(let* ((snippet (car (yas--snippets-at-point)))
(position (yas--field-end (yas--snippet-active-field snippet))))
(if (= (point) position)
(move-end-of-line 1)
(goto-char position))))
;; Prevents Yas from stepping on my toes when I use backspace
(defun my/yas-clear-field (&optional field)
(interactive)
(let ((field (or field (and yas--active-field-overlay
(overlay-buffer yas--active-field-overlay)
(overlay-get yas--active-field-overlay 'yas--field)))))
(cond ((and field
(not (yas--field-modified-p field))
(eq (point) (marker-position (yas--field-start field))))
(yas--skip-and-clear field)
(yas-next-field 1))
(t (delete-char -1)))))
;; keybinds
(bind yas-keymap
"C-e" 'my/yas-goto-end-of-field
"C-a" 'my/yas-goto-start-of-field
"<s-right>" 'my/yas-goto-end-of-field
"<s-left>" 'my/yas-goto-start-of-field
[backspace] 'my/yas-clear-field)))