init.el

;;; init.el --- personal emacs config file -*- lexical-binding: t ; eval: (read-only-mode 1)-*-
;; Early Touches

(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8)

(eval-and-compile
  (setq gc-cons-threshold 402653184
	gc-cons-percentage 0.6))


(setq debug-on-error t)
(find-file "~/.emacs.d/init.org")
(setq tramp-ssh-controlmaster-options "") ;; Avoids Tramp bug in 25.0.50
(setq inhibit-startup-message t)
(if (fboundp 'tool-bar-mode) (tool-bar-mode -1))
(scroll-bar-mode -1)
(setq ring-bell-function 'ignore)
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(fset 'yes-or-no-p 'y-or-n-p)
(setq transient-mark-mode t)

(setq ns-pop-up-frames nil) ;; No new windows for dragged-in files in OS X
;; Basic Setup

(package-initialize)
(require 'package)
(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
			 ("marmalade" . "https://marmalade-repo.org/packages/")
			 ("melpa" . "http://melpa.milkbox.net/packages/")
			 ("org" . "https://orgmode.org/elpa/")))
(package-initialize)

(add-to-list 'load-path "~/.emacs.d/non-elpa/")

(require `use-package)
;; Appearance
(setq frame-title-format '("" "Emacs " emacs-version))

(set-face-attribute  'header-line nil
                     :background "gray83")
(set-face-attribute  'mode-line-inactive nil
                     :background "gray83")
(set-face-attribute  'mode-line nil
                     :background "light green")
(defun the-lines ()
  (setq header-line-format
        (list " %& %b"))
  ;; (set-face-background 'header-line (face-background 'modeline-inactive))
  (setq mode-line-format
        (list " %& %b (%m) %I %p %Z")))
(add-hook 'find-file-hooks 'the-lines t)
(the-lines)
(set-default-font "Inconsolata-18")
(add-to-list 'default-frame-alist '(font . "Inconsolata-18"))
;; Function Library


(defun do-nothing (arg)
  (interactive "P")
  (message (format-time-string "%Y-%m-%d %H:%M:%S")))

(defun full-path-of-buffer ()
  "Show the full path file name in the minibuffer, kill ring."
  ;; http://prodissues.com/2016/01/get-the-current-files-path-in-emacs.html
  (interactive)
  (message (buffer-file-name))
  (kill-new (file-truename buffer-file-name)))

(defun insert-current-time (arg)
  (interactive "P")
  (insert (format-time-string "%Y-%m-%d %H:%M:%S")))
(defun insert-current-date (arg)
  (interactive "P")
  (insert (format-time-string "%Y-%m-%d")))

(defun back-to-indentation-or-beginning ()
  (interactive)
  (if (= (point) (save-excursion (back-to-indentation) (point)))
      (beginning-of-line)
    (back-to-indentation)))

(defun indent-whole-buffer ()
  "indent whole buffer"
  (interactive)
  (delete-trailing-whitespace)
  (indent-region (point-min) (point-max) nil)
  (untabify (point-min) (point-max)))

(defun xml-format ()
  "Pretty-print an XML buffer"
  (interactive)
  (save-excursion
    (shell-command-on-region (mark) (point) "xmllint --format -" (buffer-name) t)))

(defun thorough-return ()
  (interactive)
  (newline-and-indent)
  (previous-line) (next-line))

(defun split-and-follow ()
  (interactive)
  (delete-other-windows)
  (split-window-horizontally)
  (follow-mode))

(defun yank-pop-forwards (arg)
  (interactive "p")
  (yank-pop (- arg)))


;; Following two snagged from https://github.com/sri/dotfiles/blob/master/emacs/emacs.d/my-fns.el#L236
(defun show-unsaved-changes ()
  (interactive)
  (diff-buffer-with-file (current-buffer)))

(defun find-file-as-sudo ()
  (interactive)
  (let ((file-name (buffer-file-name)))
    (when file-name
      (find-alternate-file (concat "/sudo::" file-name)))))


;; Making tabbing smartish in html-mode
(defun smartish-tab()
  (interactive)
  (if (use-region-p)
      (indent-rigidly-right-to-tab-stop (region-beginning) (region-end))
    (tab-to-tab-stop)))

(defun smartish-backtab()
  (interactive)
  (if (use-region-p)
      (indent-rigidly-left-to-tab-stop (region-beginning) (region-end))
    (delete-backward-char 1)))
;; Management and Movement

(use-package ido
  :ensure t
  :config (setq ido-enable-flex-matching t
		tab-always-indent 'complete
		ido-save-directory-list-file "~/.emacs.d/ido.last")
  ;; (ido-mode t)
  ;; (ido-everywhere t)
  ;; (add-hook 'ido-setup-hook
  ;;           (lambda ()
  ;;             (define-key ido-completion-map [tab] 'ido-complete))))
  (ido-mode +1))

(use-package smex
  :ensure t
  :bind (("M-x" . smex)
	 ("<f12>" . smex))
  :config (smex-initialize))

(setq backup-directory-alist
      `((".*" . ,temporary-file-directory)))
(setq auto-save-file-name-transforms
      `((".*" ,temporary-file-directory t)))



(defun delete-old-backup-files ()
  (message "Deleting old backup files...")
  (let ((week (* 60 60 24 7))
        (current (float-time (current-time))))
    (dolist (file (directory-files temporary-file-directory t))
      (when (and (backup-file-name-p file)
                 (> (- current (float-time (fifth (file-attributes file))))
                    week))
        (message "%s" file)
        (delete-file file))))
  (message (format-time-string "%Y-%m-%d %H:%M:%S")))

(setq auto-save-interval 500)

(use-package dired-x
  :demand t
  :init
  :commands (dired-jump)
  :bind ("C-x C-j" . dired-jump))


;; brew install coreutils
(if (executable-find "gls")
    (progn
      (setq insert-directory-program "gls")
      (setq dired-listing-switches "-lFaGh1v --group-directories-first"))
  (setq dired-listing-switches "-ahlF"))
;; (when (memq window-system '(mac ns))


(require 'recentf)
(setq recentf-max-menu-items 25
      recentf-max-saved-items 256
      recentf-save-file "~/.emacs.d/.recentf")
(recentf-mode 1)

(defun recentf-ido-find-file ()
  "Find a recent file using Ido."
  (interactive)
  (let ((file (ido-completing-read
               "Choose recent file: " recentf-list nil t)))
    (when file
      (find-file file))))
(put 'dired-find-alternate-file 'disabled nil)

(global-set-key (kbd "C-x C-r") 'recentf-ido-find-file)


(global-set-key (kbd "<f14>") 'reveal-in-osx-finder)
(defun set-frame-width-dwim ()
  (interactive)
  (set-frame-width (selected-frame)
                   (cond
                    ((eq (frame-width) 87) (* 87 2))
                    ((eq (frame-width) (* 87 2)) (* 87 3))
                    (t 87))))
(global-set-key (kbd "<f16>") 'set-frame-width-dwim)

;; Initial window positioning
(set-frame-position (selected-frame) 0 0)
(set-frame-width-dwim)
(set-frame-height (selected-frame) 72)

(use-package framemove
  :ensure t
  :config (setq framemove-hook-into-windmove t))
(global-set-key (kbd "s-<left>")  'windmove-left)
(global-set-key (kbd "s-<right>") 'windmove-right)
(global-set-key (kbd "s-<up>")    'windmove-up)
(global-set-key (kbd "s-<down>")  'windmove-down)

(winner-mode 1)

(global-set-key (kbd "<f13>") 'fit-window-to-buffer)
(global-set-key (kbd "C-<f13>") 'balance-windows)
(use-package uniquify
  :config (setq uniquify-buffer-name-style 'forward))

(global-unset-key (kbd "<f5>"))
(global-set-key (kbd "<f5>") 'revert-buffer)

(global-set-key (kbd "<f15>") 'ibuffer)

(use-package projectile
  :ensure t
  :config (setq projectile-enable-caching t)
  :bind (:map projectile-mode-map
	      ("s-p <return>" . projectile-switch-project)
	      ("s-p f" . projectile-find-file)
	      ("s-p d" . projectile-find-file-dwim)
	      ("s-p k" . projectile-kill-buffers)))
(projectile-mode)


(global-set-key (kbd "C-a") 'back-to-indentation-or-beginning)

(global-set-key (kbd "C-m") 'thorough-return)
(global-set-key (kbd "C-z") 'undo)

(global-set-key (kbd "M-Y") 'yank-pop-forwards)


(setq x-stretch-cursor t)
;; Editing
(setq default-tab-width 4)
(setq tab-width 4)
(defvaralias 'c-basic-offset 'tab-width)
(defvaralias 'cperl-indent-level 'tab-width)

(add-hook 'text-mode-hook 'turn-on-visual-line-mode)

(use-package display-line-numbers-mode
  :hook (html-mode python-mode web-mode)
  :init (setq display-line-numbers 'absolute
		display-line-numbers-current-absolute t
		display-line-numbers-width 4
		;;display-line-numbers-widen t
		))

;;(add-hook 'text-mode-hook 'linum-mode)

;;
;; (global-linum-mode 1)
;; (setq linum-disabled-modes-list '(ansi-term-mode
;;                                   bookmark-mode
;;                                   compilation-mode
;;                                   eshell-mode
;;                                   markdown-mode
;;                                   nov-mode
;;                                   org-mode
;;                                   shell-mode
;;                                   wl-summary-mode))
;; (defun linum-on ()
;;   (unless (or (minibufferp) (member major-mode linum-disabled-modes-list))
;;     (linum-mode 1)))
(add-hook 'window-configuration-change-hook (lambda () (ruler-mode 1)))
(setq show-paren-style 'mixed)
(show-paren-mode t)

(use-package highlight-parentheses
  :ensure t
  :diminish highlight-parentheses-mode
  :config
  (progn
    (set-face-attribute 'hl-paren-face nil :weight 'ultra-bold)
    (global-highlight-parentheses-mode)
    ;;make paren highlight update after stuff like paredit changes
    (add-to-list 'after-change-functions '(lambda (&rest x) (hl-paren-highlight)))))

(setq scroll-error-top-bottom t
	      scroll-conservatively 100
	      scroll-margin 3   ;Handy for keeping context while scrolling
	      scroll-preserve-screen-position t
	      auto-window-vscroll nil)
(setq mouse-autoselect-window nil
      mouse-wheel-progressive-speed nil)
;; mouse-wheel-scroll-amount '(0.05)
;; mouse-wheel-follow-mouse 't
(dolist (command '(yank yank-pop))
  (eval `(defadvice ,command (after indent-region activate)
           (and (not current-prefix-arg)
                (member major-mode '(lisp-mode emacs-lisp -mode
                                               clojure-mode    scheme-mode
                                               haskell-mode    ruby-mode
                                               rspec-mode
                                               c-mode          c++-mode
                                               objc-mode       latex-mode
                                               plain-tex-mode))
                ;; took out python-mode
                (let ((mark-even-if-inactive transient-mark-mode))
                  (indent-region (region-beginning) (region-end) nil))))))
(defvar no-easy-keys-minor-mode-map (make-keymap)
  "no-easy-keys-minor-mode keymap.")
(let ((f (lambda (m)
	   `(lambda () (interactive)
	      (message (concat "No! use " ,m " instead."))))))
  (dolist (l '(
	       ;; ("<left>" . "C-b")
	       ;; ("<right>" . "C-f")
	       ;; ("<up>" . "C-p")
	       ;; ("<down>" . "C-n")
	       ("<C-left>" . "M-b")
	       ("<C-right>" . "M-f")
	       ("<C-up>" . "M-{")
	       ("<C-down>" . "M-}")
	       ;; ("<M-left>" . "M-b")
	       ;; ("<M-right>" . "M-f")
	       ;; ("<M-up>" . "M-{")
	       ;; ("<M-down>" . "M-}")
	       ;; ("<delete>" . "C-d")
	       ;; ("<C-delete>" . "M-d")
	       ;; ("<M-delete>" . "M-d")
	       ;; ("<next>" . "C-v")
	       ;; ("<C-next>" . "M-x <")
	       ;; ("<prior>" . "M-v")
	       ("<C-prior>" . "M-x >")
	       ("<home>" . "C-a")
	       ("<C-home>" . "M-<")
	       ("<C-end>" . "M->")
	       ))
    (define-key no-easy-keys-minor-mode-map
      (read-kbd-macro (car l)) (funcall f (cdr l)))))
(define-minor-mode no-easy-keys-minor-mode
  "A minor mode that disables the arrow-keys, pg-up/down, delete
  and backspace."  t " no-easy-keys"
  'no-easy-keys-minor-mode-map :global t)
(no-easy-keys-minor-mode 1)
(use-package avy
  :ensure t
  :bind (("s-j" . avy-goto-word-1)
	 :map isearch-mode-map
	 ("C-'" . avy-search)))


;; Experimenting with code folding

(defun toggle-selective-display (column)
  (interactive "P")
  (set-selective-display
   (or column
       (unless selective-display
	 (1+ (current-column))))))

(global-set-key (kbd "C-<tab>") 'toggle-selective-display)

(use-package syntactic-close
  :ensure t
  :bind ("M-]" . syntactic-close))


(use-package vlf
  :ensure t
  :config (progn
            (require 'vlf-setup)))
(defun unicode-shortcut (shortcut code)
  (define-key key-translation-map
    (kbd shortcut)
    (kbd (char-to-string code))))

;; Stand-alone characters
(unicode-shortcut "M-_" #x2014) ; em dash

(global-unset-key (kbd "s-d"))

;; Diacritics using Unicode combining diacritical marks
(unicode-shortcut "s-d `" #x0300) ; ò - grave accent
(unicode-shortcut "s-d '" #x0301) ; ó - acute accent
(unicode-shortcut "s-d <" #x0302) ; ô - circumflex
(unicode-shortcut "s-d ~" #x0303) ; õ - tilde
(unicode-shortcut "s-d -" #x0304) ; ō - macron
(unicode-shortcut "s-d )" #x0306) ; ŏ - breve
(unicode-shortcut "s-d ." #x0307) ; ȯ - overdot
(unicode-shortcut "s-d :" #x0308) ; ö - diaeresis
(unicode-shortcut "s-d >" #x030C) ; ǒ - caron
(unicode-shortcut "s-d (" #x0311) ; ȏ - inverted breve
(unicode-shortcut "s-d o" #x030A) ; o̊ - overring

(unicode-shortcut "s-d 2 '" #x030B) ; ő - double acute accent
(unicode-shortcut "s-d 2 `" #x030F) ; ȍ - double grave accent
(global-set-key (kbd "<f11>") 'insert-current-date)
(global-set-key (kbd "C-<f11>") 'insert-current-time)



(global-unset-key (kbd "s-S"))

(use-package yasnippet
  :ensure t
  :diminish yas-minor-mode
  :config (progn
	    (setq yas-indent-line 'fixed
		  yas-snippet-dirs '("~/.emacs.d/personal-snippets"))

	    (yas-reload-all))
  :bind(
	;; ("<tab>" . nil)
	;; ("TAB" . nil)

	("s-s" . yas-expand)
	("s-S" . yas-new-snippet))
  :init (progn
	  (yas-global-mode 1)))


(global-set-key (kbd "C-=") 'er/expand-region)
(global-set-key (kbd "C-<return>") 'indent-whole-buffer)
;; Languages

;; (use-package org
;;   :ensure org-plus-contrib
;;   :pin org
;;   :defer t)

;; ;; Ensure ELPA org is prioritized above built-in org.
;; (require 'cl)
;; (setq load-path (remove-if (lambda (x) (string-match-p "org$" x)) load-path))



(global-set-key (kbd "C-c l") 'org-store-link)

(add-hook 'org-mode-hook
	  (lambda ()
	    (define-key org-mode-map (kbd "M-<left>") 'left-word)
	    (define-key org-mode-map (kbd "M-<right>") 'right-word)
	    (define-key org-mode-map (kbd "M-<up>") nil)
	    (define-key org-mode-map (kbd "M-<down>") nil)

	    (define-key org-mode-map (kbd "S-C-<left>") 'org-metaleft)
	    (define-key org-mode-map (kbd "S-C-<right>") 'org-metaright)
	    (define-key org-mode-map (kbd "S-C-<up>") 'org-metaup)
	    (define-key org-mode-map (kbd "S-C-<down>") 'org-metadown)))

(setq org-capture-templates
      '(("l" "Log" entry (file+datetree "~/.emacs.d/org/Log.org")
	 "* %<%T> - %?\n%i\n")))

(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))

(setq org-babel-use-quick-and-dirty-noweb-expansion t
      org-catch-invisible-edits t
      org-enforce-todo-dependencies t
      org-hide-leading-stars t
      org-log-done t
      org-return-follows-link t
      org-special-ctrl-a/e t
      org-src-fontify-natively t)

(global-set-key (kbd "<f9>") 'org-babel-tangle)
(global-set-key (kbd "C-<f9>") 'org-babel-execute-src-block)

(org-babel-do-load-languages
 'org-babel-load-languages
 '((dot . t)))

(use-package bbcode-mode
  :ensure t
  :bind (:map bbcode-mode-map
	      ("s-b" . bbcode/insert-tag-b)
	      ("s-i" . bbcode/insert-tag-i)))

(autoload 'markdown-mode "markdown-mode.el" "Major mode for Markdown files" t)
(setq auto-mode-alist (cons '("\\.md" . markdown-mode) auto-mode-alist)
      auto-mode-alist (cons '("\\.fountain" . markdown-mode) auto-mode-alist))
(add-hook 'markdown-mode-hook
	  (lambda ()
	    (turn-on-visual-line-mode)
	    (define-key markdown-mode-map (kbd "RET") 'thorough-return)
	    (define-key markdown-mode-map (kbd "M-<left>") 'left-word)
	    (define-key markdown-mode-map (kbd "M-<right>") 'right-word)))

(use-package fountain-mode
  :ensure t
  :mode ("\\.fountain\\'" . fountain-mode))

(use-package textile-mode
  :ensure t
  :mode ("\\.textile\\'" . textile-mode))
(autoload 'yaml-mode "yaml-mode")
(add-to-list 'auto-mode-alist '("\\.yml$" . yaml-mode))
(add-to-list 'auto-mode-alist '("\\.yaml$" . yaml-mode))
(add-hook 'yaml-mode-hook
          (lambda ()
            (define-key yaml-mode-map "\C-m" 'newline-and-indent)))
;; (setq sgml-basic-offset 4)

(use-package web-mode
  :ensure t
  :config (setq indent-tabs-mode nil
		web-mode-attr-indent-offset 4
		web-mode-code-indent-offset 4
		web-mode-css-indent-offset 4
		web-mode-markup-indent-offset 4
		web-mode-sql-indent-offset 4
		web-mode-enable-auto-quoting nil)
  :init (add-hook 'web-mode-hook
		  (lambda ()
		    (setq tab-width 4
			  indent-tabs-mode nil)))
  :mode (("\\.jsx\\'" . web-mode)
	 ("\\.js\\'" . web-mode))
  :bind ("C-<f15>" . web-mode-reload))

(use-package prettier-js
  :ensure t
  :commands (prettier-mode prettier-js)
  :hook web-mode
  :bind (("C-<return>" . prettier-js)
	 :map web-mode-map
	 ("C-<return>" . prettier-js))
  :config (setq prettier-target-mode "web-mode"))


;; (use-package html-mode
;;   :ensure nil
;;   :config (setq tab-width 4
;;              tab-stop-list (number-sequence 4 120 4)
;;              indent-line-function 'indent-relative)
;;   :mode (("\\.cfm\\'" . html-mode)
;;       ("\\.cfc\\'" . html-mode)
;;       ("\\.aspx\\'" . html-mode))
;;   :bind (("C-m" . newline-and-indent)))
;;       ;; ("<tab>" . smartish-tab)
;;       ;; ("<backtab>" . smartish-backtab))

(add-to-list 'auto-mode-alist '("\\.htm$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.html$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.cfm$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.cfc$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.aspx$" . html-mode))
(add-hook 'html-mode-hook
	  (lambda ()
	    (setq tab-width 4
		  indent-line-function 'indent-relative)
	    ;; (setq tab-stop-list (number-sequence 4 120 4))
	    (define-key html-mode-map (kbd "C-m") 'newline-and-indent)
	    (define-key html-mode-map (kbd "<tab>") 'smartish-tab)
	    (define-key html-mode-map (kbd "C-<return>") `do-nothing)))

(use-package less-css-mode
  :ensure t)

(autoload 'asp-mode "asp-mode")
(add-to-list 'auto-mode-alist '("\\.asp$" . asp-mode))

(add-to-list 'load-path "~/.emacs.d/plugins/jade-mode")
(require 'sws-mode)
(require 'jade-mode)
(add-to-list 'auto-mode-alist '("\\.styl$" . sws-mode))
(add-to-list 'auto-mode-alist '("\\.jade$" . jade-mode))
(add-hook 'sql-mode-hook
	  (lambda ()
	    (setq tab-width 4)
	    ;; (setq tab-stop-list (number-sequence 4 120 4))
	    (setq indent-line-function 'indent-relative)
	    (define-key sql-mode-map (kbd "C-m") 'newline-and-indent)
	    (define-key sql-mode-map (kbd "<tab>") 'tab-to-tab-stop)
	    (define-key sql-mode-map (kbd "C-<return>") do-nothing)))

;; (use-package sql-mode
;;   :ensure nil
;;   :bind (("C-m" . 'newline-and-indent)
;;       ("<tab>" . tab-to-tab-stop))
;;   :init (progn
;;        (setq tab-width 4
;;              tab-stop-list (number-sequence 4 120 4)
;;              indent-line-function 'indent-relative))
;;   :mode ("\\.sql\\'" . sql-mode))


(setq-default py-indent-offset 4)
(add-hook 'python-mode-hook '(lambda ()
			       (define-key
				 python-mode-map
				 (kbd "C-m")
				 'newline-and-indent)))

(autoload 'vbnet-mode "vbnet-mode" "Mode for editing VB.NET code." t)
(setq auto-mode-alist (append '(("\\.\\(frm\\|bas\\|cls\\|vb\\)$" .
				 vbnet-mode)) auto-mode-alist))

(autoload 'csharp-mode "csharp-mode" "Major mode for editing C# code." t)
(setq auto-mode-alist (append '(("\\.cs$" . csharp-mode)) auto-mode-alist))

;; (use-package nov
;;   :ensure t
;;   :config
;;   (push '("\\.epub\\'" . nov-mode) auto-mode-alist))

(use-package writegood-mode
  :ensure t
  :defer t
  :bind ("C-c C-g" . writegood-mode))
;; External program interfaces

(use-package exec-path-from-shell
  :ensure t
  :config
  (exec-path-from-shell-copy-env "SHELL")
  (exec-path-from-shell-copy-env "PATH")
  (exec-path-from-shell-copy-env "PYTHONPATH")
  (when (memq window-system '(mac ns x))
    (exec-path-from-shell-initialize)))
(eval-after-load 'grep
  '(progn
     (add-to-list 'grep-find-ignored-directories "CFIDE")
     (add-to-list 'grep-find-ignored-directories "lib-python")
     (add-to-list 'grep-find-ignored-directories "pypy-win")
     (add-to-list 'grep-find-ignored-directories "venv")))
(add-hook 'grep-mode-hook (lambda () (toggle-truncate-lines 1)))


(use-package ripgrep
  :ensure t
  :bind (("s-g" . ripgrep-regexp))
  :init (progn
	  (use-package projectile-ripgrep
	    :ensure t
	    :after projectile
	    :bind (:map projectile-mode-map
			("s-p g" . projectile-ripgrep)))))
(use-package magit
  :ensure t
  :defer nil
  :bind (("<f10>" . magit-status)
	 ("S-<f10>" . magit-log-buffer-file))
  :init (progn
	  (setq auto-revert-buffer-list-filter
		'magit-auto-revert-repository-buffers-p
		magit-auto-revert-mode nil
		magit-git-executable "/usr/local/bin/git"
		magit-last-seen-setup-instructions "1.4.0"
		magit-refresh-status-buffer nil
		vc-handled-backends nil)))

(use-package git-timemachine
  :ensure t
  :bind ("C-<f10>" . git-timemachine))
(use-package ispell
  :defer 15
  :ensure t
  :config
  (progn
    (cond
     ((executable-find "/usr/local/bin/aspell")
      ;;(setq ispell-extra-args '("--sug-mode=fast"))
      (setq ispell-extra-args '("--encoding=utf-8"))
      (setq ispell-program-name "/usr/local/bin/aspell"))))
  :bind
  (("<f6>" . ispell-word)
   ("C-<f6>" . ispell-buffer)))
(use-package langtool
  :config (setq langtool-default-language "en-US"
                langtool-language-tool-jar "~/Utilities/LanguageTool-3.0/languagetool-commandline.jar"
                langtool-mother-tongue "en-US")
  :bind (("<f7>" . langtool-check)
         ("C-<f7>" . langtool-show-message-at-point)
         ("S-<f7>" . langtool-check-done)))
(use-package osx-dictionary
  ;; Look up a string in the dictionary used by Dictionary.app
  :ensure t
  :config (setq osx-dictionary-dictionary-choice "Webster's")
  :bind ("<f8>" . osx-dictionary-search-word-at-point))

(use-package graphviz-dot-mode
  :ensure t
  :mode "\\.dot\\'")

(use-package atomic-chrome
  :ensure t
  :init (atomic-chrome-start-server))

;; Final touches

;; (use-package which-key
;;   :ensure t
;;   :diminish which-key-mode
;;   :config (which-key-mode))

(setq gc-cons-threshold 16777216
      gc-cons-percentage 0.1)

(message "Startup time: %s" (emacs-init-time))
(kill-buffer "init.org")

(use-package esup
  :ensure t)

(setq debug-on-error nil)