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

Rewrote initfiles

Browse source
This commit is contained in:
Henrik Lissner 2014-08-21 03:33:30 -04:00
parent a58f4246ba
commit e0c72477ae
16 changed files with 345 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

2
init.el
View file

@ -47,5 +47,5 @@
mod-cpp ; C++ gamedev mod-cpp ; C++ gamedev
mod-eclim ; Integration into eclipse (for Java) mod-eclim ; Integration into eclipse (for Java)
mod-csharp ; Emacs as a Csharp/Unity IDE mod-csharp ; Emacs as a Csharp/Unity IDE
mod-collab ; For collab programming ;; mod-collab ; For collab programming
)) ))

17
init/core-editor.el
View file

@ -1,7 +1,16 @@
;;;; Editor behavior ;;;;;;;;;;;;;;;; ;;;; Editor behavior ;;;;;;;;;;;;;;;;
(setq initial-scratch-buffer nil) ; empty scratch buffer ;; (electric-indent-mode +1) ; auto-indent on RET
(electric-indent-mode +1) ; auto-indent on RET ;; (defun disable-electric-indent-mode ()
(global-hl-line-mode +1) ; highlight the line ;; (set (make-local-variable 'electric-indent-mode) nil)
;; (setq-local tab-always-indent t))
;; ;; Only enable electric-mode in programming languages
;; (add-hook 'text-mode-hook 'disable-electric-indent-mode)
;; (add-hook 'org-mode-hook 'disable-electric-indent-mode)
;; (add-hook 'markdown-mode-hook 'disable-electric-indent-mode)
;; (global-hl-line-mode +1) ; highlight the line
(blink-cursor-mode -1)
(setq-default (setq-default
tab-width 4 ; set tab width to 4 for all buffers tab-width 4 ; set tab width to 4 for all buffers
indent-tabs-mode nil ; use tabs, not spaces indent-tabs-mode nil ; use tabs, not spaces
@ -28,13 +37,13 @@
(evil-mode 1) (evil-mode 1)
(use-package evil-leader :ensure t) (use-package evil-leader :ensure t)
(use-package evil-nerd-commenter :ensure t)
(use-package evil-matchit :ensure t) (use-package evil-matchit :ensure t)
(use-package evil-surround :ensure t) (use-package evil-surround :ensure t)
(use-package evil-numbers :ensure t) (use-package evil-numbers :ensure t)
(use-package evil-exchange :ensure t) (use-package evil-exchange :ensure t)
(use-package evil-space :ensure t) (use-package evil-space :ensure t)
(use-package evil-visualstar :ensure t) (use-package evil-visualstar :ensure t)
(use-package evil-nerd-commenter :ensure t)
(use-package evil-ex-registers) (use-package evil-ex-registers)
;; To get evil-leader mappings to work in the messages buffer... ;; To get evil-leader mappings to work in the messages buffer...

212
init/core-keymaps.el
View file

@ -12,28 +12,30 @@
(kbd "C-c l") 'send-to-launchbar (kbd "C-c l") 'send-to-launchbar
(kbd "C-c L") 'send-dir-to-launchbar (kbd "C-c L") 'send-dir-to-launchbar
(kbd "C-c t") 'my/tmux-chdir (kbd "C-c t") 'my/tmux-chdir
(kbd "C-c T") (λ (my/tmux-chdir (projectile-project-root))) (kbd "C-c T") (λ (my/tmux-chdir (projectile-project-root))))
)
;; Evaluating elisp ;; Evaluating elisp
(nmap my/mode-map (kbd "C-c x") 'eval-buffer) (nmap my/mode-map (kbd "C-c x") 'eval-buffer)
(vmap my/mode-map (kbd "C-c x") 'eval-region) (vmap my/mode-map (kbd "C-c x") 'eval-region)
(when window-system (when window-system
(global-set-key (kbd "s-=") 'text-scale-increase) (global-set-key (kbd "s-=") 'text-scale-increase)
(global-set-key (kbd "s--") 'text-scale-decrease) (global-set-key (kbd "s--") 'text-scale-decrease)
(global-set-key (kbd "s-/") 'evilnc-comment-or-uncomment-lines) (global-set-key (kbd "s-w") 'evil-window-delete)
(global-set-key (kbd "s-w") 'evil-window-delete) (global-set-key (kbd "s-/") 'evilnc-comment-or-uncomment-lines)
(global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen) (global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
(nmap my/mode-map ;; Faster scrolling
;; Faster scrolling (mapc (lambda(map)
(kbd "s-j") "5j" (evil-define-key map my/mode-map (kbd "s-j") "5j")
(kbd "s-k") "5k" (evil-define-key map my/mode-map (kbd "s-k") "5k"))
'(emacs normal visual))
(nmap my/mode-map
;; Leader alternatives ;; Leader alternatives
(kbd "s-f") 'projectile-find-file (kbd "s-f") 'projectile-find-file
(kbd "s-F") 'projectile-ag (kbd "s-F") 'projectile-ag
(kbd "s-p") 'projectile-switch-project
(kbd "s-m") 'my/recentf-ido-find-file (kbd "s-m") 'my/recentf-ido-find-file
(kbd "s-M") 'projectile-recentf (kbd "s-M") 'projectile-recentf
(kbd "s-o") 'ido-find-file (kbd "s-o") 'ido-find-file
@ -43,8 +45,8 @@
(kbd "C-s-'") 'mc/mark-all-like-this (kbd "C-s-'") 'mc/mark-all-like-this
(kbd "s-d") 'dash-at-point) (kbd "s-d") 'dash-at-point)
;; Newlines from insert mode
(imap my/mode-map (imap my/mode-map
;; Textmate-esque insert-line before/after
(kbd "<s-return>") 'evil-open-below (kbd "<s-return>") 'evil-open-below
(kbd "<S-s-return>") 'evil-open-above (kbd "<S-s-return>") 'evil-open-above
@ -56,106 +58,114 @@
;; Fixes delete ;; Fixes delete
(kbd "<kp-delete>") 'delete-char))) (kbd "<kp-delete>") 'delete-char)))
;; Local keymaps ;;;;;;;;;;;;;;;; ;; Local keymaps ;;;;;;;;;;;;;;;;
(evil-leader/set-leader ",") (evil-leader/set-leader ",")
(evil-leader/set-key (evil-leader/set-key
"`" 'my/notes "`" 'my/notes
"'" 'mc/mark-next-like-this "'" 'mc/mark-next-like-this
"\"" 'mc/mark-all-like-this "\"" 'mc/mark-all-like-this
"e" 'ido-find-file "e" 'ido-find-file
"E" 'my/initfiles "E" 'my/initfiles
"d" 'dash-at-point "d" 'dash-at-point
"f" 'projectile-find-file "f" 'projectile-find-file
"F" 'projectile-ag "F" 'projectile-ag
"g" 'git-gutter:stage-hunk "g" 'git-gutter:stage-hunk
"G" 'git-gutter:revert-hunk "G" 'git-gutter:revert-hunk
;; "m" 'helm-recentf ; recent GLOBAL files "m" 'my/recentf-ido-find-file ; recent GLOBAL files
"m" 'my/recentf-ido-find-file ; recent GLOBAL files "M" 'projectile-recentf ; recent PROJECT files
"M" 'projectile-recentf ; recent PROJECT files "p" 'projectile-switch-project
"p" 'projectile-switch-project "\\" 'neotree-show
"/" 'evilnc-comment-or-uncomment-lines "|" 'neotree-hide
"\\" 'neotree-show ";" 'helm-imenu
"|" 'neotree-hide ":" 'my/ido-goto-symbol
";" 'helm-imenu "," 'ido-switch-buffer
":" 'my/ido-goto-symbol "=" 'align-regexp
"," 'ido-switch-buffer "x" 'my/kill-other-buffers
"=" 'align-regexp "X" 'my/kill-all-buffers
"x" 'my/kill-other-buffers (kbd "RET") 'org-capture)
"X" 'my/kill-all-buffers
(kbd "RET") 'org-capture) ;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use
;; define-key instead of n/vmap for this one to register.
(define-key evil-normal-state-map ";" 'evil-ex)
(define-key evil-visual-state-map ";" 'evil-ex)
(nmap my/mode-map (nmap my/mode-map
";" 'evil-ex ; Remap ; to : - SPC and shift-SPC replace ; and , (kbd "C-;") 'eval-expression ; Elisp command
(kbd "C-;") 'eval-expression ; Elisp command (kbd "s-;") 'my/tmux-run
(kbd "s-:") 'my/tmux-paste
;; Moving rows rather than lines (in case of wrapping) ;; Moving rows rather than lines (in case of wrapping)
"j" 'evil-next-visual-line "j" 'evil-next-visual-line
"k" 'evil-previous-visual-line "k" 'evil-previous-visual-line
"X" 'evil-destroy ; Delete without yanking "X" 'evil-destroy ; Delete without yanking
;; copy to end of line ;; behave like D and C; yank to end of line
"Y" (λ (evil-yank (point) (point-at-eol))) "Y" (λ (evil-yank (point) (point-at-eol)))
"zz" 'kill-this-buffer ; Close buffer "zz" 'kill-this-buffer ; Close buffer
"]b" 'previous-buffer "]b" 'previous-buffer
"[b" 'next-buffer "[b" 'next-buffer
"]e" 'next-error "]e" 'next-error
"[e" 'previous-error "[e" 'previous-error
"]g" 'git-gutter:next-hunk "]h" 'git-gutter:next-hunk
"[g" 'git-gutter:previous-hunk "[h" 'git-gutter:previous-hunk
;; winner-mode: window layout undo/redo (see init-core.el) ;; winner-mode: window layout undo/redo (see init-core.el)
(kbd "C-w u") 'winner-undo (kbd "C-w u") 'winner-undo
(kbd "C-w C-r") 'winner-redo (kbd "C-w C-r") 'winner-redo
;; Increment/decrement number under cursor ;; Increment/decrement number under cursor
(kbd "C--") 'evil-numbers/inc-at-pt (kbd "C--") 'evil-numbers/inc-at-pt
(kbd "C-+") 'evil-numbers/dec-at-pt) (kbd "C-+") 'evil-numbers/dec-at-pt)
(vmap my/mode-map (vmap my/mode-map
; vnoremap < <gv ;; vnoremap < <gv
"<" (λ (evil-shift-left (region-beginning) (region-end)) "<" (λ (evil-shift-left (region-beginning) (region-end))
(evil-normal-state) (evil-normal-state)
(evil-visual-restore)) (evil-visual-restore))
; vnoremap > >gv ;; vnoremap > >gv
">" (λ (evil-shift-right (region-beginning) (region-end)) ">" (λ (evil-shift-right (region-beginning) (region-end))
(evil-normal-state) (evil-normal-state)
(evil-visual-restore))) (evil-visual-restore)))
(imap my/mode-map (imap my/mode-map
(kbd "s-j") 'evil-join ;; Make DEL act like expandtab in vim
(kbd "M-SPC") 'expand-space (kbd "DEL") 'backward-delete-whitespace-to-column
(kbd "<C-return>") 'indent-new-comment-line) ;; Join lines from insert mode
(kbd "<M-kp-delete>") 'evil-join
;; Newline magic
(kbd "RET") 'newline-and-indent
(kbd "M-RET") (kbd "RET DEL")
(kbd "<C-return>") 'indent-new-comment-line
;; Textmate-esque indent shift left/right
(kbd "s-[") (λ (evil-shift-left (point-at-bol) (point-at-eol)))
(kbd "s-]") (λ (evil-shift-right (point-at-bol) (point-at-eol)))
(kbd "<backtab>") (kbd "S-["))
(emap my/mode-map (emap my/mode-map
;; Preserve buffer-movement in emacs mode ;; Preserve buffer-movement in emacs mode
"j" 'evil-next-line "j" 'evil-next-line
"k" 'evil-previous-line "k" 'evil-previous-line
(kbd "C-w h") 'evil-window-left (kbd "C-w h") 'evil-window-left
(kbd "C-w l") 'evil-window-right (kbd "C-w l") 'evil-window-right
(kbd "C-w j") 'evil-window-down (kbd "C-w j") 'evil-window-down
(kbd "C-w k") 'evil-window-up (kbd "C-w k") 'evil-window-up)
(kbd "s-j") "5j"
(kbd "s-k") "5k")
;; Commenting lines
(nmap my/mode-map "gcc" 'evilnc-comment-or-uncomment-lines)
(vmap my/mode-map "gc" 'evilnc-comment-or-uncomment-lines)
;; Rotate-text (see elisp/rotate-text.el) ;; Rotate-text (see elisp/rotate-text.el)
(nmap my/mode-map "!" 'rotate-word-at-point) (nmap my/mode-map "!" 'rotate-word-at-point)
(vmap my/mode-map "!" 'rotate-region) (vmap my/mode-map "!" 'rotate-region)
;; Enable TAB to do matchit
(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
;; Easy escape from insert mode ;; Easy escape from insert mode
(ichmap "jj" 'evil-normal-state) (ichmap "jj" 'evil-normal-state)
;; Enable TAB to do matchit
(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
;; Real go-to-definition for elisp
(nmap emacs-lisp-mode-map "gd" (nmap emacs-lisp-mode-map "gd"
(λ (let ((func (function-called-at-point))) (λ (let ((func (function-called-at-point)))
(if func (find-function func))))) (if func (find-function func)))))
@ -168,16 +178,14 @@
;;;; Keymap fixes ;;;;;;;;;;;;;;; ;;;; Keymap fixes ;;;;;;;;;;;;;;;
;; Make ESC quit all the things ;; Make ESC quit all the things
(nmap my/mode-map [escape] 'keyboard-quit) (nvmap my/mode-map [escape] 'keyboard-quit)
(vmap my/mode-map [escape] 'keyboard-quit)
(mapc (lambda (map) (mapc (lambda (map)
(define-key map [escape] 'minibuffer-quit)) (define-key map [escape] 'minibuffer-quit))
(list (list minibuffer-local-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))
(global-set-key [escape] 'evil-exit-emacs-state) (global-set-key [escape] 'evil-exit-emacs-state)
;; Close help window with escape ;; Close help window with escape
(define-key global-map [escape] 'quit-window) (define-key global-map [escape] 'quit-window)
@ -196,9 +204,7 @@
;; take that "Text is read-only" and stick it where emacs don't shine! ;; take that "Text is read-only" and stick it where emacs don't shine!
(define-key ido-completion-map (kbd "<backspace>") 'ido-delete-backward-updir) (define-key ido-completion-map (kbd "<backspace>") 'ido-delete-backward-updir)
(define-key ido-completion-map "\C-n" 'ido-next-match) (define-key ido-completion-map "\C-n" 'ido-next-match)
(define-key ido-completion-map "\C-f" 'ido-next-match)
(define-key ido-completion-map "\C-p" 'ido-prev-match) (define-key ido-completion-map "\C-p" 'ido-prev-match)
(define-key ido-completion-map "\C-b" 'ido-prev-match)
;; Auto-complete on tab/space (why is it called ido-exit-minibuffer?) ;; Auto-complete on tab/space (why is it called ido-exit-minibuffer?)
(define-key ido-completion-map " " 'ido-exit-minibuffer))) (define-key ido-completion-map " " 'ido-exit-minibuffer)))
@ -218,5 +224,21 @@
(when (get-buffer "*Completions*") (delete-windows-on "*Completions*")) (when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
(abort-recursive-edit))) (abort-recursive-edit)))
;; Mimic expandtab in vim
(defun backward-delete-whitespace-to-column ()
"delete back to the previous column of whitespace, or as much whitespace as possible,
or just one char if that's not possible"
(interactive)
(if indent-tabs-mode
(call-interactively 'backward-delete-char-untabify)
(let ((movement (% (current-column) tab-width))
(p (point)))
(when (= movement 0) (setq movement tab-width))
(save-match-data
(if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p))
(backward-delete-char-untabify (- (match-end 1) (match-beginning 1)))
(call-interactively 'backward-delete-char-untabify))))))
;; ;;
(provide 'core-keymaps) (provide 'core-keymaps)

19
init/core.el
View file

@ -24,7 +24,8 @@
inhibit-startup-buffer-menu t inhibit-startup-buffer-menu t
inhibit-startup-echo-area-message t inhibit-startup-echo-area-message t
initial-major-mode 'text-mode initial-major-mode 'text-mode
initial-scratch-message nil) initial-scratch-message nil
initial-scratch-buffer nil) ; empty scratch buffer
(setq require-final-newline nil) (setq require-final-newline nil)
@ -40,23 +41,17 @@
;; window layout undo/redo, keymaps in core-keymaps.el ;; window layout undo/redo, keymaps in core-keymaps.el
(when (fboundp 'winner-mode) (winner-mode 1)) (when (fboundp 'winner-mode) (winner-mode 1))
(defconst is-mac (defconst is-mac (eq system-type 'darwin))
(eq system-type 'darwin) (defconst is-linux (eq system-type 'gnu/linux))
"Is this running on OS X?")
(defconst is-linux
(eq system-type 'gnu/linux)
"Is this running on Linux?")
;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;; ;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;;
;; Make next/previous-buffer skip special buffers ;; Make next/previous-buffer skip special buffers
(defadvice next-buffer (after avoid-messages-buffer-in-next-buffer) (defadvice next-buffer (after avoid-messages-buffer-in-next-buffer)
"Advice around `next-buffer' to avoid going into the *Messages* buffer." "Advice around `next-buffer' to avoid going into the *Messages* buffer."
(when (string= "*Messages*" (buffer-name)) (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (next-buffer)))
(next-buffer)))
(defadvice previous-buffer (after avoid-messages-buffer-in-previous-buffer) (defadvice previous-buffer (after avoid-messages-buffer-in-previous-buffer)
"Advice around `previous-buffer' to avoid going into the *Messages* buffer." "Advice around `previous-buffer' to avoid going into the *Messages* buffer."
(when (string= "*Messages*" (buffer-name)) (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (previous-buffer)))
(previous-buffer)))
;;;; My personal minor mode ;;;;;;;; ;;;; My personal minor mode ;;;;;;;;
(defvar my/mode-map (make-sparse-keymap)) (defvar my/mode-map (make-sparse-keymap))
@ -66,7 +61,7 @@
(require 'core-packages) (require 'core-packages)
(require 'core-ui) (require 'core-ui)
(require 'core-editor) (require 'core-editor)
(when is-mac (require 'core-osx)) (if is-mac (require 'core-osx))
(add-hook 'after-init-hook (lambda() (require 'core-keymaps))) (add-hook 'after-init-hook (lambda() (require 'core-keymaps)))

3
init/init-ac.el
View file

@ -35,8 +35,7 @@
(define-key ac-completing-map [return] nil) (define-key ac-completing-map [return] nil)
;; Tell ido not to care about case ;; Tell ido not to care about case
(setq completion-ignore-case t) (setq completion-ignore-case t)))
))
;; ;;
(provide 'init-ac) (provide 'init-ac)

1
init/init-fly.el
View file

@ -1,5 +1,4 @@
(use-package flycheck :ensure t (use-package flycheck :ensure t
:commands global-flycheck-mode
:init (add-hook 'after-init-hook #'global-flycheck-mode) :init (add-hook 'after-init-hook #'global-flycheck-mode)
:config :config
(progn (progn

6
init/init-project.el
View file

@ -10,9 +10,9 @@
dired-dwim-target t)))) dired-dwim-target t))))
(use-package ag :ensure t :defer t) (use-package ag :ensure t :defer t)
;; (use-package helm :ensure t :defer t) (use-package helm :ensure t :defer t)
(use-package grizzl :ensure t :defer t) (use-package grizzl :ensure t :defer t)
(use-package neotree :commands (neotree-show neotree-hide neotree-toggle)) (use-package neotree :ensure t :commands (neotree-show neotree-hide neotree-toggle))
(use-package projectile :ensure t (use-package projectile :ensure t
:diminish projectile-mode :diminish projectile-mode
@ -22,7 +22,7 @@
projectile-enable-caching t))) projectile-enable-caching t)))
(use-package ido (use-package ido
:pre-load :init
(progn (progn
;; ido remaps its keys every time it's invoked, this screws with ;; ido remaps its keys every time it's invoked, this screws with
;; custom mappings. So we've gotta neuter ido. ;; custom mappings. So we've gotta neuter ido.

1
init/init-snippets.el
View file

@ -25,6 +25,7 @@
(progn (progn
(add-hook 'prog-mode-hook 'yas-minor-mode) (add-hook 'prog-mode-hook 'yas-minor-mode)
(add-hook 'snippet-mode-hook 'yas-minor-mode) (add-hook 'snippet-mode-hook 'yas-minor-mode)
(add-hook 'markdown-mode-hook 'yas-minor-mode)
(add-hook 'org-mode-hook 'yas-minor-mode))) (add-hook 'org-mode-hook 'yas-minor-mode)))
;; ;;

12
init/mod-cpp.el
View file

@ -17,5 +17,17 @@
("\\.frag\\'" . glsl-mode) ("\\.frag\\'" . glsl-mode)
("\\.geom\\'" . glsl-mode))) ("\\.geom\\'" . glsl-mode)))
(define-minor-mode cocos2d-mode
"Buffer local minor mode for Cocos2D-x"
:init-value nil
:lighter " C2D"
:keymap (make-sparse-keymap))
(defun cocoa2d-mode-maybe()
(let ((root (projectile-project-root)))
(if (or (string-match "[.-]cocos2d/" root)
(file-exists-p (concat root ".cocos2d-mode")))
(cocos-mode t))))
;; ;;
(provide 'mod-cpp) (provide 'mod-cpp)

9
init/mod-dev.el
View file

@ -1,3 +1,5 @@
(add-hook 'prog-mode-hook 'my/enable-comment-hard-wrap)
(add-to-list 'auto-mode-alist '("\\.plist\\'" . nxml-mode)) (add-to-list 'auto-mode-alist '("\\.plist\\'" . nxml-mode))
(use-package dash-at-point :ensure t (use-package dash-at-point :ensure t
@ -8,7 +10,11 @@
(add-to-list 'dash-at-point-mode-alist '(ruby-mode . "rb")) (add-to-list 'dash-at-point-mode-alist '(ruby-mode . "rb"))
(add-to-list 'dash-at-point-mode-alist '(python-mode . "py2")))) (add-to-list 'dash-at-point-mode-alist '(python-mode . "py2"))))
(use-package yaml-mode :ensure t :mode "\\.yaml\\'") (use-package yaml-mode :ensure t
:defer t
:config
(defun my/setup-yaml-mode () (setq tab-width 2))
(add-hook 'yaml-mode-hook 'my/setup-yaml-mode))
(use-package json-mode :ensure t (use-package json-mode :ensure t
:mode (("\\.json\\'" . json-mode) :mode (("\\.json\\'" . json-mode)
@ -63,6 +69,5 @@
(my/setup-run-code ruby-mode-map "ruby") (my/setup-run-code ruby-mode-map "ruby")
(nmap ruby-mode-map "gd" 'rsense-jump-to-definition))) (nmap ruby-mode-map "gd" 'rsense-jump-to-definition)))
;; ;;
(provide 'mod-dev) (provide 'mod-dev)

23
init/mod-love.el
View file

@ -1,28 +1,27 @@
(use-package lua-mode :ensure t (use-package lua-mode :ensure t
:mode "\\.lua\\'" :mode "\\.lua\\'"
:interpreter "lua" :interpreter "lua"
:config
(my/setup-run-code lua-mode-map "lua")
:init :init
(progn (progn
(define-minor-mode love-mode (define-minor-mode love-mode
"Buffer local minor mode for evil-org" "Buffer local minor mode for Love2D"
:init-value nil :init-value nil
:lighter " <3" :lighter " <3"
:keymap (make-sparse-keymap) ; defines love-mode-map :keymap (make-sparse-keymap) ; defines love-mode-map
:group lua) :group lua)
(define-key love-mode-map (kbd "s-b") (nmap love-mode-map (kbd ",b")
(λ (shell-command (concat "open -a love.app " default-directory)))) (λ (shell-command (concat "open -a love.app " (projectile-project-root)))))
(add-hook 'lua-mode-hook (add-hook 'lua-mode-hook 'love-mode-maybe)))
(lambda()
(if (string-match "\\.love/.+\\.lua\\'" (buffer-file-name))
(love-mode t))
(nmap lua-mode-map (kbd "s-r") (defun love-mode-maybe()
(lambda() (interactive) (shell-command-on-region (point-min) (point-max) "lua"))) (let ((root (projectile-project-root)))
(vmap lua-mode-map (kbd "s-r") (if (or (string-match "[.-]love/" root)
(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) "lua"))) (file-exists-p (concat root ".love-mode")))
)))) (love-mode t))))
;; ;;
(provide 'mod-love) (provide 'mod-love)

61
init/mod-org.el
View file

@ -12,6 +12,9 @@
(funcall fun) (funcall fun)
(evil-append nil)) (evil-append nil))
(defun my/org-surround (delim)
(insert delim) (save-excursion (insert delim)))
;; ;;
(use-package org :ensure t (use-package org :ensure t
:mode ("\\.org\\'" . org-mode) :mode ("\\.org\\'" . org-mode)
@ -19,12 +22,14 @@
(progn (progn
(setq org-directory "~/Dropbox/notes") (setq org-directory "~/Dropbox/notes")
(setq org-default-notes-file "~/Dropbox/notes/notes.org") (setq org-default-notes-file "~/Dropbox/notes/notes.org")
(setq org-archive-location "~/Dropbox/notes/archives.org") (setq org-mobile-inbox-for-pull "~/Dropbox/notes/notes.org")
(setq org-mobile-directory "~/Dropbox/Apps/MobileOrg")
(setq org-agenda-files '("~/Dropbox/notes/gtd.org" (setq org-agenda-files '("~/Dropbox/notes/gtd.org"
"~/Dropbox/notes/notes.org" "~/Dropbox/notes/notes.org"
"~/Dropbox/notes/blog.org" "~/Dropbox/notes/blog.org"
"~/Dropbox/notes/invoices.org" "~/Dropbox/notes/invoices.org"
"~/Dropbox/notes/journal.org" "~/Dropbox/notes/journal.org"
"~/Dropbox/notes/trivia.org"
"~/Dropbox/notes/vocab.org" "~/Dropbox/notes/vocab.org"
"~/Dropbox/notes/excerpts.org")) "~/Dropbox/notes/excerpts.org"))
@ -32,7 +37,9 @@
(setq org-hide-leading-stars t) (setq org-hide-leading-stars t)
(setq org-export-backends '(ascii html latex md)) (setq org-export-backends '(ascii html latex md))
(setq org-todo-keywords (setq org-todo-keywords
'((sequence "TODO" "DOING" "VERIFY" "WAITING" "|" "DONE" "DELEGATED" "CANCELLED"))) '((sequence "TODO(t)" "|" "DONE(d)")
(sequence "STARTED(s)" "VERIFY(v)" "WAITING(w)")
(sequence "|" "CANCELLED(c)")))
(org-babel-do-load-languages 'org-babel-load-languages (org-babel-do-load-languages 'org-babel-load-languages
'((python . t) '((python . t)
@ -61,8 +68,10 @@
("n" "Note" entry (file+datetree org-default-notes-file) "** %?") ("n" "Note" entry (file+datetree org-default-notes-file) "** %?")
("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %?") ("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %?")
("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\n%?\nAdded: %U") ("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\n%?\nAdded: %U")
("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %?" :prepend t) ("a" "Trivia" entry (file "~/Dropbox/notes/trivia.org") "* %u %?" :prepend t)
("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %?" :prepend t))) ("s" "Writing Scraps" entry (file "~/Dropbox/notes/writing.org") "* %u %?" :prepend t)
("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %u %?" :prepend t)
("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %u %?" :prepend t)))
(setq org-agenda-custom-commands (setq org-agenda-custom-commands
'(("x" agenda) '(("x" agenda)
@ -85,31 +94,45 @@
;; (emap org-agenda-mode-map ;; (emap org-agenda-mode-map
;; ...) ;; ...)
;; Formatting shortcuts
;; Bold
(vmap evil-org-mode-map (kbd "s-b") "s*")
(imap evil-org-mode-map (kbd "s-b") (λ (my/org-surround "*")))
;; Italics
(vmap evil-org-mode-map (kbd "s-i") "s/")
(imap evil-org-mode-map (kbd "s-i") (λ (my/org-surround "/")))
;; Underline
(imap evil-org-mode-map (kbd "s-u") (λ (my/org-surround "_")))
;; Strikethrough
(imap evil-org-mode-map (kbd "s-`") (λ (my/org-surround "+")))
(imap evil-org-mode-map (imap evil-org-mode-map
(kbd "<s-return>") 'org-insert-heading-after-current) (kbd "<s-return>") 'org-insert-heading-after-current)
(vmap evil-org-mode-map (nvmap evil-org-mode-map
",l" 'org-insert-link) ",l" 'org-insert-link)
;; (vmap evil-org-mode-map
;; ",l" 'org-insert-link)
(nmap evil-org-mode-map (nmap evil-org-mode-map
",l" 'org-insert-link ",d" 'org-time-stamp
",D" 'org-time-stamp-inactive
",s" 'org-schedule ",s" 'org-schedule
",a" 'org-attach ",a" 'org-attach
",A" 'org-agenda ",A" 'org-attach-open
",t" 'org-todo ",t" 'org-todo
",T" 'org-show-todo-tree ",T" 'org-show-todo-tree
",\\" 'org-match-sparse-tree ",/" 'org-match-sparse-tree
",?" 'org-tags-view
",+" 'org-align-all-tags ",+" 'org-align-all-tags
",r" 'org-refile
"gh" 'outline-up-heading "gh" 'outline-up-heading
"gj" (if (fboundp 'org-forward-same-level) ;to be backward compatible with older org version "gj" 'org-forward-heading-same-level
'org-forward-same-level "gk" 'org-backward-heading-same-level
'org-forward-heading-same-level)
"gk" (if (fboundp 'org-backward-same-level)
'org-backward-same-level
'org-backward-heading-same-level)
"gl" 'outline-next-visible-heading "gl" 'outline-next-visible-heading
"go" 'org-open-at-point "go" 'org-open-at-point
"gr" 'org-refile "ga" 'org-agenda
"H" 'org-beginning-of-line "H" 'org-beginning-of-line
"L" 'org-end-of-line "L" 'org-end-of-line
"$" 'org-end-of-line "$" 'org-end-of-line
@ -117,9 +140,9 @@
"<" 'org-metaleft "<" 'org-metaleft
">" 'org-metaright ">" 'org-metaright
"-" 'org-cycle-list-bullet "-" 'org-cycle-list-bullet
(kbd "RET") (λ (org-insert-heading-after-current) (evil-insert-state)) (kbd ", SPC") 'org-archive-subtree
(kbd "SPC") 'org-todo (kbd "<s-return>") (λ (org-insert-heading-after-current) (evil-insert-state))
(kbd "M-SPC") (λ (org-todo "DONE")) (kbd "RET") (λ (org-todo 'done))
(kbd "TAB") 'org-cycle) (kbd "TAB") 'org-cycle)
;; normal & insert state shortcuts. ;; normal & insert state shortcuts.
@ -134,7 +157,7 @@
(kbd "M-H") 'org-shiftmetaleft (kbd "M-H") 'org-shiftmetaleft
(kbd "M-K") 'org-shiftmetaup (kbd "M-K") 'org-shiftmetaup
(kbd "M-J") 'org-shiftmetadown (kbd "M-J") 'org-shiftmetadown
(kbd "M-o") '(lambda () (interactive) (kbd "<M-return>") '(lambda () (interactive)
(my/org-eol-call (my/org-eol-call
'(lambda() '(lambda()
(org-insert-heading) (org-insert-heading)

49
init/mod-text.el
View file

@ -3,13 +3,50 @@
(use-package markdown-mode :ensure t (use-package markdown-mode :ensure t
:mode (("\\.md\\'" . markdown-mode) :mode (("\\.md\\'" . markdown-mode)
("/README\\'" . markdown-mode)) ("/README\\'" . markdown-mode))
:init :config
(add-hook 'markdown-mode-hook (progn
(lambda() (let ((map markdown-mode-map))
;; Restore native mac M-left/right functionality (define-key map (kbd "<backspace>") nil)
(local-unset-key (kbd "<M-left>")) (define-key map (kbd "<M-left>") nil)
(local-unset-key (kbd "<M-right>"))))) (define-key map (kbd "<M-right>") nil)
(nvmap map
(kbd ",i") 'markdown-insert-image
(kbd ",l") 'markdown-insert-link
(kbd ",L") 'markdown-insert-reference-link-dwim)
(imap map (kbd "M--") 'markdown-insert-hr)
(nmap map
"[p" 'markdown-promote
"]p" 'markdown-demote)
(define-key map (kbd "s-*") 'markdown-insert-list-item)
(define-key map (kbd "s-b") 'markdown-insert-bold)
(define-key map (kbd "s-i") 'markdown-insert-italic)
(define-key map (kbd "s-`") 'markdown-insert-del)
)
))
(defvar markdown-regex-del "\\(^\\|[^\\]\\)\\(\\(~\\{2\\}\\)\\([^ \n \\]\\|[^ \n ]\\(?:.\\|\n[^\n]\\)*?[^\\ ]\\)\\(\\3\\)\\)")
(defun markdown-insert-del ()
"Insert markup to make a region or word bold.
If there is an active region, make the region bold. If the point
is at a non-bold word, make the word bold. If the point is at a
bold word or phrase, remove the bold markup. Otherwise, simply
insert bold delimiters and place the cursor in between them."
(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)))))
;; ;;
(provide 'mod-text) (provide 'mod-text)

43
init/mod-webdev.el
View file

@ -4,14 +4,9 @@
(use-package scss-mode :ensure t (use-package scss-mode :ensure t
:mode "\\.scss\\'" :mode "\\.scss\\'"
:config :config (add-hook 'scss-mode-hook 'ac-css-mode-setup))
(add-hook 'scss-mode-hook (lambda() (add-to-list 'ac-sources 'ac-css-mode-setup))))
(use-package haml-mode :ensure t :mode "\\.haml\\'") (use-package haml-mode :ensure t :mode "\\.haml\\'")
(use-package web-mode :ensure t
:mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
("\\.tpl\\(\\.php\\)?\\'" . web-mode)
("\\.erb\\'" . web-mode)))
(use-package php-mode :ensure t (use-package php-mode :ensure t
:mode (("\\.php\\'" . php-mode) :mode (("\\.php\\'" . php-mode)
@ -22,9 +17,13 @@
(my/setup-run-code php-mode-map "php") (my/setup-run-code php-mode-map "php")
(setq php-template-compatibility nil))) (setq php-template-compatibility nil)))
(use-package js-mode (use-package web-mode :ensure t
:mode "\\.js\\'" :mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
:interpreter "node") ("\\.tpl\\(\\.php\\)?\\'" . web-mode)
("\\.erb\\'" . web-mode)
("wp-content/themes/.+/.+\\.php\\'" . web-mode))
:config
(add-hook 'web-mode-hook 'jekyll-mode-maybe))
(use-package tern :ensure t (use-package tern :ensure t
:commands tern-mode :commands tern-mode
@ -44,12 +43,36 @@
(use-package emmet-mode :ensure t (use-package emmet-mode :ensure t
:defer t :defer t
:config :config
(imap 'emmet-mode-map (kbd "s-e") 'emmet-expand-line) (progn
(imap emmet-mode-keymap (kbd "s-e") 'emmet-expand-yas)
(imap emmet-mode-keymap (kbd "s-E") 'emmet-expand-line)
(setq emmet-move-cursor-between-quotes t))
:init :init
(progn (progn
(add-hook 'scss-mode-hook 'emmet-mode) (add-hook 'scss-mode-hook 'emmet-mode)
(add-hook 'web-mode-hook 'emmet-mode) (add-hook 'web-mode-hook 'emmet-mode)
(add-hook 'haml-mode-hook 'emmet-mode)
(add-hook 'nxml-mode-hook 'emmet-mode))) (add-hook 'nxml-mode-hook 'emmet-mode)))
;; Jekyll support
(define-minor-mode jekyll-mode
:init-value nil
:lighter " :{"
:keymap (make-sparse-keymap))
(defun jekyll-mode-maybe()
(let ((root (projectile-project-root)))
(if (or (string-match "[.-]jekyll/" root)
(file-exists-p (concat root ".jekyll-mode")))
(jekyll-mode t))))
(nmap jekyll-mode-map (kbd ",b")
(λ (open-file-with "http://localhost:4000")))
(add-hook 'scss-mode-hook 'jekyll-mode-maybe)
(add-hook 'web-mode-hook 'jekyll-mode-maybe)
(add-hook 'markdown-mode-hook 'jekyll-mode-maybe)
;; ;;
(provide 'mod-webdev) (provide 'mod-webdev)

81
init/my-defuns.el
View file

@ -11,6 +11,9 @@
`(evil-define-key 'insert ,map ,@body)) `(evil-define-key 'insert ,map ,@body))
(defmacro emap (map &rest body) (defmacro emap (map &rest body)
`(evil-define-key 'emacs ,map ,@body)) `(evil-define-key 'emacs ,map ,@body))
(defmacro nvmap (map &rest body)
`(evil-define-key 'normal ,map ,@body)
`(evil-define-key 'visual ,map ,@body))
;; insert-mode key-chord mapping ;; insert-mode key-chord mapping
(defmacro ichmap (key command) (defmacro ichmap (key command)
@ -29,22 +32,6 @@
(switch-to-buffer (get-buffer-create "*scratch*")) (switch-to-buffer (get-buffer-create "*scratch*"))
(text-mode)) (text-mode))
(defun my/expand-space ()
"Insert a space ahead of the cursor"
(interactive)
(save-excursion (insert " ")))
(defun my/expand-backspace ()
"Add a space before and ahead of the cursor"
(interactive)
(save-excursion (delete-char 1))
(delete-backward-char 1))
(defun my/enable-hard-wrap()
"Enable hard line wrapping"
(interactive)
(auto-fill-mode 1))
(defun my/byte-recompile () (defun my/byte-recompile ()
"Byte compile init.el, ~/.emacs.d/init/* and ~/.emacs.d/elisp/*" "Byte compile init.el, ~/.emacs.d/init/* and ~/.emacs.d/elisp/*"
(interactive) (interactive)
@ -71,7 +58,12 @@
(mapc 'kill-buffer (cdr (buffer-list (current-buffer)))) (mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
(message "All other buffers killed")) (message "All other buffers killed"))
(defun my/kill-non-project-buffers ()) ; TODO Implement this (defun my/kill-dired-buffers ()
(interactive)
(mapc (lambda (buffer)
(when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
(kill-buffer buffer)))
(buffer-list)))
(defun my/recentf-ido-find-file () (defun my/recentf-ido-find-file ()
"Find a recent file using ido." "Find a recent file using ido."
@ -128,7 +120,16 @@
(add-to-list 'symbol-names name) (add-to-list 'symbol-names name)
(add-to-list 'name-and-pos (cons name position)))))))) (add-to-list 'name-and-pos (cons name position))))))))
;;;; Ac-setup Defuns ;;;;;;;;;;;;;; ;;;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;
(defun my/enable-hard-wrap()
(auto-fill-mode 1)
(diminish 'auto-fill-function))
(defun my/enable-comment-hard-wrap ()
(set (make-local-variable 'comment-auto-fill-only-comments) t)
(auto-fill-mode 1)
(diminish 'auto-fill-function))
(defun my/ac-ruby-setup() (defun my/ac-ruby-setup()
"Set up RSense and ac-sources" "Set up RSense and ac-sources"
(setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources))) (setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources)))
@ -140,34 +141,54 @@
(defun my/setup-run-code(mode interpreter) (defun my/setup-run-code(mode interpreter)
"Set up s-r to run code using a specified interpreter and print the "Set up s-r to run code using a specified interpreter and print the
output in the echo area" output in the echo area"
(interactive) (nmap mode (kbd ",r")
(nmap mode (kbd "s-r") `(lambda()
`(lambda() (interactive) (shell-command-on-region (point-min) (point-max) ,interpreter))) (interactive)
(vmap mode (kbd "s-r") (if (file-exists-p (buffer-file-name))
(shell-command (concat ,interpreter " " (buffer-file-name)))
(shell-command-on-region (point-min) (point-max) ,interpreter))))
(vmap mode (kbd ",r")
`(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) ,interpreter)))) `(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) ,interpreter))))
;;;; Tmux defuns ;;;;;;;;;;;;;;;;; ;;;; Tmux defuns ;;;;;;;;;;;;;;;;;
(defun my/tmux-send(command) (defun my/tmux-run (command)
(interactive "sRun command: ") "Run command in tmux"
(shell-command (concat "tmux send-keys C-u " (shell-quote-argument command) " Enter")) (interactive
(list
(read-shell-command "Tmux command: " nil nil
(let ((filename (cond (buffer-file-name)
((eq major-mode 'dired-mode)
(dired-get-filename nil t)))))
(and filename (file-relative-name filename))))))
(shell-command (concat "/usr/local/bin/tmux send-keys C-u " (shell-quote-argument command) " Enter"))
;; (call-process "/usr/local/bin/tmux" nil nil nil "C-u" "send-keys" command "C-m")
(message "Tmux: Command sent!")) (message "Tmux: Command sent!"))
(defun my/tmux-paste (command)
(interactive "sSend to Tmux: ")
(shell-command (concat "/usr/local/bin/tmux send-keys " command))
(message "Tmux: Text pasted!"))
(defun my/tmux-chdir(dir) (defun my/tmux-chdir(dir)
"CD into a new directory in tmux"
(interactive "DDirectory: ") (interactive "DDirectory: ")
(shell-command (concat "tmux send-keys C-u \"cd " dir "\" Enter")) (my/tmux-run (concat "cd " (shell-quote-argument dir)))
(message "Tmux: Directory changed!")) (message "Tmux: Directory changed!"))
;;;; Mac-specific Defuns ;;;;;;;;; ;;;; Mac-specific Defuns ;;;;;;;;;
(when is-mac (when is-mac
;; Send current file to OSX apps ;; Send current file to OSX apps
(defun open-file-with (path &optional appName) (defun open-file-with (path &optional appName)
(if (not (string= "" appName)) (if (and appName
(stringp appName)
(not (string= "" appName)))
(setq appName (concat "-a " appName ".app"))) (setq appName (concat "-a " appName ".app")))
(shell-command (concat "open " appName " " path))) (shell-command (concat "open " appName " " (shell-quote-argument path))))
(defun open-with (appName) (defun open-with (appName)
(interactive) (interactive "sApp name: ")
(open-file-with (buffer-file-name) appName)) (open-file-with buffer-file-name appName))
(defun send-to-transmit () (interactive) (open-with "Transmit")) (defun send-to-transmit () (interactive) (open-with "Transmit"))
(defun send-to-launchbar () (interactive) (open-with "LaunchBar")) (defun send-to-launchbar () (interactive) (open-with "LaunchBar"))

12
themes/brin-theme.el
View file

@ -26,10 +26,7 @@
(deftheme brin "Space Grey theme for Emacs") (deftheme brin "Space Grey theme for Emacs")
(custom-theme-set-variables (custom-theme-set-variables 'brin)
'brin
;; '(linum-format " %1d ")
)
(let ((background "#1f1f1f") (let ((background "#1f1f1f")
;; (gutters "#262E34") ;; (gutters "#262E34")
@ -85,6 +82,8 @@
`(highlight-indentation-face ((t (:background ,gutters) ))) `(highlight-indentation-face ((t (:background ,gutters) )))
`(highlight-indentation-current-column-face ((t (:background ,gutters-active) ))) `(highlight-indentation-current-column-face ((t (:background ,gutters-active) )))
`(flyspell-incorrect ((t (:underline "#ff5555" :inherit unspecified))))
;; Font lock faces ;; Font lock faces
;; ***************************************************************************************** ;; *****************************************************************************************
@ -103,11 +102,6 @@
) )
;;;###autoload
(when (and (boundp 'custom-theme-load-path) load-file-name)
(add-to-list 'custom-theme-load-path
(file-name-as-directory (file-name-directory load-file-name))))
;; ***************************************************************************************** ;; *****************************************************************************************
(provide-theme 'brin) (provide-theme 'brin)