init.el

;; bootstrap use-package
;; http://cachestocaches.com/2015/8/getting-started-use-package/

(require 'package)
(setq package-enable-at-startup nil)
;;(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/"))
(add-to-list 'package-archives '("melpa-stable" . "https://stable.melpa.org/packages/") t)
(add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/"))
(add-to-list 'package-archives '("gnu" . "http://elpa.gnu.org/packages/"))
(package-initialize)

(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(eval-when-compile
  (require 'use-package))
(require 'diminish)
(require 'bind-key)

;; general emacs config

(when (fboundp 'menu-bar-mode) (menu-bar-mode -1))
(when (fboundp 'tool-bar-mode) (tool-bar-mode -1))
(when (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
(setq inhibit-splash-screen t)
(show-paren-mode 1)
(global-auto-revert-mode 1)

;; Also auto refresh dired, but be quiet about it
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)
(setq make-backup-files nil)

(xterm-mouse-mode 1)

;; global key bindings

(global-set-key (kbd "<mouse-5>") 'scroll-up-line)
(global-set-key (kbd "<mouse-4>") 'scroll-down-line)
(global-set-key (kbd "C-x C-b") 'ibuffer)

(global-set-key (kbd "C-x <up>") 'previous-multiframe-window)
(global-set-key (kbd "C-x <down>") 'next-multiframe-window)

;; dark blue is hard to read
;;(set-face-foreground 'minibuffer-prompt "white")
(use-package gruvbox-theme
  :ensure t)

;; install and configure packages
(use-package super-save
  :ensure t
  :init
  (setq super-save-auto-save-when-idle t)
  (setq auto-save-default nil)
  :config
  (super-save-mode +1))

(use-package helm
  :ensure t
  :diminish helm-mode
  :bind (("M-x" . helm-M-x)
	 ("C-x C-f" . helm-find-files)
	 ("C-x b" . helm-buffers-list))
  :init
  (setq helm-M-x-fuzzy-match t
	helm-buffers-fuzzy-matching t
	helm-display-header-line nil)
  :config
  (helm-mode 1)
  (helm-autoresize-mode 1)
  (add-to-list 'helm-completing-read-handlers-alist '(find-file . helm-completing-read-symbols)))


;; Project management.
(use-package projectile
  :ensure t
  :commands (projectile-find-file projectile-switch-project)
  :diminish projectile-mode
  :init
  (use-package helm-projectile
    :ensure t
    :bind (("s-p" . helm-projectile-find-file)
	   ("s-P" . helm-projectile-switch-project)))
  :config
  (projectile-global-mode))

(use-package company
  :ensure t
  :defer t
  :diminish company-mode
  :init
  (setq company-idle-delay 0.2)
  :config
  (add-hook 'prog-mode-hook 'company-mode))

;; Shows a popup with all the possible key bindings that would complete the
;; started binding.
(use-package guide-key
  :ensure t
  :defer 4
  :diminish guide-key-mode
  :config
  (progn
    (setq guide-key/guide-key-sequence t)
    (setq guide-key/idle-delay 0.4)
    (guide-key-mode 1)))

(use-package neotree
  :ensure t
  :bind (("C-c n" . neotree-toggle)
	 ("C-c C-n" . neotree-show))
  :init
  (setq neo-theme (if (display-graphic-p) 'icons 'arrow)
	neo-smart-open t))

(use-package projectile
  :ensure t
;;  :diminish projectile-mode
  :bind ("C-c p a" . projectile-ag)
  :init (progn
	  (projectile-cleanup-known-projects)
	  (projectile-global-mode)))

(use-package sayid
  :ensure t)

(use-package clojure-mode
  :ensure t
  :config
  (sayid-setup-package))

(use-package cider
  :ensure t
  ;; use 0.14 instead of 0.15-snapshot
  ;;  :pin melpa-stable

  :bind (("C-c C-o" . cider-repl-clear-buffer))
  :init
  (setq cider-repl-display-help-banner nil
	cider-popup-stacktraces      nil
	cider-repl-popup-stacktraces t
	cider-popup-on-error         nil
	nrepl-popup-on-error         nil
	cider-repl-use-pretty-printing t

	;; cider-cljs-lein-repl
	;; "(do (require 'figwheel-sidecar.repl-api)
	;;      (figwheel-sidecar.repl-api/start-figwheel!)
	;;       (figwheel-sidecar.repl-api/cljs-repl))"

	))


(use-package paredit
  ;;:diminish paredit-mode
  :ensure t
  :init
  (dolist (hook '(clojure-mode-hook
		  cider-repl-mode-hook
		  lisp-mode-hook
		  emacs-lisp-mode-hook
		  lisp-interaction-mode-hook
		  ielm-mode-hook
		  json-mode-hook))
    (add-hook hook 'enable-paredit-mode)))

(use-package magit
  :ensure t
  :bind (("C-x g" . magit-status)
	 ("C-x M-g" . magit-dispatch-popup)))

;; (use-package clj-refactor
;;   :ensure t
;;   :init
;;   (add-hook 'clojure-mode-hook
;;	    (progn
;;	      (clj-refactor-mode 1)
;;	      (yas-minor-mode 1)
;;	      (cljr-add-keybindings-with-prefix "C-c C-m"))))


;;;

(defun top-join-line ()
  "Join the current line with the line beneath it."
  (interactive)
  (delete-indentation 1))

(global-set-key (kbd "C-^") 'top-join-line)


;;;;;;;;
;;(setq cider-lein-parameters "with-profile +cider,+repl repl :headless")

;;(setq cider-lein-parameters "with-profile +figwheel repl :headless")

;; copy paste
(defun copy-from-osx ()
  (shell-command-to-string "pbpaste"))

(defun paste-to-osx (text &optional push)
  (let ((process-connection-type nil))
    (let ((proc (start-process "pbcopy" "*Messages*" "pbcopy")))
      (process-send-string proc text)
      (process-send-eof proc))))

(setq interprogram-cut-function 'paste-to-osx)
(setq interprogram-paste-function 'copy-from-osx)


(defun escape-doublequotes-at-car-of-kill-ring ()
  "Escape doublequotes in car of kill-ring "
  (interactive)
  (with-temp-buffer
    (insert (car kill-ring))
    (goto-char (point-min))
    (while (search-forward "\"" nil t 1)
      (replace-match "\\\\\""))
    (kill-new (buffer-substring-no-properties (point-min) (point-max)))))

(use-package evil
  :ensure t
  :init
  (progn
    (setq evil-ex-search-vim-style-regexp t
	  evil-mode-line-format nil
	  evil-search-module 'evil-search
	  evil-symbol-word-search t
	  evil-want-C-u-scroll t
	  evil-want-Y-yank-to-eol t
	  ;; for clojure eval
	  evil-move-beyond-eol t)
    (setq-default evil-shift-width 2)
    (evil-mode 1))

  :config
  (progn
    (use-package evil-leader
      :ensure t
      :config
      (progn
	(setq evil-leader/leader "<SPC>"
	      evil-leader/in-all-states t)

	(evil-leader/set-key
	  "b" 'helm-buffers-list
	  "ce" 'cider-eval-last-sexp
	  "f" 'helm-find-files
	  "g" 'magit-status
	  "e" 'eval-last-sexp
	  "W" 'whitespace-cleanup
	  ;; https://github.com/holguinj/evil-clojure-emacs/blob/master/config/evil-config.el
	  ;; map <leader> cc and <leader> dd to what I feel in my heart cc and dd should do. Which is respect paredit.
	  "cc" (lambda (arg) (interactive "P") (move-beginning-of-line arg) (paredit-kill arg) (evil-insert arg))
	  "dd" (lambda (arg) (interactive "P") (move-beginning-of-line arg) (paredit-kill arg)))

	   (define-key evil-ex-map "e " 'helm-find-files)
	   (define-key evil-ex-map "b " 'helm-buffers-list)
	(global-evil-leader-mode)))

    (use-package evil-escape
      :ensure t
      :diminish evil-escape-mode
      :init

      :config
      (evil-escape-mode 1)

      (setq-default evil-escape-key-sequence "jk"))

    (use-package evil-iedit-state
      :ensure t
      :commands evil-iedit-state/iedit-mode)

    (use-package evil-matchit
      :ensure t
      :init
      (global-evil-matchit-mode 1))

    (use-package evil-nerd-commenter
      :ensure t
      :commands evilnc-comment-or-uncomment-lines)

    (use-package evil-numbers
      :ensure t
      :commands (evil-numbers/inc-at-pt evil-numbers/dec-at-t))

    (use-package evil-surround
      :ensure t
      :init
      (progn
	(setq-default surround-pairs-alist '((?\( . ("(" . ")"))
					     (?\[ . ("[" . "]"))
					     (?\{ . ("{" . "}"))

					     (?\) . ("( " . " )"))
					     (?\] . ("[ " . " ]"))
					     (?\} . ("{ " . " }"))
					     (?> . ("< " . " >"))

					     (?# . ("#{" . "}"))
					     (?p . ("(" . ")"))
					     (?b . ("[" . "]"))
					     (?B . ("{" . "}"))
					     (?< . ("<" . ">"))
					     (?t . surround-read-tag)))
	(global-evil-surround-mode 1)))

    ;; ;;; esc quits
    (define-key evil-normal-state-map [escape] 'keyboard-quit)
    (define-key evil-visual-state-map [escape] 'keyboard-quit)
    (define-key minibuffer-local-map [escape] 'abort-recursive-edit)
    (define-key minibuffer-local-ns-map [escape] 'abort-recursive-edit)
    (define-key minibuffer-local-completion-map [escape] 'abort-recursive-edit)
    (define-key minibuffer-local-must-match-map [escape] 'abort-recursive-edit)
    (define-key minibuffer-local-isearch-map [escape] 'abort-recursive-edit)

    (cl-loop for (mode . state) in '((inferior-emacs-lisp-mode . emacs)
				     (cider-docview-mode . emacs)
				     (cider-inspector-mode . emacs)
				     (cider-macroexpansion-mode . emacs)
				     (cider-repl-mode . emacs)
				     (cider-result-mode . emacs)
				     (cider-stacktrace-mode . emacs)
				     (cider-test-report-mode . emacs)
				     (comint-mode              . emacs)
				     (eshell-mode              . emacs)
				     (occur-mode               . emacs)
				     (paradox-menu-mode        . emacs)
				     (sql-interactive-mode     . emacs)
				     (text-mode                . emacs))

	     do (evil-set-initial-state mode state))))


(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(package-selected-packages
   (quote
    (undo-tree evil sayid helm-projectile neotree gruvbox-theme avk-daylight-theme avk-daylight silkworm-theme clj-refactor magit projectile cider-mode super-save cider company paredit helm clojure-mode use-package)))
 '(safe-local-variable-values (quote ((js-indent-level . 4)))))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )