Big updates to haskell-mode stuff.

10 files changed, 536 insertions, 106 deletions

diff --git a/.hgignore b/.hgignore
index 0c970e5..1a2cc86 100644
--- a/.hgignore
+++ b/.hgignore
@@ -2,6 +2,7 @@ syntax: regexp
 ^url\/
 ^elpa\/
 ^eshell\/
+^smex-items$
 \.elc$
 \.mc-lists\.el$
 \.DS_Store$
diff --git a/lisp/c-init.el b/elisp/c-init.el
index 8bcb172..8bcb172 100644
--- a/lisp/c-init.el
+++ b/elisp/c-init.el
diff --git a/elisp/haskell-flycheck.el b/elisp/haskell-flycheck.el
new file mode 100644
index 0000000..4248718
--- /dev/null
+++ b/elisp/haskell-flycheck.el
@@ -0,0 +1,97 @@
+;;; haskell-flycheck.el --- Flychecker using the GHCi process
+
+;; Copyright (c) 2014 Chris Done. All rights reserved.
+
+;; This file is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; This file is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'haskell-process)
+(require 'flycheck)
+
+(defun flycheck-haskell-process-start (checker callback)
+  "Start a GHCi load with CHECKER.
+
+CALLBACK is the status callback passed by Flycheck."
+  (let ((session (haskell-session)))
+    (haskell-session-current-dir session)
+    (let ((process (haskell-process)))
+      (haskell-process-queue-command
+       process
+       (make-haskell-command
+        :state
+        (list :process process
+              :session session
+              :filename (buffer-file-name)
+              :callback callback
+              :buffer (current-buffer)
+              :original (buffer-string))
+        :go
+        (lambda (state)
+          (with-current-buffer (plist-get state :buffer)
+            (let* ((filename (plist-get state :filename)))
+              (write-region (point-min) (point-max) filename)
+              (clear-visited-file-modtime)
+              (haskell-process-send-string
+               (plist-get state :process)
+               (format ":load \"%s\""
+                       (replace-regexp-in-string
+                        "\""
+                        "\\\\\""
+                        filename))))))
+        :live (lambda (state _)
+                (when (plist-get state :original)
+                  (with-temp-buffer
+                    (insert (plist-get state :original))
+                    (write-region (point-min) (point-max) (plist-get state :filename))
+                    (plist-put state :original nil))))
+        :complete
+        (lambda (state response)
+          (let ((session (plist-get state :session))
+                (process (plist-get state :process)))
+            (haskell-process-set-response-cursor process 0)
+            (let ((errors (list))
+                  (next-error t))
+              (while next-error
+                (setq next-error
+                      (haskell-process-errors-warnings
+                       session
+                       process
+                       response
+                       t))
+                (when (consp next-error)
+                  (add-to-list 'errors
+                               (flycheck-error-new-at
+                                (plist-get next-error :line)
+                                (plist-get next-error :col)
+                                (plist-get next-error :type)
+                                (plist-get next-error :msg)
+                                :checker 'haskell-process
+                                :buffer (plist-get state :buffer)))))
+              (funcall (plist-get state :callback)
+                       'finished
+                       errors)))))))))
+
+
+(flycheck-define-generic-checker 'haskell-process
+  "A syntax and type checker for Haskell using GHCi (via the
+haskell-process Emacs module)."
+  :start 'flycheck-haskell-process-start
+  :modes '(haskell-mode)
+  :next-checkers '((warning . haskell-hlint)))
+
+;; Register as an auto-selectable checker
+(setq flycheck-checkers (cons `haskell-process flycheck-checkers))
+
+(provide 'haskell-flycheck)
diff --git a/elisp/haskell-init.el b/elisp/haskell-init.el
new file mode 100644
index 0000000..0923efd
--- /dev/null
+++ b/elisp/haskell-init.el
@@ -0,0 +1,170 @@
+;; ~/.emacs.d/elisp/haskell-init.el
+;; Luke Hoersten <[email protected]>
+
+;; Require packages
+(require 'package-require)
+(package-require '(haskell-mode hi2 flycheck)) ;;  flycheck-haskell hindent shm
+
+(require 'flycheck)
+
+;; (eval-after-load 'flycheck
+;;   '(add-hook 'flycheck-mode-hook #'flycheck-haskell-setup))
+;; (require 'flycheck-haskell)
+
+(require 'haskell)
+(require 'haskell-mode)
+(require 'haskell-process)
+(require 'haskell-flycheck)
+(require 'haskell-interactive-mode)
+
+(defun haskell-who-calls (&optional prompt)
+  "Grep the codebase to see who uses the symbol at point."
+  (interactive "P")
+  (let ((sym (if prompt
+                 (read-from-minibuffer "Look for: ")
+               (haskell-ident-at-point))))
+    (let ((existing (get-buffer "*who-calls*")))
+      (when existing
+        (kill-buffer existing)))
+    (let ((buffer
+           (grep-find (format "cd %s && find . -name '*.hs' -exec grep -inH -e %s {} +"
+                              (haskell-session-current-dir (haskell-session))
+                              sym))))
+      (with-current-buffer buffer
+        (rename-buffer "*who-calls*")
+        (switch-to-buffer-other-window buffer)))))
+
+(defun haskell-process-all-types ()
+  "List all types in a grep-mode buffer."
+  (interactive)
+  (let ((session (haskell-session)))
+    (switch-to-buffer (get-buffer-create (format "*%s:all-types*"
+                                                 (haskell-session-name (haskell-session)))))
+    (setq haskell-session session)
+    (cd (haskell-session-current-dir session))
+    (let ((inhibit-read-only t))
+      (erase-buffer)
+      (let ((haskell-process-log nil))
+        (insert (haskell-process-queue-sync-request (haskell-process) ":all-types")))
+      (unless (eq major-mode  'compilation-mode)
+        (compilation-mode)
+        (setq compilation-error-regexp-alist
+              haskell-compilation-error-regexp-alist)))))
+
+;;; haskell-mode
+(add-hook
+ 'haskell-mode-hook
+ (lambda ()
+   (imenu-add-menubar-index)
+   (flycheck-mode)
+   (flycheck-disable-checker `haskell-ghc)
+   (turn-on-hi2)
+   (interactive-haskell-mode)))
+
+(custom-set-variables
+ '(capitalized-words-mode t)
+ '(haskell-stylish-on-save t)
+
+ '(hi2-layout-offset 4)
+ '(hi2-left-offset 4)
+
+ '(haskell-process-type 'cabal-repl)
+ '(haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng"))
+ '(haskell-process-path-ghci "ghci-ng")
+ '(haskell-process-args-ghci "-ferror-spans")
+ '(haskell-process-suggest-remove-import-lines t)
+ '(haskell-process-auto-import-loaded-modules t)
+ '(haskell-process-log t)
+ '(haskell-process-reload-with-fbytecode nil)
+ '(haskell-process-use-presentation-mode t)
+ '(haskell-process-suggest-haskell-docs-imports t)
+ '(haskell-process-suggest-hoogle-imports t)
+ '(haskell-process-generate-tags nil)
+ '(haskell-process-show-debug-tips nil)
+
+ '(haskell-notify-p t)
+ '(haskell-align-imports-pad-after-name t)
+ '(haskell-ask-also-kill-buffers t)
+ '(haskell-import-mapping t)
+
+ '(haskell-interactive-mode-eval-pretty t)
+ '(haskell-interactive-mode-scroll-to-bottom t)
+ '(haskell-interactive-mode-eval-mode 'haskell-mode))
+
+;; haskell-interactive-mode keybindings
+(define-key interactive-haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
+(define-key interactive-haskell-mode-map (kbd "M-,") 'haskell-who-calls)
+(define-key interactive-haskell-mode-map (kbd "M-.") 'haskell-mode-goto-loc)
+(define-key interactive-haskell-mode-map (kbd "C-?") 'haskell-mode-find-uses)
+(define-key interactive-haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
+(define-key interactive-haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+(define-key interactive-haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+(define-key interactive-haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
+(define-key interactive-haskell-mode-map (kbd "C-c C-t") 'haskell-mode-show-type-at)
+
+(define-key haskell-interactive-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
+(define-key haskell-interactive-mode-map (kbd "C-<left>") 'haskell-interactive-mode-error-backward)
+(define-key haskell-interactive-mode-map (kbd "C-<right>") 'haskell-interactive-mode-error-forward)
+(define-key haskell-interactive-mode-map (kbd "C-c c") 'haskell-process-cabal)
+
+(define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
+(define-key haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
+(define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
+(define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
+(define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+(define-key haskell-mode-map (kbd "C-c C-d") 'haskell-describe)
+(define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+(define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
+(define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space)
+
+(define-key haskell-cabal-mode-map (kbd "C-`") 'haskell-interactive-bring)
+(define-key haskell-cabal-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+(define-key haskell-cabal-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+(define-key haskell-cabal-mode-map (kbd "C-c c") 'haskell-process-cabal)
+
+(message "Loading haskell-init...done")
+(provide 'haskell-init)
+
+
+;;;; Old haskell stuff
+;; ;;; haskell-mode
+;; (autoload 'ghc-init "ghc" nil t)
+;; (add-hook
+;;  'haskell-mode-hook
+;;  (lambda ()
+;;    (ghc-init)
+;;    (capitalized-words-mode t)
+;;    (turn-on-hi2)
+;;    (imenu-add-menubar-index)
+;;    (interactive-haskell-mode)
+;;    (local-set-key (kbd "C-c i") 'haskell-navigate-imports) ; go to imports. prefix to return
+;;    (local-set-key (kbd "M-p") 'move-line-up) ; need to override default M-p function
+;;    (local-set-key (kbd "M-n") 'move-line-down)
+;;    (local-set-key (kbd "C-1") 'ghc-display-errors)
+;;    (local-set-key (kbd "C-.") 'ghc-goto-next-error)
+;;    (local-set-key (kbd "C-,") 'ghc-goto-prev-error)
+
+;;    (define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
+;;    (define-key haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
+;;    (define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
+;;    (define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
+;;    (define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+;;    (define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+;;    (define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
+;;    (define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space)
+
+;;    (setq
+;;     ghc-ghc-options '("-isrc")
+;;     haskell-program-name "cabal repl"
+;;     haskell-stylish-on-save t
+;;     hi2-layout-offset 4
+;;     hi2-left-offset 4
+;;     whitespace-line-column 78
+;;     ;; haskell-process-type 'cabal-repl
+;;     haskell-process-suggest-remove-import-lines t
+;;     haskell-process-auto-import-loaded-modules t
+;;     haskell-process-log t
+;;     )))
+
+;; ;;; ghci-mode
+;; (add-hook 'inferior-haskell-mode-hook 'turn-on-ghci-completion)
diff --git a/lisp/hoersten-c-style.el b/elisp/hoersten-c-style.el
index 043a499..043a499 100644
--- a/lisp/hoersten-c-style.el
+++ b/elisp/hoersten-c-style.el
diff --git a/elisp/javascript-init.el b/elisp/javascript-init.el
new file mode 100644
index 0000000..4035870
--- /dev/null
+++ b/elisp/javascript-init.el
@@ -0,0 +1,16 @@
+;; ~/.emacs.d/elisp/javascript-init.el
+;; Luke Hoersten <[email protected]>
+
+;; Require packages
+(require 'package-require)
+(package-require '(ac-js2 js2-mode json-mode))
+
+(require 'auto-complete-config)
+
+;;; js2-mode
+(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
+(add-hook 'js2-mode-hook 'ac-js2-mode)
+(setq-default ac-js2-evaluate-calls t)
+
+(message "Loading javascript-init...done")
+(provide 'javascript-init)
diff --git a/elisp/package-require.el b/elisp/package-require.el
new file mode 100644
index 0000000..c44c2d0
--- /dev/null
+++ b/elisp/package-require.el
@@ -0,0 +1,16 @@
+;; ~/.emacs.d/elisp/package-require.el
+;; Luke Hoersten <[email protected]>
+
+(package-initialize)
+(add-to-list 'package-archives '("melpa" . "http://melpa.milkbox.net/packages/") t)
+(add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/") t)
+
+(defun package-require (packages)
+  "Ensure that a given package is installed"
+  (mapc (lambda (package)
+          (unless (package-installed-p package)
+            (package-install package)))
+        packages))
+
+(message "Loading packages...done")
+(provide 'package-require)
diff --git a/elisp/shm-init.el b/elisp/shm-init.el
new file mode 100644
index 0000000..d80a509
--- /dev/null
+++ b/elisp/shm-init.el
@@ -0,0 +1,209 @@
+;; ~/.emacs.d/elisp/shm-init.el
+;; Luke Hoersten <[email protected]>
+
+;; Require packages
+(require 'package-require)
+(package-require '(haskell-mode shm hindent flymake-haskell-multi))
+
+;; Requirements
+(require 'shm)
+(require 'hindent)
+(require 'shm-case-split)
+(require 'shm-reformat)
+(require 'haskell)
+(require 'haskell-mode)
+(require 'hindent)
+(require 'haskell-process)
+(require 'haskell-simple-indent)
+(require 'haskell-interactive-mode)
+(require 'haskell-font-lock)
+
+;; Functions
+(defun haskell-process-all-types ()
+  "List all types in a grep-mode buffer."
+  (interactive)
+  (let ((session (haskell-session)))
+    (switch-to-buffer (get-buffer-create (format "*%s:all-types*"
+                                                 (haskell-session-name (haskell-session)))))
+    (setq haskell-session session)
+    (cd (haskell-session-current-dir session))
+    (let ((inhibit-read-only t))
+      (erase-buffer)
+      (let ((haskell-process-log nil))
+        (insert (haskell-process-queue-sync-request (haskell-process) ":all-types")))
+      (unless (eq major-mode  'compilation-mode)
+        (compilation-mode)
+        (setq compilation-error-regexp-alist
+              haskell-compilation-error-regexp-alist)))))
+
+(defun haskell-interactive-toggle-print-mode ()
+  (interactive)
+  (setq haskell-interactive-mode-eval-mode
+        (intern
+         (ido-completing-read "Eval result mode: "
+                              '("fundamental-mode"
+                                "haskell-mode"
+                                "ghc-core-mode")))))
+
+(defun haskell-insert-doc ()
+  "Insert the documentation syntax."
+  (interactive)
+  (insert "-- | "))
+
+(defun haskell-insert-undefined ()
+  "Insert undefined."
+  (interactive)
+  (if (and (boundp 'structured-haskell-mode)
+           structured-haskell-mode)
+      (shm-insert-string "undefined")
+    (insert "undefined")))
+
+(defun haskell-move-right ()
+  (interactive)
+  (haskell-move-nested 1))
+
+(defun haskell-move-left ()
+  (interactive)
+  (haskell-move-nested -1))
+
+(defun haskell-who-calls (&optional prompt)
+  "Grep the codebase to see who uses the symbol at point."
+  (interactive "P")
+  (let ((sym (if prompt
+                 (read-from-minibuffer "Look for: ")
+               (haskell-ident-at-point))))
+    (let ((existing (get-buffer "*who-calls*")))
+      (when existing
+        (kill-buffer existing)))
+    (let ((buffer
+           (grep-find (format "cd %s && find . -name '*.hs' -exec grep -inH -e %s {} +"
+                              (haskell-session-current-dir (haskell-session))
+                              sym))))
+      (with-current-buffer buffer
+        (rename-buffer "*who-calls*")
+        (switch-to-buffer-other-window buffer)))))
+
+(defun haskell-auto-insert-module-template ()
+  "Insert a module template for the newly created buffer."
+  (interactive)
+  (when (and (= (point-min)
+                (point-max))
+             (buffer-file-name))
+    (insert
+     "-- | "
+     "\n"
+     "\n"
+     "module "
+     )
+    (let ((name (haskell-guess-module-name)))
+      (if (string= name "")
+          (progn (insert "Main")
+                 (shm-evaporate (- (point) 5)
+                                (point)))
+        (insert name)))
+    (insert " where"
+            "\n"
+            "\n")
+    (goto-char (point-min))
+    (forward-char 4)))
+
+(defun shm-contextual-space ()
+  "Do contextual space first, and run shm/space if no change in
+the cursor position happened."
+  (interactive)
+  (if (looking-back "import")
+      (call-interactively 'haskell-mode-contextual-space)
+    (progn
+      (let ((ident (haskell-ident-at-point)))
+        (when ident
+          (and interactive-haskell-mode
+               (haskell-process-do-try-type ident))))
+      (call-interactively 'shm/space))))
+
+;; Mode settings
+(custom-set-variables
+ '(haskell-process-type 'cabal-repl)
+ '(haskell-process-args-cabal-repl
+   '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng"))
+ '(haskell-notify-p t)
+ '(haskell-stylish-on-save nil)
+ '(haskell-tags-on-save nil)
+ '(haskell-process-suggest-remove-import-lines t)
+ '(haskell-process-auto-import-loaded-modules t)
+ '(haskell-process-log t)
+ '(haskell-process-reload-with-fbytecode nil)
+ '(haskell-process-use-presentation-mode t)
+ '(haskell-interactive-mode-include-file-name nil)
+ '(haskell-interactive-mode-eval-pretty nil)
+ '(shm-use-presentation-mode t)
+ '(shm-auto-insert-skeletons t)
+ '(shm-auto-insert-bangs t)
+ '(haskell-process-suggest-haskell-docs-imports t)
+ '(hindent-style "chris-done")
+ '(haskell-interactive-mode-eval-mode 'haskell-mode)
+ '(haskell-process-path-ghci "ghci-ng")
+ '(haskell-process-args-ghci '("-ferror-spans"))
+ '(haskell-process-args-cabal-repl
+   '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng"))
+ '(haskell-process-generate-tags nil)
+ '(haskell-complete-module-preferred
+   '("Data.ByteString"
+     "Data.ByteString.Lazy"
+     "Data.List"
+     "Data.Map"
+     "Data.Maybe"
+     "Data.Monoid"
+     "Data.Ord")))
+
+;; Add hook
+(add-hook 'haskell-mode-hook 'structured-haskell-mode)
+(add-hook 'haskell-mode-hook 'interactive-haskell-mode)
+(add-hook 'haskell-interactive-mode-hook 'structured-haskell-repl-mode)
+(add-hook 'haskell-mode-hook 'haskell-auto-insert-module-template)
+
+;; Keybindings
+(define-key interactive-haskell-mode-map [f5] 'haskell-process-load-or-reload)
+(define-key interactive-haskell-mode-map [f12] 'haskell-process-reload-devel-main)
+(define-key interactive-haskell-mode-map (kbd "M-,") 'haskell-who-calls)
+(define-key interactive-haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
+(define-key interactive-haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+(define-key interactive-haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+(define-key interactive-haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
+(define-key interactive-haskell-mode-map (kbd "M-.") 'haskell-mode-goto-loc)
+(define-key interactive-haskell-mode-map (kbd "C-?") 'haskell-mode-find-uses)
+(define-key interactive-haskell-mode-map (kbd "C-c C-t") 'haskell-mode-show-type-at)
+
+(define-key haskell-mode-map (kbd "C-c i") 'hindent/reformat-decl)
+(define-key haskell-mode-map [f8] 'haskell-navigate-imports)
+(define-key haskell-mode-map (kbd "C-c C-u") 'haskell-insert-undefined)
+(define-key haskell-mode-map (kbd "C-c C-a") 'haskell-insert-doc)
+(define-key haskell-mode-map (kbd "C-<return>") 'haskell-simple-indent-newline-indent)
+(define-key haskell-mode-map (kbd "C-<right>") 'haskell-move-right)
+(define-key haskell-mode-map (kbd "C-<left>") 'haskell-move-left)
+(define-key haskell-mode-map (kbd "<space>") 'haskell-mode-contextual-space)
+
+(define-key haskell-cabal-mode-map (kbd "C-`") 'haskell-interactive-bring)
+(define-key haskell-cabal-mode-map [?\C-c ?\C-z] 'haskell-interactive-switch)
+(define-key haskell-cabal-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
+(define-key haskell-cabal-mode-map (kbd "C-c c") 'haskell-process-cabal)
+(define-key haskell-cabal-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
+
+(define-key haskell-interactive-mode-map (kbd "C-c C-v") 'haskell-interactive-toggle-print-mode)
+(define-key haskell-interactive-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
+(define-key haskell-interactive-mode-map [f12] 'haskell-process-reload-devel-main)
+(define-key haskell-interactive-mode-map (kbd "C-<left>") 'haskell-interactive-mode-error-backward)
+(define-key haskell-interactive-mode-map (kbd "C-<right>") 'haskell-interactive-mode-error-forward)
+(define-key haskell-interactive-mode-map (kbd "C-c c") 'haskell-process-cabal)
+
+(define-key shm-map (kbd "C-c C-p") 'shm/expand-pattern)
+(define-key shm-map (kbd "C-c C-s") 'shm/case-split)
+(define-key shm-map (kbd "SPC") 'shm-contextual-space)
+(define-key shm-map (kbd "C-\\") 'shm/goto-last-point)
+(define-key shm-map (kbd "C-c C-f") 'shm-fold-toggle-decl)
+(define-key shm-map (kbd "C-c i") 'shm-reformat-decl)
+
+(turn-on-haskell-simple-indent)
+(load "haskell-mode-autoloads.el")
+
+(message "Loading shm-init...done")
+(provide 'shm-init)
diff --git a/init.el b/init.el
index aa76f08..481e86c 100644
--- a/init.el
+++ b/init.el
@@ -2,7 +2,7 @@
 ;; Luke Hoersten <[email protected]>
 
 ;;;; General ;;;;
-(add-to-list 'load-path "~/.emacs.d/lisp")     ; set default emacs load path
+(add-to-list 'load-path "~/.emacs.d/elisp")     ; set default emacs load path
 
 (setq-default
  ediff-split-window-function
@@ -23,7 +23,7 @@
 (delete-selection-mode t)                 ; replace highlighted text
 (windmove-default-keybindings)            ; move between windows with shift-arrow
 (fset 'yes-or-no-p 'y-or-n-p)             ; replace yes/no prompts
-(global-hl-line-mode t)                   ; highlight current line
+;; (global-hl-line-mode t)                   ; highlight current line
 
 
 ;;; Coding
@@ -53,7 +53,7 @@
   (scroll-bar-mode -1)    ; remove scroll bar
   (unless is-mac (menu-bar-mode -1)) ; remove menu bar
   (visual-line-mode t)    ; word wrap break on whitespace
-  (set-frame-font (if is-mac "Ubuntu Mono-12" "Ubuntu Mono-10.5")))
+  (set-default-font (if is-mac "Ubuntu Mono-12" "Ubuntu Mono-10.5")))
 
 ;;;; Mode-Specific ;;;;
 
@@ -111,28 +111,24 @@
 ;;;; Requires and Packages ;;;;
 
 ;;; packages
-(package-initialize)
-(add-to-list 'package-archives '("melpa" . "http://melpa.milkbox.net/packages/") t)
-(add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/") t)
-
-;; install packages
-(let ((ensure-installed
-       (lambda (name)
-         (unless (package-installed-p name) (package-install name))))
-      (packages '(ac-js2 auto-complete exec-path-from-shell expand-region
-                  ghc ghci-completion haskell-mode
-                  js2-mode multiple-cursors rainbow-delimiters rainbow-mode
-                  skewer-mode solarized-theme visual-regexp yasnippet
-                  zencoding-mode json-mode markdown-mode)))
-  (mapc ensure-installed packages))
-
-;;; requires
+(require 'package-require)
+(package-require '(auto-complete exec-path-from-shell
+ rainbow-delimiters rainbow-mode solarized-theme visual-regexp
+ yasnippet zencoding-mode markdown-mode smex move-text))
+;; expand-region multiple-cursors skewer-mode
+
+;;; custom requires
+(require 'haskell-init)
+(require 'javascript-init)
 (require 'c-init)             ; c specific elisp
-(require 'move-line)          ; move line up or down
-(require 'uniquify)           ; unique buffer names with dirs
-(require 'auto-complete-config)
+
+;;; smex
+(global-set-key (kbd "M-x") 'smex)
+(global-set-key (kbd "M-X") 'smex-major-mode-commands)
+(global-set-key (kbd "C-c M-x") 'execute-extended-command)
 
 ;;; auto-complete-mode
+(require 'auto-complete-config)
 (ac-config-default)
 (global-set-key (kbd "M-/") 'auto-complete)
 (setq-default ac-auto-start nil)
@@ -144,6 +140,7 @@
 (add-hook 'eshell-mode-hook (lambda () (setenv "TERM" "emacs")))
 
 ;;; uniquify
+(require 'uniquify)           ; unique buffer names with dirs
 (setq
  uniquify-buffer-name-style 'post-forward
  uniquify-separator ":")
@@ -163,17 +160,16 @@
 ;;; gradle-mode
 (add-to-list 'auto-mode-alist '("\\.gradle$" . groovy-mode))
 
-;;; js2-mode
-(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
-(add-hook 'js2-mode-hook 'ac-js2-mode)
-(setq-default ac-js2-evaluate-calls t)
+
+;;; markdown-mode
+(add-hook 'markdown-mode-hook 'flyspell-mode)
+
 
 ;;; html-mode
 (add-to-list 'auto-mode-alist '("\\.tpl\\'" . html-mode))
 (add-hook
  'html-mode-hook
  (lambda ()
-   (local-set-key (kbd "C-c t") 'mc/mark-sgml-tag-pair)
    (zencoding-mode)
    (rainbow-mode)))
 
@@ -198,60 +194,12 @@
    clojure-mode-hook
    emacs-lisp-mode-hook))
 
-;;; haskell-mode
-(autoload 'ghc-init "ghc" nil t)
-(add-hook
- 'haskell-mode-hook
- (lambda ()
-   (ghc-init)
-   (capitalized-words-mode t)
-   (turn-on-hi2)
-   (imenu-add-menubar-index)
-   (interactive-haskell-mode)
-   (local-set-key (kbd "C-c i") 'haskell-navigate-imports) ; go to imports. prefix to return
-   (local-set-key (kbd "M-p") 'move-line-up) ; need to override default M-p function
-   (local-set-key (kbd "M-n") 'move-line-down)
-   (local-set-key (kbd "C-1") 'ghc-display-errors)
-   (local-set-key (kbd "C-.") 'ghc-goto-next-error)
-   (local-set-key (kbd "C-,") 'ghc-goto-prev-error)
-
-   (define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
-   (define-key haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
-   (define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
-   (define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
-   (define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
-   (define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
-   (define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
-   (define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space)
-
-   (setq
-    ghc-ghc-options '("-isrc")
-    haskell-program-name "cabal repl"
-    haskell-stylish-on-save t
-    hi2-layout-offset 4
-    hi2-left-offset 4
-    whitespace-line-column 78
-    ;; haskell-process-type 'cabal-repl
-    haskell-process-suggest-remove-import-lines t
-    haskell-process-auto-import-loaded-modules t
-    haskell-process-log t
-    )))
-
-;;; ghci-mode
-(add-hook 'inferior-haskell-mode-hook 'turn-on-ghci-completion)
-
 ;;; expand-region
-(global-set-key (kbd "C-=") 'er/expand-region)
-
-;;; move-line
-(global-set-key (kbd "M-p") 'move-line-up)
-(global-set-key (kbd "M-n") 'move-line-down)
+;; (global-set-key (kbd "C-=") 'er/expand-region)
 
-;;; multiple-cursors
-(global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
-(global-set-key (kbd "C->") 'mc/mark-next-like-this)
-(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
-(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
+;;; move-text
+(global-set-key (kbd "M-p") 'move-text-up)
+(global-set-key (kbd "M-n") 'move-text-down)
 
 ;;; visual-regexp
 (global-set-key (kbd "C-M-%") 'vr/query-replace)
diff --git a/lisp/move-line.el b/lisp/move-line.el
deleted file mode 100644
index 7986715..0000000
--- a/lisp/move-line.el
+++ /dev/null
@@ -1,27 +0,0 @@
-;; http://www.emacswiki.org/emacs/MoveLine
-
-(defun move-line (n)
-  "Move the current line up or down by N lines."
-  (interactive "p")
-  (setq col (current-column))
-  (beginning-of-line) (setq start (point))
-  (end-of-line) (forward-char) (setq end (point))
-  (let ((line-text (delete-and-extract-region start end)))
-    (forward-line n)
-    (insert line-text)
-    ;; restore point to original column in moved line
-    (forward-line -1)
-    (forward-char col)))
-
-(defun move-line-up (n)
-  "Move the current line up by N lines."
-  (interactive "p")
-  (move-line (if (null n) -1 (- n))))
-
-(defun move-line-down (n)
-  "Move the current line down by N lines."
-  (interactive "p")
-  (move-line (if (null n) 1 n)))
-
-(message "Loading move-line...done")
-(provide 'move-line)