;; ~/.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)