bauer: an Emacs+Nix IDE
Bauer’s Automated Unified Emacs Realm

Better defaults

(apply 'set-defaults
       (mapcar (lambda (x) (list (intern (car x))
                                 (if (stringp (cadr x))
                                     (car (read-from-string (cadr x)))
                                   (cadr x)))) defaults))

(when (file-exists-p user-emacs-directory)
  (make-directory (expand-file-name "auto-save/" user-emacs-directory) t)
  (make-directory (expand-file-name "backup/" user-emacs-directory) t)
  (make-directory (expand-file-name "undo-tree/" user-emacs-directory) t))

(set-defaults
 '(auto-save-file-name-transforms `((".*"
                                     ,(expand-file-name "auto-save/"
                                                        user-emacs-directory) t)))
 '(bug-reference-bug-regexp
   (concat "\\(\\(?:[Ii]ssue \\|[Ff]ixe[ds] \\|[Rr]esolve[ds]? \\|[Cc]lose[ds]?\\|"
           "[Pp]\\(?:ull [Rr]equest\\|[Rr]\\) \\|(\\)#\\([0-9]+\\))?\\)"))
 '(backup-directory-alist `((".*" .
                             ,(expand-file-name "backup/"
                                                user-emacs-directory))))
 '(company-auto-complete (lambda ()
                           (and (company-tooltip-visible-p)
                                (company-explicit-action-p))))
 '(company-continue-commands
   '(not save-buffer
         save-some-buffers
         save-buffers-kill-terminal
         save-buffers-kill-emacs
         comint-previous-matching-input-from-input
         comint-next-matching-input-from-input
         completion-at-point))
 '(company-backends '(company-elisp
                      company-css
                      company-cmake
                      company-nxml
                      (company-capf
                       company-files
                       company-keywords
                       company-dabbrev-code)
                      company-dabbrev))
 '(comint-password-prompt-regexp (concat
                                  "\\(^ *\\|"
                                  (regexp-opt
                                   '("Enter" "enter" "Enter same" "enter same" "Enter the" "enter the"
                                     "Enter Auth" "Old" "old" "New" "new" "'s" "login"
                                     "Kerberos" "CVS" "UNIX" " SMB" "LDAP" "PEM" "SUDO"
                                     "[sudo]" "Repeat" "Bad" "Retype")
                                   t)
                                  ;; Allow for user name to precede password equivalent (Bug#31075).
                                  " +.*\\)"
                                  "\\(?:" (regexp-opt password-word-equivalents) "\\|Response\\)"
                                  "\\(?:\\(?:, try\\)? *again\\| (empty for no passphrase)\\| (again)\\)?"
                                  ;; "[[:alpha:]]" used to be "for", which fails to match non-English.
                                  "\\(?: [[:alpha:]]+ .+\\)?[[:blank:]]*[:：៖][[:blank:]]*\\'"))
 '(compilation-environment '("TERM=xterm-256color"))
 '(completion-styles '(basic
                       partial-completion
                       emacs22
                       substring))
 '(custom-file (expand-file-name
                "settings.el"
                user-emacs-directory))
 '(dired-listing-switches "-alhv")
 '(dired-omit-files "^\\.\\|^#.*#$")
 '(dirtrack-list '("^[^:]*:\\(?:\e\\[[0-9]+m\\)?\\([^$#\e]+\\)" 1))
 '(eshell-banner-message "")
 '(eshell-ls-dired-initial-args '("-h"))
 '(eshell-ls-initial-args "-h")
 '(eshell-prompt-function
   (lambda ()
     (concat (when (tramp-tramp-file-p default-directory)
               (concat
                (tramp-file-name-user
                 (tramp-dissect-file-name default-directory))
                "@"
                (tramp-file-name-host
                 (tramp-dissect-file-name default-directory))
                " "))
             (let ((dir (eshell/pwd)))
               (if (string= dir (getenv "HOME")) "~"
                 (let ((dirname (file-name-nondirectory dir)))
                   (if (string= dirname "") "/" dirname))))
             (if (= (user-uid) 0) " # " " $ "))))
 '(eshell-visual-commands
   '("vi" "screen" "top" "less" "more" "lynx" "ncftp" "pine" "tin"
     "trn" "elm" "ssh" "mutt" "tmux" "htop"
     "alsamixer" "watch" "elinks" "links" "nethack" "vim"
     "cmus" "nmtui" "nmtui-connect" "nmtui-edit" "ncdu"
     "telnet" "rlogin"))
 '(eshell-visual-subcommands '(("vagrant" "ssh")))
 '(find-ls-option '("-print0 | xargs -P4 -0 ls -ldN" . "-ldN"))
 '(find-ls-subdir-switches "-ldN")
 '(flycheck-global-modes '(not erc-mode
                               message-mode
                               git-commit-mode
                               view-mode
                               outline-mode
                               text-mode
                               org-mode))
 '(flycheck-check-syntax-automatically '(save mode-enabled))
 '(frame-title-format
   '(:eval
     (if (buffer-file-name)
         (abbreviate-file-name (buffer-file-name))
       "%b")))
 '(haskell-compile-cabal-build-command "cabal new-build")
 '(haskell-hoogle-url "https://hoogle.haskell.org/?hoogle=%s")
 '(ibuffer-formats
   '((mark modified read-only " " (name 16 -1) " "
           (size 6 -1 :right) " " (mode 16 16) " " filename)
     (mark " " (name 16 -1) " " filename)))
 '(ibuffer-never-show-predicates '("\\*magit-\\(diff\\|process\\):"))
 '(ispell-extra-args '("--sug-mode=ultra"))
 '(magit-blame-disable-modes '(fci-mode view-mode yascroll-bar-mode))
 '(magit-process-find-password-functions
   '(magit-process-password-auth-source))
 '(magit-process-password-prompt-regexps '(
                                           "^\\(Enter \\)?[Pp]assphrase\\( for \\(RSA \\)?key '.*'\\)?: ?$"
                                           "^\\(Enter \\)?[Pp]assword\\( for '?\\(https?://\\)?\\(?99:[^']*\\)'?\\)?: ?$"
                                           "Please enter the passphrase for the ssh key"
                                           "Please enter the passphrase to unlock the OpenPGP secret key"
                                           "^.*'s password: ?$"
                                           "^Yubikey for .*: ?$"
                                           "^Enter PIN for .*: ?$"
                                           "^\\[sudo\\] password for .*: ?$"))
 '(mouse-wheel-scroll-amount '(1
                               ((shift) . 5)
                               ((control))))
 '(minibuffer-prompt-properties
   '(read-only t
               cursor-intangible t
               face minibuffer-prompt))
 '(org-latex-listings-langs
   '((emacs-lisp "Lisp")
     (lisp "Lisp")
     (clojure "Lisp")
     (c "C")
     (cc "C++")
     (fortran "fortran")
     (perl "Perl")
     (cperl "Perl")
     (python "Python")
     (ruby "Ruby")
     (html "HTML")
     (xml "XML")
     (tex "TeX")
     (latex "[LaTeX]TeX")
     (shell-script "bash")
     (gnuplot "Gnuplot")
     (ocaml "Caml")
     (caml "Caml")
     (sql "SQL")
     (sqlite "sql")
     (makefile "make")
     (R "r")
     (nix "{}")
     (nil "{}")
     (yaml "{}")
     (gitattributes "{}")
     (gitignore "{}")
     (shell "{}")
     (gitconfig "{}")))
 '(org-latex-default-packages-alist
   '(("utf8" "inputenc" t
      ("pdflatex"))
     ("T1" "fontenc" t
      ("pdflatex"))
     ("" "graphicx" t nil)
     ("" "grffile" t nil)
     ("" "longtable" nil nil)
     ("" "wrapfig" nil nil)
     ("" "rotating" nil nil)
     ("normalem" "ulem" t nil)
     ("" "amsmath" t nil)
     ("" "textcomp" t nil)
     ("" "amssymb" t nil)
     ("" "capt-of" nil nil)
     ("" "hyperref" nil nil)
     ("" "parskip" nil nil)
     ("" "alltt" nil nil)
     ("" "upquote" nil nil)
     ("" "listings" nil nil)))
 '(package-archives
   '(("melpa" . "https://melpa.org/packages/")
     ("org" . "http://orgmode.org/elpa/")
     ("gnu" . "https://elpa.gnu.org/packages/")))
 '(projectile-globally-ignored-files '(".DS_Store" "TAGS"))
 '(projectile-ignored-project-function
   (lambda (file) (or (file-remote-p file)
                      (string-prefix-p "/nix" file)
                      (string-prefix-p "/nix/store" file)
                      (string-suffix-p "/.local/share/Trash/files/" file))))
 '(projectile-mode-line-prefix "")
 '(projectile-mode-line-function
   (lambda () (if (and (ignore-errors (projectile-project-p))
                       (not (file-remote-p default-directory)))
                  (format " Projectile[%s]" (projectile-project-name))
                "")))
 '(savehist-additional-variables '(search-ring
                                   regexp-search-ring
                                   kill-ring
                                   comint-input-ring
                                   kmacro-ring
                                   sr-history-registry
                                   file-name-history
                                   tablist-name-filter))
 '(tab-stop-list (number-sequence 4 200 4))
 '(tramp-default-proxies-alist
   '(((regexp-quote (system-name)) nil nil)
     (nil "\\`root\\'" "/ssh:%h:")
     (".*" "\\`root\\'" "/ssh:%h:")))
 '(uniquify-ignore-buffers-re "^\\*")
 '(uniquify-separator "/")
 '(undo-tree-mode-lighter "")
 '(undo-tree-history-directory-alist
   `((".*" . ,(expand-file-name "undo-tree/" user-emacs-directory))))
 '(vc-git-diff-switches '("-w" "-U3"))
 '(vc-ignore-dir-regexp
   (concat "\\(\\(\\`"
           "\\(?:[\\/][\\/][^\\/]+[\\/]\\|/"
           "\\(?:net\\|afs\\|\\.\\.\\.\\)/\\)"
           "\\'\\)\\|\\(\\`/[^/|:][^/|]*:\\)\\)\\|\\"
           "(\\`/[^/|:][^/|]*:\\)"))
 '(which-key-lighter "")
 '(whitespace-action '(cleanup))
 '(whitespace-style '(face trailing lines space-before-tab
                           empty lines-style))
 '(whitespace-global-modes '(not erc-mode ses-mode)))

Site paths

(load "site-paths" t)

Set environment

(set-envs
 '("EDITOR" "emacsclient -a emacs")
 '("NODE_NO_READLINE" "1")
 '("PAGER" "cat")
 '("PS1" "\\W > ")
 )

(when (eq window-system 'w32)
  (setenv "GIT_ASKPASS" "git-gui--askpass"))

Load custom file

(load custom-file t)

Essentials

• aggressive-indent
  

  GitHub

  Automatically indent code as you type. Only enabled for Lisp currently.

  (use-package aggressive-indent
    :hook ((emacs-lisp-mode
            inferior-emacs-lisp-mode
            ielm-mode
            lisp-mode
            inferior-lisp-mode
            isp-interaction-mode
            slime-repl-mode) . aggressive-indent-mode))
  

• align
  

  (use-package align
    :bind ("M-[" . align)
    :config
    (add-to-list 'align-rules-list
                 '(haskell-types
                   (regexp . "\\(\\s-+\\)\\(::\\|∷\\)\\s-+")
                   (modes quote (haskell-mode literate-haskell-mode))))
    (add-to-list 'align-rules-list
                 '(haskell-assignment
                   (regexp . "\\(\\s-+\\)=\\s-+")
                   (modes quote (haskell-mode literate-haskell-mode))))
    (add-to-list 'align-rules-list
                 '(haskell-arrows
                   (regexp . "\\(\\s-+\\)\\(->\\|→\\)\\s-+")
                   (modes quote (haskell-mode literate-haskell-mode))))
    (add-to-list 'align-rules-list
                 '(haskell-left-arrows
                   (regexp . "\\(\\s-+\\)\\(<-\\|←\\)\\s-+")
                   (modes quote (haskell-mode literate-haskell-mode))))
    )
  

• Company
  

  Website

  Company provides completions in Emacs. Activate them by pressing C-M-i.

  (use-package company
    :commands global-company-mode
    :delight
    :demand
    :preface
    (load "company-autoloads" t t)
    (defun company-complete-common-or-cycle-backward ()
      "Complete common prefix or cycle backward."
      (interactive)
      (company-complete-common-or-cycle -1))
    :bind (:map company-mode-map
                ("C-M-i" . company-complete-common-or-cycle)
                :map company-active-map
                ("RET" . company-complete-selection)
                ([return] . company-complete-selection)
                ("C-j" . company-complete-selection)
  
                ("TAB" . company-complete-common-or-cycle)
                ("<tab>" . company-complete-common-or-cycle)
                ("S-TAB" . company-complete-common-or-cycle-backward)
                ("<backtab>" . company-complete-common-or-cycle-backward)
                ("C-n" . company-select-next)
                ("C-p" . company-select-previous)
  
                ("C-/" . company-search-candidates)
                ("C-M-/" . company-filter-candidates)
                ("C-d" . company-show-doc-buffer)
                )
    :hook (;; (minibuffer-setup . company-mode)
           ;; (minibuffer-setup . (lambda ()
           ;;                       (setq-local company-frontends '(company-preview-if-just-one-frontend))
           ;;                       (setq-local company-auto-complete nil)))
           (after-init . global-company-mode)
           (shell-mode .
                       (lambda ()
                         (setq-local company-backends '(company-capf))))
           (eshell-mode . (lambda () (setq-local company-backends '(company-files)))))
    :config
    (advice-add 'completion-at-point
                :around (lambda (old-function &rest args)
                          (if company-mode
                              (apply 'company-complete-common-or-cycle args)
                            (apply old-function args))))
    (global-company-mode))
  

  • company-irony
    

    (use-package company-irony
      :commands company-irony
      :hook (irony-mode . (lambda ()
        (setq-local company-backends '(company-irony company-capf)))))
    

  • company-restclient
    

    (use-package company-restclient
      :commands company-restclient
      :hook (restclient-mode . (lambda ()
        (setq-local company-backends '(company-restclient company-capf)))))
    

  • company-anaconda
    

    (use-package company-anaconda
      :commands company-anaconda
      :hook (anaconda-mode . (lambda ()
                               (setq-local company-backends '((company-anaconda
                                                               company-capf))))))
    

  • company-auctex
    

    (use-package company-auctex
      :commands (company-auctex
                 company-auctext-labels
                 company-auctest-bibs
                 company-auctex-macros
                 company-auctext-symbols
                 company-auctext-environments)
      :hook
      (tex-mode . (lambda ()
                    (setq-local company-backends '((company-auctex-labels
                                                    company-auctex-bibs
                                                    company-auctex-macros
                                                    company-auctex-environments
                                                    company-auctex-symbols
                                                    company-capf))))))
    

  • company-web
    

    (use-package company-web
      :preface
      (autoload 'company-web-html "company-web-html")
      (autoload 'company-web-jade "company-web-jade")
      (autoload 'company-web-slim "company-web-slim")
      :hook ((web-mode . (lambda ()
                           (setq-local company-backends '(company-web-html
                                                          company-web-jade
                                                          company-web-slim
                                                          company-capf))))))
    

  • company-math
    

    (use-package company-math
      :preface
      (autoload 'company-math-symbols-latex "company-math")
      (autoload 'company-latex-commands "company-math")
      :hook
      (TeX-mode . (lambda ()
                    (setq-local company-backends '((company-math-symbols-latex
                                                    company-latex-commands
                                                    company-capf))))))
    

• Counsel
  

  GitHub

  Counsel provides a better selection experience to the default Emacs.

  Counsel is only enabled on non-Windows systems. This is due to an issue in counsel-find-file, see https://github.com/abo-abo/swiper/issues/773 for more info.

  (use-package counsel
    :disabled
    :commands (counsel-mode counsel-descbinds
               counsel-grep-or-swiper)
  
    ;; counsel doesn’t work well with windows drives
    ;; see https://github.com/abo-abo/swiper/issues/773
    ;; :if (not (string= system-type "windows-nt"))
  
    :bind* (([remap execute-extended-command] . counsel-M-x)
            ([remap find-library] . counsel-find-library)
            ([remap describe-bindings]  .
             counsel-descbinds)
            ([remap describe-face]  .
             counsel-describe-faces)
            ([remap list-faces-display] . counsel-faces)
            ([remap imenu] . counsel-imenu)
            ([remap load-library] . counsel-load-library)
            ([remap load-theme] . counsel-load-theme)
            ([remap yank-pop] . counsel-yank-pop)
            ([remap info-lookup-symbol] .
             counsel-info-lookup-symbol)
            ([remap pop-to-mark-command] .
             counsel-mark-ring)
            ([remap bookmark-jump] . counsel-bookmark)
            ("C-c j" . counsel-git-grep)
            ("C-x l" . counsel-locate)
            ("M-y" . counsel-yank-pop)
            ("C-c i 8" . counsel-unicode-char)
            ("C-x M-f" . counsel-find-file)
  
            :map help-map
            ("C-v" . counsel-find-symbol)
            ("C-k" . counsel-find-function-on-key)
            ("C-l" . counsel-find-library)
            ))
  

  • ivy
    

    (use-package ivy
      :commands (ivy-read)
      :bind (([remap list-buffers] . ivy-switch-buffer)
             ([remap switch-to-buffer] . ivy-switch-buffer)
             ([remap switch-to-buffer-other-window] .
              ivy-switch-buffer-other-window)
             :package ivy
             :map ivy-minibuffer-map
             ("<escape>" . abort-recursive-edit))
      :init
      (defvar projectile-completion-system)
      (defvar magit-completing-read-function)
      (defvar projector-completion-system)
      (setq projectile-completion-system 'ivy
            magit-completing-read-function 'ivy-completing-read)
      :commands (ivy-completing-read
                 ivy-completion-in-region
                 swiper))
    

• diff-hl
  

  This mode provides indicators at the right fringe of the Emacs buffer. These indications show where a file has been edited from the last Git commit.

  (use-package diff-hl
    :disabled
    :bind (:package diff-hl
           :map diff-hl-mode-map
           ("<left-fringe> <mouse-1>" . diff-hl-diff-goto-hunk))
    :hook ((prog-mode . diff-hl-mode)
           (vc-dir-mode . diff-hl-mode)
           (dired-mode . diff-hl-dir-mode)
           (magit-post-refresh . diff-hl-magit-post-refresh)
           (org-mode . diff-hl-mode)))
  

• dtrt-indent
  

  GitHub

  This mode will try to

  (use-package dtrt-indent
    :delight
    :hook (prog-mode . dtrt-indent-mode))
  

• Emacs shell
  

  Emacs shell provides . Run eshell by typing C-c e or M-x eshell.

  (use-package eshell
    :bind (("C-c M-t" . eshell)
           ("C-c x" . eshell)
           ("C-c e" . eshell))
    :hook (;; (eshell-first-time-mode-hook . eshell-read-history)
           (eshell-first-time-mode-hook . (lambda () (add-hook 'eshell-expand-input-functions 'eshell-spawn-external-command))))
    :preface
    (defvar eshell-isearch-map
      (let ((map (copy-keymap isearch-mode-map)))
        (define-key map [(control ?m)] 'eshell-isearch-return)
        (define-key map [return]       'eshell-isearch-return)
        (define-key map [(control ?r)] 'eshell-isearch-repeat-backward)
        (define-key map [(control ?s)] 'eshell-isearch-repeat-forward)
        (define-key map [(control ?g)] 'eshell-isearch-abort)
        (define-key map [backspace]    'eshell-isearch-delete-char)
        (define-key map [delete]       'eshell-isearch-delete-char)
        map)
      "Keymap used in isearch in Eshell.")
    (defalias 'eshell/q 'eshell/exit)
    (defalias 'eshell/\? 'help)
    (defun eshell-spawn-external-command (beg end)
      "Parse and expand any history references in current input."
      (save-excursion
        (goto-char end)
        (when (looking-back "&!" beg)
          (delete-region (match-beginning 0) (match-end 0))
          (goto-char beg)
          (insert "spawn ")))))
  

  • em-rebind
    

    (use-package em-rebind
      :ensure nil
      :demand
      :config
      ;; TODO: move this back to customize
      (setq eshell-rebind-keys-alist
            '(([(control 97)] . eshell-bol)
              ([home] . eshell-bol)
              ([(control 100)] . eshell-delchar-or-maybe-eof)
              ([backspace] . eshell-delete-backward-char)
              ([delete] . eshell-delete-backward-char)
              ([(control 119)] . backward-kill-word)
              ([(control 117)] . eshell-kill-input)
              ([tab] . completion-at-point)
              ([(control 101)] . (lambda ()
                                   (interactive) (end-of-line)))))
    
      ;; TODO: move this back to customize
      (setq eshell-modules-list
            '(eshell-alias
              eshell-basic
              eshell-cmpl
              eshell-dirs
              eshell-glob
              eshell-hist
              eshell-ls
              eshell-pred
              eshell-prompt
              eshell-rebind
              eshell-script
              eshell-term
              eshell-tramp
              eshell-unix
              eshell-xtra
              )))
    
    

  • esh-help
    

    (use-package esh-help
      :preface
      (autoload 'esh-help-eldoc-command "esh-help")
      (defun esh-help-turn-on ()
        (interactive)
        (setq-local eldoc-documentation-function
                    'esh-help-eldoc-command)
        (setq eldoc-documentation-function
                    'esh-help-eldoc-command)
        (eldoc-mode 1))
      :hook (eshell-mode . esh-help-turn-on))
    

  • em-dired
    

    (use-package em-dired
      :preface
      (autoload 'em-dired-new "em-dired")
      :ensure nil
      :bind (:package dired
             :map dired-mode-map
             ("e" . em-dired))
      :hook (eshell-mode . em-dired-mode)
      :init
      (advice-add 'eshell :before 'em-dired-new))
    

• Flycheck
  

  Website

  Flycheck will annotate code with errors from the compiler or interpreter. It supports many languages and give us a lot of features right out of the box.

  (use-package flycheck
    :hook ((prog-mode . flycheck-mode)
           (haskell-mode . (lambda () (flycheck-mode -1)))
           (c++-mode . (lambda () (flycheck-mode -1)))))
  ;; (use-package flycheck-haskell
  ;;   :hook (haskell-mode . flycheck-haskell-setup))
  (use-package flycheck-cask
    :hook (emacs-lisp-mode . flycheck-cask-setup))
  (use-package flycheck-rust
    :hook (rust-mode . flycheck-rust-setup))
  

• Gnus
  

  Website

  Gnus is an infamous email client & news reader.

  (use-package gnus
    :commands gnus
    :hook ((dired-mode . turn-on-gnus-dired-mode)))
  

• God Mode
  

  GitHub

  God Mode makes it easier to type Emacs shortcuts involving lots of modifier keys. Activate it by pressing Escape (Notice “God” at the bottom of the screen). You no longer have to press & hold the control key!

  Note that god-mode overwrites escape key. This can cause some issues for certain Emacs keybinds.

    (use-package god-mode
      :bind (("<escape>" . god-local-mode)
  ;;           ("ESC" . god-local-mode)
  ))
  

• helpful
  

  (use-package helpful
    :if (>= emacs-major-version 25)
    :bind (([remap describe-function] . helpful-callable)
           ([remap describe-variable] . helpful-variable)
           ([remap describe-key] . helpful-key)
           ("H-h" . helpful-at-point)))
  

• Hippie Expand
  

  Hippie provides dynamic expansions. Try it out by pressing M-/.

  (use-package hippie-exp
    :bind* (("M-/" . hippie-expand)
            ("s-?" . hippie-expand-line))
    :hook ((emacs-lisp-mode ielm-mode) .
           (lambda ()
             (setq-local
              hippie-expand-try-functions-list
              (append '(try-complete-lisp-symbol-partially
                        try-complete-lisp-symbol)
               hippie-expand-try-functions-list)))))
  

• Magit
  

  Website

  Magit is a Git porcelain for Emacs. All of the features from the Git command line are available in an intuitive Emacs buffer.

  (use-package magit
    :preface
    (autoload 'magit-toplevel "magit")
    (autoload 'magit-read-string-ns "magit")
    (autoload 'magit-get "magit")
    ;; (autoload 'magit-define-popup-action "magit")
    (autoload 'magit-remote-arguments "magit")
    (defun magit-dired-other-window ()
      (interactive)
      (dired-other-window (magit-toplevel)))
  
    ;; (defun magit-remote-github (username &optional args)
    ;;   (interactive (list (magit-read-string-ns "User name")
    ;;                      (magit-remote-arguments)))
    ;;   (let* ((url (magit-get "remote.origin.url"))
    ;;          (match (string-match
    ;;                  "^\\(?:https?://github\.com/\\|git@github.com:\\|ssh://git@github\.com/\\)[^/]*/\\(.*\\)"
    ;;                  url)))
    ;;     (unless match
    ;;       (error "Not a github remote"))
    ;;     (let ((repo (match-string 1 url)))
    ;;       (apply 'magit-remote-add username
    ;;              (format "ssh://git@github.com/%s/%s"
    ;;                      username repo) args))))
    ;; :hook (magit-mode . (lambda ()
    ;;                       (magit-define-popup-action
    ;;                         'magit-remote-popup
    ;;                         ?g
    ;;                         "Add remote from github user name"
    ;;                         'magit-remote-github)))
  
    :commands (magit-clone magit-blame-addition magit-log-buffer-file)
    :if (locate-file "git" exec-path)
    :bind (("C-x g" . magit-status)
           ("C-x G" . magit-dispatch)
           :package magit
           :map magit-mode-map
           ("C-o" . magit-dired-other-window)))
  

  Magit forge.

  (use-package forge
    :after magit)
  

  Magit todos

  (use-package magit-todos
    :commands (magit-todos-list))
  

  • git-commit
    

    (use-package git-commit
      :hook ((git-commit-mode . flyspell-mode)
    	 (git-commit-mode . git-commit-save-message)
    	 (git-commit-mode . turn-on-auto-fill)))
    

• MMM Mode
  

  GitHub

  MMM mode lets you edit multiple languages within one buffer.

  (use-package mmm-mode
    :commands mmm-mode
    :config
    (use-package mmm-auto
      :ensure nil))
  

• multiple-cursors
  

  GitHub

  Multiple cursors give you more cursors. It is bound to C-> & C-<.

  (use-package multiple-cursors
    :bind
    (("<C-S-down>" . mc/mark-next-like-this)
     ("<C-S-up>" . mc/mark-previous-like-this)
     ("C->" . mc/mark-next-like-this)
     ("C-<" . mc/mark-previous-like-this)
     ("M-<mouse-1>" . mc/add-cursor-on-click)
     ("C-c C-<"     . mc/mark-all-like-this)
     ("C-!"         . mc/mark-next-symbol-like-this)
     ("C-S-c C-S-c" . mc/edit-lines)))
  

• Org
  

  Website

  Org mode is an impressive suite of text editing solutions. It gives you an outliner but also much much more.

  (use-package org
    :ensure org-plus-contrib
    :hook ((org-mode . (lambda ()
             (add-hook 'completion-at-point-functions
                       'pcomplete-completions-at-point nil t)))
           (org-mode . auto-fill-mode)
           (org-mode . (lambda () (setq-local scroll-margin 3)))
           (message-mode . turn-on-orgtbl)
           (org-mode . (lambda ()
             (autoload 'org-eldoc-documentation-function "org-eldoc")
             (setq-local eldoc-documentation-function
                         'org-eldoc-documentation-function))))
    :bind* (("C-c c" . org-capture)
            ("C-c a" . org-agenda)
            ("C-c l" . org-store-link)
            ("C-c b" . org-iswitchb))
    :config
    (use-package ob-dot
      :ensure nil
      :demand)
    (use-package ox-latex
      :ensure nil
      :demand)
    (use-package ox-beamer
      :ensure nil
      :demand)
    (use-package ox-md
      :ensure nil
      :demand))
  (use-package org-download
    :hook (dired-mode . org-download-enable))
  (use-package org-present
    :commands org-present)
  (use-package org-journal
    :commands org-journal-new-entry)
  

• Projectile
  

  GitHub

  Setup projectile & link it with some other packages. This also adds an easymenu to make the “Projectile” modeline clickable.

  (use-package projectile
    :commands projectile-mode
    :bind-keymap* (("C-c p" . projectile-command-map)
                   ("s-p" . projectile-command-map))
    :bind (("C-c C-f" . projectile-find-file))
    :preface
    (autoload 'projectile-project-vcs "projectile")
    (autoload 'projectile-project-root "projectile")
    (autoload 'easy-menu-define "easymenu" "" nil 'macro)
    :demand
    :config
    (projectile-mode))
  

• Recentf
  

  (use-package recentf
    :disabled
    :config (recentf-mode 1))
  

• smart-hungry-delete
  

  GitHub

  Smart hungry delete automatically delete lots of whitespace in a row.

  (use-package smart-hungry-delete
    :if (>= emacs-major-version 25)
    :bind (:map prog-mode-map
           ("<backspace>" .
            smart-hungry-delete-backward-char)
           ("C-d" .
            smart-hungry-delete-forward-char))
    :hook ((prog-mode .
            smart-hungry-delete-default-prog-mode-hook)
           (c-mode-common .
            smart-hungry-delete-default-c-mode-common-hook)
           (python-mode .
            smart-hungry-delete-default-c-mode-common-hook)
           (text-mode .
            smart-hungry-delete-default-text-mode-hook)))
  

• Smartparens
  

  Website

  Smartparens is helpful in closing parenthesis when editing Lisp code.

  (use-package smartparens
    :preface
    (autoload 'sp-local-pair "smartparens")
    (autoload 'sp-local-tag  "smartparens")
    :hook (((emacs-lisp-mode
             inferior-emacs-lisp-mode
             ielm-mode
             lisp-mode
             inferior-lisp-mode
             lisp-interaction-mode
             slime-repl-mode
             eval-expression-minibuffer-setup) .
            smartparens-strict-mode)
           ((emacs-lisp-mode
             inferior-emacs-lisp-mode
             ielm-mode
             lisp-mode
             inferior-lisp-mode
             lisp-interaction-mode
             slime-repl-mode
             org-mode) . show-smartparens-mode)
           ((web-mode
             html-mode) . smartparens-mode))
    :bind (:map smartparens-mode-map
           ("C-M-f" . sp-forward-sexp) ;; navigation
           ("C-M-b" . sp-backward-sexp)
           ("C-M-u" . sp-backward-up-sexp)
           ("C-M-d" . sp-down-sexp)
           ("C-M-p" . sp-backward-down-sexp)
           ("C-M-n" . sp-up-sexp)
           ("M-s" . sp-splice-sexp) ;; depth-changing commands
           ("M-<up>" . sp-splice-sexp-killing-backward)
           ("M-<down>" . sp-splice-sexp-killing-forward)
           ("M-r" . sp-splice-sexp-killing-around)
           ("M-(" . sp-wrap-round)
           ("C-)" . sp-forward-slurp-sexp) ;; barf/slurp
           ("C-<right>" . sp-forward-slurp-sexp)
           ("C-}" . sp-forward-barf-sexp)
           ("C-<left>" . sp-forward-barf-sexp)
           ("C-(" . sp-backward-slurp-sexp)
           ("C-M-<left>" . sp-backward-slurp-sexp)
           ("C-{" . sp-backward-barf-sexp)
           ("C-M-<right>" . sp-backward-barf-sexp)
           ("M-S" . sp-split-sexp) ;; misc
           ("M-j" . sp-join-sexp))
    :config
    (autoload 'sp-with-modes "smartparens" "" nil 'macro)
    (use-package smartparens-config
      :ensure nil
      :demand)
  
    (sp-with-modes 'org-mode
      (sp-local-pair "*" "*"
        :actions '(insert wrap)
        :unless '(sp-point-after-word-p sp-point-at-bol-p)
        :wrap "C-*" :skip-match 'sp--org-skip-asterisk)
      (sp-local-pair "_" "_" :unless '(sp-point-after-word-p)
                             :wrap "C-_")
      (sp-local-pair "/" "/" :unless '(sp-point-after-word-p)
                     :post-handlers '(("[d1]" "SPC")))
      (sp-local-pair "~" "~" :unless '(sp-point-after-word-p)
                     :post-handlers '(("[d1]" "SPC")))
      (sp-local-pair "=" "=" :unless '(sp-point-after-word-p)
                     :post-handlers '(("[d1]" "SPC")))
      (sp-local-pair "«" "»"))
  
    (sp-with-modes '(java-mode c++-mode)
      (sp-local-pair "{" nil
                     :post-handlers '(("||\n[i]" "RET")))
      (sp-local-pair "/*" "*/"
                     :post-handlers '((" | " "SPC")
                                      ("* ||\n[i]" "RET"))))
  
    (sp-with-modes '(markdown-mode gfm-mode rst-mode)
      (sp-local-pair "*" "*" :bind "C-*")
      (sp-local-tag "2" "**" "**")
      (sp-local-tag "s" "```scheme" "```")
      (sp-local-tag "<"  "<_>" "</_>"
                    :transform 'sp-match-sgml-tags))
  
    (sp-local-pair 'emacs-lisp-mode "`" nil
                   :when '(sp-in-string-p))
    (sp-local-pair 'clojure-mode "`" "`"
                   :when '(sp-in-string-p))
    (sp-local-pair 'minibuffer-inactive-mode "'" nil
                   :actions nil)
  
    (sp-with-modes 'nix-mode
      (sp-local-pair "'" "'"
                     :unless '(sp-in-comment-p
                               sp-in-string-quotes-p))
      (sp-local-pair "\"" "\"")
      (sp-local-pair "''" "''"
                     :unless '(sp-in-comment-p
                               sp-in-string-quotes-p))))
  

• sudo-edit
  

  GitHub

  Sudo-edit lets you open a file using sudo (it actually goes through TRAMP to achieve this).

  (use-package sudo-edit
    :bind (("C-c C-r" . sudo-edit)))
  

• Theme
  

  GitHub

  This is the theme I use & it works well for this configuration. It is dark with high contrast. We will only enable it when we are running with GUI Emacs.

  (use-package apropospriate-theme
    :if window-system
    :init
    (add-to-list 'custom-theme-load-path
                 (file-name-directory
                   (locate-library "apropospriate-theme")))
    (load-theme 'apropospriate-dark t))
  

  (unless (display-graphic-p)
    (set-background-color "black")
    (set-foreground-color "white"))
  

  While apropospriate is the default, other themes can be used as well! For instance spacemacs-theme can be enabled:

  (use-package spacemacs-common
    :ensure spacemacs-theme
    :if window-system
    :init
    (add-to-list 'custom-theme-load-path
                 (file-name-directory
                   (locate-library "spacemacs-theme-pkg")))
    (load-theme 'spacemacs-dark t))
  

• try
  

  GitHub

  (use-package try
    :commands try)
  

• which-key
  

  Which-key will tell you what key bindings are available give a prefix. Test it out by pressing C-x & waiting a few seconds. Each key listed is bound to a function.

  (use-package which-key
    :demand
    :commands which-key-mode
    :config (which-key-mode 1))
  

Built-ins

• ansi-color
  

  Get color/ansi codes in compilation mode.

  (use-package ansi-color
    :hook (compilation-filter . colorize-compilation-buffer)
    :preface
    (autoload 'ansi-color-apply-on-region "ansi-color")
    (defun colorize-compilation-buffer ()
      (let ((inhibit-read-only t))
        (ansi-color-apply-on-region (point-min) (point-max)))))
  

• autorevert
  

  Autorevert mode makes files update when they have changed on disk. Unfortunately this can have some issues in cases where Emacs uses the wrong file. Need to investigate how to fix this.

  (use-package autorevert
    :commands global-auto-revert-mode
    :demand
    :config (global-auto-revert-mode t))
  
  (require 'vc-git)
  (advice-add 'vc-git-find-file-hook :override
    (lambda ()
      "Activate `smerge-mode' if there is a conflict."
      (when (and buffer-file-name
                 (eq (vc-state buffer-file-name 'Git) 'conflict)
                 (save-excursion
                   (goto-char (point-min))
                   (re-search-forward "^<<<<<<< " nil 'noerror)))
        (unless (and (boundp 'smerge-mode) smerge-mode)
          (smerge-start-session))
        (when vc-git-resolve-conflicts
          (add-hook 'after-save-hook 'vc-git-resolve-when-done nil 'local))
        (vc-message-unresolved-conflicts buffer-file-name))))
  

• bug-reference
  

  Provides links to bugs listed in source code.

  (use-package bug-reference
    :hook ((prog-mode . bug-reference-prog-mode)
           (text-mode . bug-reference-mode)))
  

• comint
  

  Base mode used for shell and terminal modes.

    (defvar comint-input-ring-prefix ": [[:digit:]]+:[[:digit:]]+;"
      "Possible prefix that may come before history elements. In
      Zshell with extended_history, this is useful.")
  
    (defvar ffap-url-at-point)
    (use-package comint
      :ensure nil
      :hook (comint-mode . (lambda () (setq-local ffap-url-at-point "/ssh:")))
      :preface
      (autoload 'comint-write-input-ring "comint")
      (autoload 'comint-read-input-ring "comint")
      (autoload 'comint-send-invisible "comint")
      (defun turn-on-comint-history (history-file)
        (setq comint-input-ring-file-name history-file)
        (comint-read-input-ring 'silent))
      (defun save-history ()
        (dolist (buffer (buffer-list))
          (with-current-buffer buffer
            (comint-write-input-ring))))
      :config
      (advice-add 'comint-read-input-ring
                  :override (lambda (&optional silent)
                              (cond ((or (null comint-input-ring-file-name)
                                         (equal comint-input-ring-file-name ""))
                                     nil)
                                    ((not (file-readable-p comint-input-ring-file-name))
                                     (or silent
                                         (message "Cannot read history file %s"
                                                  comint-input-ring-file-name)))
                                    (t
                                     (let* ((file comint-input-ring-file-name)
                                            (count 0)
                                            ;; Some users set HISTSIZE or `comint-input-ring-size'
                                            ;; to huge numbers.  Don't allocate a huge ring right
                                            ;; away; there might not be that much history.
                                            (ring-size (min 1500 comint-input-ring-size))
                                            (ring (make-ring ring-size)))
                                       (with-temp-buffer
                                         (insert-file-contents file)
                                         ;; Save restriction in case file is already visited...
                                         ;; Watch for those date stamps in history files!
                                         (goto-char (point-max))
                                         (let (start end history)
                                           (while (and (< count comint-input-ring-size)
                                                       (re-search-backward comint-input-ring-separator
                                                                           nil t)
                                                       (setq end (match-beginning 0)))
                                             (setq start
                                                   (if (re-search-backward comint-input-ring-separator
                                                                           nil t)
                                                       (progn
                                                         (when (looking-at (concat comint-input-ring-separator
                                                                                   comint-input-ring-prefix))
                                                           ;; Skip zsh extended_history stamps
                                                           (re-search-forward comint-input-ring-prefix
                                                                              nil t))
                                                         (match-end 0))
                                                     (progn
                                                       (goto-char (point-min))
                                                       (if (looking-at comint-input-ring-prefix)
                                                           (progn
                                                             (re-search-forward comint-input-ring-prefix
                                                                                nil t)
                                                             (match-end 0))
                                                         (point-min)))))
                                             (setq history (buffer-substring start end))
                                             (goto-char start)
                                             (when (and (not (string-match comint-input-history-ignore
                                                                           history))
                                                        (or (null comint-input-ignoredups)
                                                            (ring-empty-p ring)
                                                            (not (string-equal (ring-ref ring 0)
                                                                               history))))
                                               (when (= count ring-size)
                                                 (ring-extend ring (min (- comint-input-ring-size ring-size)
                                                                        ring-size))
                                                 (setq ring-size (ring-size ring)))
                                               (ring-insert-at-beginning ring history)
                                               (setq count (1+ count))))))
                                       (setq comint-input-ring ring
                                             comint-input-ring-index nil)))))))
  
  (use-package comint-hyperlink
    :ensure nil
    :commands (comint-hyperlink-process-output)
    :init (add-to-list 'comint-output-filter-functions 'comint-hyperlink-process-output))
  

• compile
  

  (use-package compile
    :bind (("C-c C-c" . compile)
           :map compilation-mode-map
           ("o" . compile-goto-error))
    :preface
    (autoload 'ansi-color-process-output "ansi-color")
    (defun show-compilation ()
      (interactive)
      (let ((compile-buf
             (catch 'found
               (dolist (buf (buffer-list))
                 (if (string-match "\\*compilation\\*"
                                   (buffer-name buf))
                     (throw 'found buf))))))
        (if compile-buf
            (switch-to-buffer-other-window compile-buf)
          (call-interactively 'compile))))
  
    (defun compilation-ansi-color-process-output ()
      (ansi-color-process-output nil)
      (set (make-local-variable 'comint-last-output-start)
           (point-marker)))
    :hook (compilation-filter .
           compilation-ansi-color-process-output))
  

• conf-mode
  

  (use-package conf-mode
    :mode (("/\\.merlin\\'" . conf-mode)
           ("_oasis\\'" . conf-mode)
           ("_tags\\'" . conf-mode)
           ("_log\\'" . conf-mode)))
  

• delsel
  

  (use-package delsel
    :demand
    :commands delete-selection-mode
    :config (delete-selection-mode t))
  

• desktop
  

  You may want to enable this to persist info across Emacs sessions.

  (use-package desktop
    :disabled
    :demand
    :commands delete-save-mode
    :config
      (setq desktop-dirname user-emacs-directory)
      (desktop-save-mode t))
  

• dired
  

  (use-package dired
    :ensure nil
    :preface
    (autoload 'dired-get-filename "dired")
    (autoload 'term-set-escape-char "term")
    (defun dired-run-command (&optional filename)
      "Run file at point in a new buffer."
      (interactive)
      (unless filename
        (setq filename (expand-file-name
                        (dired-get-filename t t)
                        default-directory)))
      (let ((buffer (make-term
                      (file-name-nondirectory filename)
                      filename))
            (buffer-read-only nil))
        (with-current-buffer buffer
          ;; (term-mode)
          (term-char-mode)
          (term-set-escape-char ?\C-x))
        (set-process-sentinel
          (get-buffer-process buffer)
          (lambda (proc event)
             (when (not (process-live-p proc))
               (kill-buffer (process-buffer proc)))))
        (switch-to-buffer buffer)))
    :bind (("C-c J" . dired-double-jump)
           :package dired
           :map dired-mode-map
           ("C-c C-c" . compile)
           ("r" . term)
           ("M-@" . shell)
           ("M-*" . eshell)
           ("W" . browse-url-of-dired-file)
           ("@" . dired-run-command)))
  (use-package dired-du
    :commands dired-du-mode)
  

  • dired-column
    

    (use-package dired-column
      :ensure nil
      :bind (:package dired
                      :map dired-mode-map
                      ("o" . dired-column-find-file)))
    

  • dired-subtree
    

    (use-package dired-subtree
      :bind (:package dired
                      :map dired-mode-map
                      ("<tab>" . dired-subtree-toggle)
                      ("TAB" . dired-subtree-toggle)
                      ("<backtab>" . dired-subtree-cycle)))
    

  • dired-x
    

    (use-package dired-x
      :ensure nil
      :hook ((dired-mode . dired-omit-mode))
      :bind (("s-\\" . dired-jump-other-window)
             :package dired
             :map dired-mode-map
             (")" . dired-omit-mode)))
    

• display-line-numbers
  

  (use-package display-line-numbers
    :commands (display-line-numbers-mode)
    :hook ((prog-mode . display-line-numbers-mode)
           (conf-mode . display-line-numbers-mode)))
  

• eldoc
  

  Provides some info for the thing at the point.

  (use-package eldoc
    :hook ((emacs-lisp-mode . eldoc-mode)
           (eval-expression-minibuffer-setup . eldoc-mode)
           (lisp-mode-interactive-mode . eldoc-mode)
           (typescript-mode . eldoc-mode)
           (haskell-mode . eldoc-mode)
           (python-mode . eldoc-mode)
           (eshell-mode . eldoc-mode)
           (org-mode . eldoc-mode)))
  

• electric
  

  Setup these modes:

  • electric-quote
  • electric-indent
  • electric-layout

  (use-package electric
    :if (>= emacs-major-version 25)
    :hook ((prog-mode . electric-quote-local-mode)
           (text-mode . electric-quote-local-mode)
           (org-mode . electric-quote-local-mode)
           (message-mode . electric-quote-local-mode)
           (prog-mode . electric-indent-local-mode)
           (prog-mode . electric-layout-mode)
           (haskell-mode . (lambda () (electric-indent-local-mode -1)))
           (nix-mode . (lambda () (electric-indent-local-mode -1)))))
  

  • elec-pair
    

    Setup electric-pair-mode for prog-modes. Also disable it when smartparens is setup.

    (use-package elec-pair
      :if (>= emacs-major-version 25)
      :hook
       ((prog-mode . electric-pair-local-mode)
        (smartparens-mode . (lambda ()
          (electric-pair-local-mode -1)))))
    

• eww
  

  eww is enabled so we can open files in non-graphical environments.

  (use-package eww
    :if (and (not window-system)
             (not (string-equal
                    (getenv "TERM_PROGRAM")
                    "Apple_Terminal")))
    :commands (eww-browse-url eww-reload)
    :config
    (add-hook 'eww-mode-hook (lambda ()
      (add-hook 'text-scale-mode-hook (lambda (&rest _) (eww-reload t)) nil t)
      (add-hook 'window-size-change-functions (lambda (&rest _) (eww-reload t)) nil t)))
    :init
    (setq browse-url-browser-function 'eww-browse-url))
  

• executable
  

  Make scripts executable automatically.

  (use-package executable
    :hook
    ((after-save .
      executable-make-buffer-file-executable-if-script-p)))
  

• ffap
  

  (use-package ffap
    :bind (("C-x C-f" . find-file-at-point)
           ("C-x 4 C-f" . ffap-other-window)
           ("C-x C-r" . ffap-read-only)
           ("C-x C-v" . ffap-alternate-file)
           ("C-x 4 f" . ffap-other-window)
           ("C-x 5 f" . ffap-other-frame)
           ("C-x 4 r" . ffap-read-only-other-window)
           ("C-x 5 r" . ffap-read-only-other-frame)
           ("C-x d"  . dired-at-point)
           ("C-x 4 d" . ffap-dired-other-window)
           ("C-x 5 d" . ffap-dired-other-frame)
           ("C-x C-d" . ffap-list-directory))
    :hook ((gnus-summary-mode . ffap-gnus-hook)
           (gnus-article-mode . ffap-gnus-hook)
           (vm-mode . ffap-ro-mode-hook)
           (rmail-mode . ffap-ro-mode-hook)))
  

• files
  

  (use-package files
    :ensure nil
    :demand
    :preface
    (defun find-file--line-number (orig-fun filename
                                   &optional wildcards)
      "Turn files like file.js:14:10 into file.js and going to line 14, col 10."
      (save-match-data
        (let* ((matched (string-match
                          "^\\(.*?\\):\\([0-9]+\\):?\\([0-9]*\\)$"
                          filename))
               (line-number (and matched
                              (match-string 2 filename)
                              (string-to-number
                                (match-string 2 filename))))
               (col-number (and matched
                              (match-string 3 filename)
                              (string-to-number (match-string 3 filename))))
               (filename (if matched
                             (match-string 1 filename)
                             filename)))
          (apply orig-fun (list filename wildcards))
          (when line-number
            ;; goto-line is for interactive use
            (goto-char (point-min))
            (forward-line (1- line-number))
            (when (> col-number 0)
              (forward-char (1- col-number)))))))
    :config
    (advice-add 'find-file
                :around #'find-file--line-number))
  

• flyspell
  

  (use-package flyspell
    :if (locate-file
         (if (boundp 'ispell-program-name)
             ispell-program-name "aspell")
         exec-path)
    :hook ((text-mode . flyspell-mode)
           (prog-mode . flyspell-prog-mode))
    :bind (:map flyspell-mode-map
                ("C-M-i" . nil)))
  

• goto-addr
  

  (use-package goto-addr
    :hook (((prog-mode conf-mode) . goto-address-prog-mode)
           ((help-mode org-mode text-mode) . goto-address-mode)
           (git-commit-mode . goto-address-mode)
           (shell-mode . goto-address-mode)))
  

• hl-line
  

  (use-package hl-line
    :hook ((prog-mode . hl-line-mode)
           (org-mode . hl-line-mode)
           (dired-mode . hl-line-mode)))
  

• make-mode
  

  (use-package make-mode
    :ensure nil
    :mode (("\\(/\\|\\`\\)[Mm]akefile" . makefile-mode)))
  

• paren
  

  (use-package paren
    :hook ((prog-mode . show-paren-mode)
           (smartparens-mode . (lambda () (show-paren-mode -1)))))
  

• pp
  

  (use-package pp
    :commands pp-eval-last-sexp
    :bind (([remap eval-expression] . pp-eval-expression))
    ;; :init
    ;;(global-unset-key (kbd "C-x C-e"))
    :hook ((lisp-mode emacs-lisp-mode) . always-eval-sexp)
    :preface
    (defun always-eval-sexp ()
      (define-key (current-local-map)
                  (kbd "C-x C-e")
                  'pp-eval-last-sexp)))
  

• prog-mode
  

  (use-package prog-mode
    :ensure nil
    :hook (;; (prog-mode . prettify-symbols-mode)
           ;; (lisp-mode . prettify-symbols-lisp)
           ;; (c-mode . prettify-symbols-c)
           ;; (c++-mode . prettify-symbols-c++)
           ;; ((js-mode js2-mode) . prettify-symbols-js)
           (prog-mode . (lambda ()
             (setq-local scroll-margin 3))))
    :preface
    (defun prettify-symbols-prog ()
      (push '("<=" . ?≤) prettify-symbols-alist)
      (push '(">=" . ?≥) prettify-symbols-alist))
    (defun prettify-symbols-lisp ()
      (push '("/=" . ?≠) prettify-symbols-alist)
      (push '("sqrt" . ?√) prettify-symbols-alist)
      (push '("not" . ?¬) prettify-symbols-alist)
      (push '("and" . ?∧) prettify-symbols-alist)
      (push '("or" . ?∨) prettify-symbols-alist))
    (defun prettify-symbols-c ()
      (push '("<=" . ?≤) prettify-symbols-alist)
      (push '(">=" . ?≥) prettify-symbols-alist)
      (push '("!=" . ?≠) prettify-symbols-alist)
      (push '("&&" . ?∧) prettify-symbols-alist)
      (push '("||" . ?∨) prettify-symbols-alist)
      (push '(">>" . ?») prettify-symbols-alist)
      (push '("<<" . ?«) prettify-symbols-alist))
    (defun prettify-symbols-c++ ()
      (push '("<=" . ?≤) prettify-symbols-alist)
      (push '(">=" . ?≥) prettify-symbols-alist)
      (push '("!=" . ?≠) prettify-symbols-alist)
      (push '("&&" . ?∧) prettify-symbols-alist)
      (push '("||" . ?∨) prettify-symbols-alist)
      (push '(">>" . ?») prettify-symbols-alist)
      (push '("<<" . ?«) prettify-symbols-alist)
      (push '("->" . ?→) prettify-symbols-alist))
    (defun prettify-symbols-js ()
      (push '("function" . ?λ) prettify-symbols-alist)
      (push '("=>" . ?⇒) prettify-symbols-alist)))
  

• savehist-mode
  

  (use-package savehist
    :hook (after-init . savehist-mode))
  

• saveplace-mode
  

  (use-package saveplace
    :if (>= emacs-major-version 25)
    :hook (after-init . save-place-mode))
  

• Shell
  

  (use-package shell
    :bind (("C-c C-s" . shell)
           ("H-s" . shell)
           ("M-@" . shell))
    :hook ((shell-mode . ansi-color-for-comint-mode-on)
           (shell-mode . dirtrack-mode)
           ;; (shell-mode . (lambda ()
           ;;            (turn-on-comint-history (expand-file-name "sh-history"
           ;;            user-emacs-directory))))
           ))
  

• simple
  

  (use-package simple
    :ensure nil
    :demand
    :commands (column-number-mode auto-fill-mode)
    :bind
    (("C-`" . list-processes)
     :map minibuffer-local-map
     ("<escape>"         . abort-recursive-edit)
     ("M-TAB"    . previous-complete-history-element)
     ("<M-S-tab>" . next-complete-history-element))
    :hook ((text-mode . visual-line-mode)
           (text-mode . auto-fill-mode))
    :config (column-number-mode))
  

• subword
  

  (use-package subword
    :hook ((java-mode . subword-mode)))
  

• term
  

  (use-package term
    :commands (term-mode term-char-mode)
    :hook ((term-mode .
             (lambda ()
               (setq term-prompt-regexp
                     "^[^#$%>\n]*[#$%>] *")
               (setq-local transient-mark-mode nil)
               (auto-fill-mode -1))))
    :preface
    (autoload 'tramp-tramp-file-p "tramp")
    (autoload 'tramp-dissect-file-name "tramp"))
  
  (use-package tramp-term
    :commands tramp-term
    :functions term-send-raw-string
    :hook (tramp-term-after-initialized . (lambda (host)
      (term-send-raw-string (concat "cd " default-directory (kbd "RET"))))))
  

• text-mode
  

  (use-package text-mode
    :no-require
    :ensure nil
    :hook ((text-mode . turn-on-auto-fill)))
  

• time
  

  (use-package time
    :demand
    :config (display-time-mode))
  

• url-handlers
  

  (use-package url-handlers
    :ensure nil
    :demand
    :commands url-handler-mode
    :config (url-handler-mode))
  

• which-func
  

  (use-package which-func
    :commands which-function-mode
    :demand
    :config (which-function-mode))
  

• whitespace
  

  (use-package whitespace
    :hook (prog-mode . whitespace-mode))
  

Programming languages

• C/C++
  

  (use-package cc-mode
    :mode (("\\.h\\(h?\\|xx\\|pp\\)\\'" . c++-mode)
           ("\\.m\\'" . c-mode)
           ("\\.c\\'" . c-mode)
           ("\\.cpp\\'" . c++-mode)
           ("\\.c++\\'" . c++-mode)
           ("\\.mm\\'" . c++-mode)))
  

  • Irony
    

    (use-package irony
      :preface
      (autoload 'file-remote-p "files")
      (defun irony-mode-disable-remote ()
        "Disabled irony in remote buffers."
        (when (and buffer-file-name
                   (file-remote-p buffer-file-name))
          (irony-mode -1)))
      :hook (((c++-mode c-mode objc-mode) .
              irony-mode-disable-remote)
             ((c++-mode c-mode objc-mode) . irony-mode)))
    

    (use-package irony-cdb
        :ensure nil
        :hook (irony-mode . irony-cdb-autosetup-compile-options))
    

    • flycheck-irony
      

      (use-package flycheck-irony
        :hook (flycheck-mode . flycheck-irony-setup))
      

    • irony-eldoc
      

      (use-package irony-eldoc
        :hook (irony-mode . irony-eldoc))
      

• CMake
  

  (use-package cmake-mode
    :mode (("\\.cmake\\'" . cmake-mode)
           ("\\CMakeLists.txt$" . cmake-mode)))
  

• CoffeeScript
  

  (use-package coffee-mode
    :mode (("\\.coffee\\'" . coffee-mode)))
  

• CSS
  

  (use-package css-mode
    :mode "\\.css\\'")
  

• CSV
  

  (use-package csv-mode
    :mode "\\.csv\\'"
    :hook ((csv-mode . (lambda () (visual-line-mode -1)))
           (csv-mode . (lambda () (auto-fill-mode -1)))
           (csv-mode . (lambda () (toggle-truncate-lines 1)))))
  

• ELF
  

  (use-package elf-mode
    :magic ("ELF" . elf-mode))
  

• Emacs speaks statistics
  

  Website

  (use-package ess-site
    :ensure ess
    :no-require
    :interpreter (("Rscript" . r-mode)
                  ("r" . r-mode))
    :mode (("\\.sp\\'"          . S-mode)
           ("/R/.*\\.q\\'"      . R-mode)
           ("\\.[qsS]\\'"       . S-mode)
           ("\\.ssc\\'"         . S-mode)
           ("\\.SSC\\'"         . S-mode)
           ("\\.[rR]\\'"        . R-mode)
           ("\\.[rR]nw\\'"      . Rnw-mode)
           ("\\.[sS]nw\\'"      . Snw-mode)
           ("\\.[rR]profile\\'" . R-mode)
           ("NAMESPACE\\'"      . R-mode)
           ("CITATION\\'"       . R-mode)
           ("\\.omg\\'"         . omegahat-mode)
           ("\\.hat\\'"         . omegahat-mode)
           ("\\.lsp\\'"         . XLS-mode)
           ("\\.do\\'"          . STA-mode)
           ("\\.ado\\'"         . STA-mode)
           ("\\.[Ss][Aa][Ss]\\'"        . SAS-mode)
           ("\\.[Ss]t\\'"       . S-transcript-mode)
           ("\\.Sout"           . S-transcript-mode)
           ("\\.[Rr]out"        . R-transcript-mode)
           ("\\.Rd\\'"          . Rd-mode)
           ("\\.[Bb][Uu][Gg]\\'"         . ess-bugs-mode)
           ("\\.[Bb][Oo][Gg]\\'"         . ess-bugs-mode)
           ("\\.[Bb][Mm][Dd]\\'"         . ess-bugs-mode)
           ("\\.[Jj][Aa][Gg]\\'"         . ess-jags-mode)
           ("\\.[Jj][Oo][Gg]\\'"         . ess-jags-mode)
           ("\\.[Jj][Mm][Dd]\\'"         . ess-jags-mode)
           ))
  

• git-modes
  
  • gitattributes
    

    (use-package gitattributes-mode
      :mode (("/\\.gitattributes\\'"  . gitattributes-mode)
             ("/info/attributes\\'"   . gitattributes-mode)
             ("/git/attributes\\'"    . gitattributes-mode)))
    

  • gitconfig
    

    (use-package gitconfig-mode
      :mode (("/\\.gitconfig\\'"      . gitconfig-mode)
             ("/\\.git/config\\'"     . gitconfig-mode)
             ("/modules/.*/config\\'" . gitconfig-mode)
             ("/git/config\\'"        . gitconfig-mode)
             ("/\\.gitmodules\\'"     . gitconfig-mode)
             ("/etc/gitconfig\\'"     . gitconfig-mode)))
    

  • gitignore
    

    (use-package gitignore-mode
      :mode (("/\\.gitignore\\'"      . gitignore-mode)
             ("/info/exclude\\'"      . gitignore-mode)
             ("/git/ignore\\'"        . gitignore-mode)))
    

• Go
  

  (use-package go-mode
    :mode "\\.go\\'")
  

• HAML
  

  (use-package haml-mode
    :mode "\\.haml\\'")
  

• Haskell
  
  • haskell-mode
    

    (use-package haskell
      :preface
      (load "haskell-mode-autoloads" t t)
      :ensure haskell-mode
      :mode (("\\.hs\\(c\\|-boot\\)?\\'" . haskell-mode)
             ("\\.lhs\\'" . literate-haskell-mode)
             ("\\.cabal\\'" . haskell-cabal-mode))
      :hook ((haskell-mode . subword-mode)
             (haskell-mode . flyspell-prog-mode)
             ;; (haskell-mode . haskell-indentation-mode)
             (haskell-mode . haskell-auto-insert-module-template)
             ;; (haskell-mode . haskell-decl-scan-mode)
             (haskell-mode . haskell-indent-mode)
             ;; (haskell-mode . imenu-add-menubar-index)
             ;; (haskell-mode .
             ;;          (lambda ()
             ;;            (autoload 'haskell-doc-current-info
             ;;              "haskell-doc")
             ;;            (setq-local eldoc-documentation-function
             ;;                        'haskell-doc-current-info)))
             )
      :functions xref-push-marker-stack
      :commands (haskell-session-maybe haskell-mode-find-def haskell-ident-at-point
                  haskell-mode-handle-generic-loc)
      :bind (:map haskell-mode-map
             ("C-c h" . haskell-hoogle)
             ("C-c C-." . haskell-navigate-imports)
             ("C-`" . haskell-interactive-bring)
             ("C-c `" . haskell-interactive-bring)
             ("C-c C-t" . haskell-process-do-type)
             ("C-c C-i" . haskell-process-do-info)
             ("C-c C-c" . haskell-process-cabal-build)
             ("C-c C-k" . haskell-interactive-mode-clear)
             ("C-c c" . haskell-process-cabal)
             ;; ("M-." . haskell-mode-jump-to-def)
             :map haskell-cabal-mode-map
             ("C-`" . haskell-interactive-bring)
             ("C-c C-k" . haskell-interactive-mode-clear)
             ("C-c C-c" . haskell-process-cabal-build)
             ("C-c c" . haskell-process-cabal)
             :map interactive-haskell-mode-map
             ("M-." . (lambda (&optional _next-p)
                        (interactive "P")
                        (if (haskell-session-maybe)
                            (let ((initial-loc (point-marker))
                                  (loc (haskell-mode-find-def (haskell-ident-at-point))))
                              (if loc
                                  (progn
                                    (haskell-mode-handle-generic-loc loc)
                                    (unless (equal initial-loc (point-marker))
                                      (xref-push-marker-stack initial-loc)))
                                (call-interactively 'haskell-mode-tag-find)))
                          (call-interactively 'haskell-mode-tag-find))))
             ("C-c C-t" . haskell-mode-show-type-at))
      :init
      (add-to-list 'completion-ignored-extensions ".hi"))
    

  • haskell-interactive-mode
    

    (use-package haskell-interactive-mode
      :ensure nil
      :commands interactive-haskell-mode
      ;; :hook (haskell-mode . interactive-haskell-mode)
      )
    

  • nix-haskell
    

    (use-package nix-haskell-mode
      :ensure nil
      :disabled
      ;; :hook (haskell-mode . nix-haskell-mode)
      )
    

• Java
  
  • jdee
    

    (use-package jdee
      :disabled
      :mode ("\\.java\\'" . jdee-mode)
      :bind (:package jdee
             :map jdee-mode-map
             ("<s-mouse-1>" . jdee-open-class-at-event)))
    

• JavaScript
  
  • indium
    

    (use-package indium
      :if (>= emacs-major-version 25)
      :mode ("\\.js\\'" . indium-mode))
    

  • js2-mode
    

    (use-package js2-mode
      :mode (("\\.js\\'" . js2-mode)
             ("\\.es6\\'" . js2-mode)
             ("\\.ejs\\'" . js2-mode))
      :interpreter "node")
    

    • js2-imenu-extras
      

      (use-package js2-imenu-extras
        :ensure nil
        :hook (js2-mode . js2-imenu-extras-mode))
      

  • tern
    

    (use-package tern
      :if (locate-file "tern" exec-path)
      :hook (js2-mode . tern-mode))
    

• JSON
  

  (use-package json-mode
    :mode (("\\.bowerrc$"     . json-mode)
           ("\\.jshintrc$"    . json-mode)
           ("\\.json_schema$" . json-mode)
           ("\\.json\\'" . json-mode))
    :bind (:package json-mode-map
           :map json-mode-map
           ("C-c <tab>" . json-mode-beautify))
    :config
    (make-local-variable 'js-indent-level))
  

• LaTeX
  
  • auctex
    

    Auctex provides some helpful tools for working with LaTeX.

    • tex-site
      

      (use-package tex-site
        :ensure auctex
        :no-require
        :mode ("\\.tex\\'" . TeX-latex-mode))
      

    • tex-mode
      

      (use-package tex-mode
        :hook (TeX-mode . latex-electric-env-pair-mode))
      

• Lisp
  

  (use-package elisp-mode
    :ensure nil
    :interpreter (("emacs" . emacs-lisp-mode)))
  

  • ielm
    

    (use-package ielm
      :bind ("C-c :" . ielm))
    

• Mach-O
  

  View macho binaries read-only. To view in Hexl-mode raw binaries, run M-x macho-mode to toggle then M-x hexl-mode.

  (use-package macho-mode
    :ensure nil
    :magic (("\xFE\xED\xFA\xCE" . macho-mode)
            ("\xFE\xED\xFA\xCF" . macho-mode)
            ("\xCE\xFA\xED\xFE" . macho-mode)
            ("\xCF\xFA\xED\xFE" . macho-mode)))
  

• Markdown
  
  • markdown-mode
    

    (use-package markdown-mode
      :mode (("README\\.md\\'" . gfm-mode)
             ("\\.md\\'"       . markdown-mode)
             ("\\.markdown\\'" . gfm-mode)))
    

• Nix
  
  • nix-mode
    

    (use-package nix-mode
      :mode "\\.nix\\'")
    

  • nix-shell
    

    (use-package nix-shell
      :ensure nil
      :commands (nix-shell nix-unpack))
    

  • nix-drv-mode
    

    (use-package nix-drv-mode
      :ensure nil
      :mode "\\.drv\\'")
    

  • nix-buffer
    

    (use-package nix-buffer
      :commands nix-buffer
      ;; :preface
      ;; (defun turn-on-nix-buffer ()
      ;;   (when (and (not noninteractive)
      ;;         (not (eq (aref (buffer-name) 0) ?\s))
      ;;         (not (file-remote-p default-directory)))
      ;;     (nix-buffer)))
      ;; :hook (after-change-major-mode . turn-on-nix-buffer)
      )
    

  • nix-update
    

    (use-package nix-update
      :commands nix-update-fetch
      :bind (("C-. u" . nix-update-fetch)))
    

• OCaml
  

  (use-package tuareg
    :mode (("\\.mli?\\'" . tuareg-mode))
    :config
    ;; Use Merlin if available
    (when (require 'merlin nil t)
      (defvar merlin-command)
      (setq merlin-command 'opam)
  
      (declare-function merlin-mode "merlin.el")
  
      (when (functionp 'merlin-document)
        (define-key tuareg-mode-map (kbd "\C-c\C-h") 'merlin-document))
  
      ;; Run Merlin if a .merlin file in the parent dirs is detected
      (add-hook 'tuareg-mode-hook
                (lambda()
                  (let ((fn (buffer-file-name)))
                    (if (and fn (locate-dominating-file fn ".merlin"))
                        (merlin-mode)))))))
  

• PHP
  

  (use-package php-mode
    :mode "\\.php\\'")
  

• Proof General
  

  Website

  (use-package proof-site
    :ensure proofgeneral
    :demand
    :if (not needs-package-init))
  

• Python
  
  • Anaconda
    

    (use-package anaconda-mode
      :hook ((python-mode . anaconda-mode)
             (python-mode . anaconda-eldoc-mode)))
    

  • python-mode
    

    (use-package python
      :mode ("\\.py\\'" . python-mode)
      :interpreter ("python" . python-mode))
    

• restclient
  

  (use-package restclient
    :mode (("\\.rest\\'" . restclient-mode)
           ("\\.restclient\\'" . restclient-mode)))
  

• Ruby
  

  (use-package ruby-mode
    :mode ("\\.rb\\'" . ruby-mode)
    :interpreter ("ruby" . ruby-mode))
  

• Rust
  

  (use-package rust-mode
    :mode "\\.rs\\'")
  

• SASS
  

  (use-package sass-mode
    :mode "\\.sass\\'")
  

• Scala
  

  (use-package scala-mode
    :mode "\\.scala\\'"
    :interpreter ("scala" . scala-mode))
  

• SCSS
  

  (use-package scss-mode
    :mode "\\.scss\\'")
  

• Shell
  

  (use-package sh-script
    :commands shell-command
    :mode (("\\.*shellrc$" . sh-mode)
           ("\\.*shell_profile" . sh-mode)
           ("\\.zsh\\'" . sh-mode)))
  

• texinfo
  

  (use-package texinfo
    :mode ("\\.texi\\'" . texinfo-mode))
  

• TypeScript
  

  (use-package typescript-mode
    :mode "\\.ts\\'")
  

• Web
  

  (use-package web-mode
    :mode (("\\.erb\\'" . web-mode)
           ("\\.mustache\\'" . web-mode)
           ("\\.html?\\'" . web-mode)
           ("\\.php\\'" . web-mode)
           ("\\.jsp\\'" . web-mode)
           ;; ("\\.jsx?$" . web-mode)
           ("\\.es6\\'" . web-mode)
           ("\\.ejs\\'" . web-mode)
           ("\\.phtml\\'" . web-mode)
           ("\\.tpl\\.php\\'" . web-mode)
           ("\\.[agj]sp\\'" . web-mode)
           ("\\.as[cp]x\\'" . web-mode)
           ("\\.djhtml\\'" . web-mode)))
  

• YAML
  

  (use-package yaml-mode
    :mode "\\.ya?ml\\'")
  

Custom

• dired-column
  
• em-dired
  
• installer
  
• macho-mode
  
• nethack
  

  (use-package nethack
    :commands nethack
    :ensure nil)
  

• nix-fontify
  
• set-defaults
  
• use-package-list
  

Other

• browse-at-remote
  

  (use-package browse-at-remote
    :bind ("C-c g g" . browse-at-remote))
  

• browse-kill-ring
  

  (use-package browse-kill-ring
    :commands browse-kill-ring)
  

• buffer-move
  

  GitHub

  (use-package buffer-move
    :bind
    (("<M-S-up>" . buf-move-up)
     ("<M-S-down>" . buf-move-down)
     ("<M-S-left>" . buf-move-left)
     ("<M-S-right>" . buf-move-right)))
  

• copy-as-format
  

  (use-package copy-as-format
    :bind (("C-c w s" . copy-as-format-slack)
           ("C-c w g" . copy-as-format-github)))
  

• crux
  

  (use-package crux
    :bind (("C-c D" . crux-delete-file-and-buffer)
           ("C-c C-e" . crux-eval-and-replace)
           ("C-c d" . crux-duplicate-current-line-or-region)
           ([shift return] . crux-smart-open-line)))
  

• daemons
  

  https://github.com/cbowdon/daemons.el

  (use-package daemons)
  

• deadgrep
  

  ;; (use-package ripgrep :commands ripgrep-regexp)
  ;; (use-package rg :commands rg-dwim)
  (use-package deadgrep
    :commands deadgrep
    :bind (:map projectile-command-map
           ("s g" . deadgrep)))
  

• delight
  

  (use-package delight)
  

• dired-rsync
  

  (use-package dired-rsync
    :bind (:map dired-mode-map ("C-c C-r" . dired-rsync)))
  

• emacs-gif-screencast
  

  (use-package gif-screencast
    :commands gif-screencast)
  

• fic-mode
  

  (use-package fic-mode
    :hook (prog-mode . fic-mode))
  

• git-attr
  

  (use-package git-attr-linguist
    :ensure git-attr
    :commands git-attr-linguist
    :hook (find-file . git-attr-linguist))
  

• git-timemachine
  

  (use-package git-timemachine
    :commands git-timemachine)
  

• htmlize
  

  (use-package htmlize :no-require)
  

• idle-highlight-mode
  

  (use-package idle-highlight-mode
    :hook (prog-mode . idle-highlight-mode))
  

• iedit
  

  (use-package iedit
    :bind (("C-;" . iedit-mode)))
  

• ledger-mode
  

  (use-package ledger-mode)
  

• mwim
  

  GitHub

  (use-package mwim
    :bind (([remap move-beginning-of-line]
            . mwim-beginning-of-code-or-line)
           ([remap move-end-of-line]
            . mwim-end-of-code-or-line)))
  

• org-static-blog
  

  (use-package org-static-blog :commands org-static-blog-publish)
  

• page-break-lines
  

  (use-package page-break-lines
    :delight
    :hook ((doc-mode
            emacs-lisp-mode
            compilation-mode
            outline-mode
            prog-mode
            haskell-mode
            help-mode
            magit-mode) . page-break-lines-mode))
  

• pandoc-mode
  

  (use-package pandoc-mode
    :hook ((markdown-mode . pandoc-mode)
           (pandoc-mode . pandoc-load-default-settings)))
  

• pcomplette
  

  (use-package pcomplete
    :demand
    :commands pcomplete-here
    :preface
    (autoload 'pcomplete-comint-setup "pcomplete")
    :hook ((shell-mode . (lambda () (pcomplete-comint-setup 'shell-dynamic-complete-functions)))
           ;; (term-mode . (lambda () (pcomplete-comint-setup 'term-dynamic-complete-functions)))
           (comint-mode . (lambda () (pcomplete-comint-setup 'comint-dynamic-complete-functions)))
           ;; (eshell-mode . (lambda () (add-hook 'completion-at-point-functions
           ;;                                'pcomplete-completions-at-point
           ;;                                nil t)))
           ))
  (use-package pcmpl-args
    :init
    (declare-function pcmpl-args-process-file "pcmpl-args.el")
    ;; see https://github.com/JonWaltman/pcmpl-args.el/pull/4
    (setq pcmpl-args-man-function
          (lambda (name)
            (let ((process-environment process-environment))
              ;; Setting MANWIDTH to a high number makes most paragraphs fit on a single
              ;; line, reducing the number of false positives that result from lines
              ;; starting with `-' that aren't really options.
              (push "MANWIDTH=10000" process-environment)
              (pcmpl-args-process-file
               shell-file-name shell-command-switch (format "man %s | col -b" name))))))
  
    ;; (use-package pcmpl-git)
  

• rainbow-delimiters
  

  (use-package rainbow-delimiters
    :hook ((emacs-lisp-mode
            inferior-emacs-lisp-mode
            ielm-mode
            lisp-mode
            inferior-lisp-mode
            lisp-interaction-mode
            slime-repl-mode) . rainbow-delimiters-mode))
  

• rainbow-mode
  

  (use-package rainbow-mode
    :hook ((emacs-lisp-mode
            inferior-emacs-lisp-mode
            ielm-mode
            lisp-mode
            inferior-lisp-mode
            lisp-interaction-mode
            slime-repl-mode
            web-mode
            less-css-mode
            html-mode
            css-mode) . rainbow-mode))
  

• shrink-whitespace
  

  (use-package shrink-whitespace
    :bind ("H-SPC" . shrink-whitespace))
  

• string-inflection
  

  (use-package string-inflection
    :bind (("C-c r r" . string-inflection-all-cycle)
           ("C-c r c" . string-inflection-camelcase)
           ("C-c r l" . string-inflection-lower-camelcase)
           ("C-c r u" . string-inflection-underscore)
           ("C-c r k" . string-inflection-kebab-case)
           ("C-c r J" . string-inflection-java-style-cycle)))
  

• undo-tree
  

  (use-package undo-tree
    :demand
    :commands global-undo-tree-mode
    :config (global-undo-tree-mode 1)
    ;; (global-set-key (kbd "C-z") 'undo)
    ;; (defalias 'redo 'undo-tree-redo)
    ;; (global-set-key (kbd "C-S-z") 'redo)
    )
  

• unfill
  

  (use-package unfill
    :bind ([remap fill-paragraph] . unfill-toggle))
  

• url-util
  

  (use-package url-util
    :ensure nil
    :functions (url-hexify-string url-unhex-string region-active-p)
    :preface
    (defun func-region (start end func)
      "Run a function over the region between START and END in current buffer."
      (unless (region-active-p) (error "No active region."))
      (save-excursion
        (let ((text (delete-and-extract-region start end)))
          (insert (funcall func text)))))
    (defun url-encode (start end)
      "URL encode the region between START and END in current buffer."
      (interactive "r")
      (func-region start end 'url-hexify-string))
    (defalias 'url-escape 'url-encode)
    (defun url-decode (start end)
      "URL decode the region between START and END in current buffer."
      (interactive "r")
      (func-region start end 'url-unhex-string))
    (defalias 'url-unescape 'url-decode))
  

• winner-mode
  

  (use-package winner
    :demand
    :config (winner-mode))
  

• with-editor
  

  (use-package with-editor
    :disabled
    :hook
    ((shell-mode eshell-mode) . with-editor-export-editor))
  

Emacs configuration

  site-paths = runCommand "site-paths.el" (with pkgs; ({
    inherit (customEmacsPackages) emacs;
    bash = bashInteractive;
    inherit ripgrep ag
      coreutils findutils openssh
      zsh diffutils man gawk
      gnugrep gnused cacert git;

    inherit manpages sysheaders sysframeworks
      schemas bins infopages;

    inherit MANPATH PATH XDG_DATA_DIRS INFOPATH TERMINFO_DIRS;
  } // (lib.optionalAttrs big {
    gpg = gnupg1compat;
    inherit ant perl perlcritic
      asciidoc lessc lua gcc
      pandoc clang cmake ghostscript
      sqliteInteractive freetds
      parallel unixODBC ncompress
      texinfoInteractive notmuch gnuplot
      gdb coq rtags gnutls
      ;
    inherit (pythonPackages) flake8;
    inherit (nodePackages) jshint eslint;
    inherit (haskellPackages) hoogle hlint;
    texlive = myTex;
    markdown2 = pythonPackages.markdown2;
    tidy = html-tidy;
    libxml2 = libxml2.bin;
  }))) ''
    substituteAll ${./site-paths.el.in} $out
    substituteInPlace $out \
      --subst-var-by PATH ${PATH} \
      --subst-var-by INFOPATH ${INFOPATH} \
      --subst-var-by MANPATH ${MANPATH} \
      --subst-var-by XDG_DATA_DIRS ${XDG_DATA_DIRS} \
      --subst-var-by TERMINFO_DIRS ${TERMINFO_DIRS}
'';

• Phase 1: picking up dependencies
  

  myEmacsPackages gets a listing of all of the packages that are needed by the Emacs configuration. use-package-list generates this list automatically.

  package-list =
    runCommand "package-list" {
      buildInputs = [ customEmacsPackages.emacs ];
    } ''
  

  emacs --batch --quick \
        -L ${customEmacsPackages.use-package
      }/share/emacs/site-lisp/elpa/use-package-* \
        -L ${customEmacsPackages.delight
      }/share/emacs/site-lisp/elpa/delight-* \
        -L ${customEmacsPackages.bind-key
      }/share/emacs/site-lisp/elpa/bind-key-* \
        -l ${ensure ./site-lisp/set-defaults.el
         "site-lisp/set-defaults.el"} \
        -l ${ensure ./site-lisp/bauer.el
         "site-lisp/bauer.el"} \
        -l ${ensure ./site-lisp/use-package-list.el
         "site-lisp/use-package-list.el"} \
        --eval "(use-package-list \"${./README.el}\")" \
        > $out 2>/dev/null
  

  '';
  

  myEmacsPackages' = builtins.fromJSON
         (builtins.readFile package-list);
  

• Phase 2: byte compiling
  

  default = runCommand "bauer-emacs" {
    buildInputs = [ pkgs.emacs ];
  } ''
  

  Install our lisp files. Many of these should be released into MELPA but don’t have the time to do it currently.

  install -D ${site-paths} \
    $out/share/emacs/site-lisp/site-paths.el
  install -D ${./README.el} \
    $out/share/emacs/site-lisp/default.el
  install -D ${ensure ./site-lisp/em-dired.el
           "site-lisp/em-dired.el"} \
    $out/share/emacs/site-lisp/em-dired.el
  install -D ${ensure ./site-lisp/dired-column.el
           "site-lisp/dired-column.el"} \
    $out/share/emacs/site-lisp/dired-column.el
  install -D ${ensure ./site-lisp/macho-mode.el
           "site-lisp/macho-mode.el"} \
    $out/share/emacs/site-lisp/macho-mode.el
  install -D ${ensure ./site-lisp/nethack.el
           "site-lisp/nethack.el"} \
    $out/share/emacs/site-lisp/nethack.el
  install -D ${ensure ./site-lisp/set-defaults.el
           "site-lisp/set-defaults.el"} \
    $out/share/emacs/site-lisp/set-defaults.el
  install -D ${ensure ./site-lisp/installer.el
           "site-lisp/installer.el"} \
    $out/share/emacs/site-lisp/installer.el
  install -D ${ensure ./site-lisp/restart-emacs.el
           "site-lisp/restart-emacs.el"} \
    $out/share/emacs/site-lisp/restart-emacs.el
  install -D ${ensure ./site-lisp/use-package-list.el
           "site-lisp/use-package-list.el"} \
    $out/share/emacs/site-lisp/use-package-list.el
  install -D ${ensure ./site-lisp/bauer.el
          "site-lisp/bauer.el"} \
    $out/share/emacs/site-lisp/bauer.el
  install -D ${ensure ./site-lisp/comint-hyperlink.el
          "site-lisp/comint-hyperlink.el"} \
    $out/share/emacs/site-lisp/comint-hyperlink.el
  

  This is fairly complicated. What happens is we batch compile all of the .el files. The problem is the .el files all are going to depend on dependencies that we have just found in package-list. The solution is that complex eval below where we add all of the paths (plus their requisites) to the load path. This works but is hacky & I am interested in fixing it.

  cd $out/share/emacs/site-lisp
  export HOME=$PWD
  emacs --batch --quick \
        --eval \
  "(let ((default-directory \"${emacsWrapper
    ((requiredPackages customEmacsPackages myEmacsPackages')
     ++ (with customEmacsPackages; [use-package delight]))
  }/share/emacs/site-lisp\"))
    (normal-top-level-add-subdirs-to-load-path))" \
        -L . -f batch-byte-compile *.el
  

  '';
  

• Phase 3: wrapping into Emacs
  

  This phase wraps the byte compiled lisp into an Emacs binary. Each package listed in use-package above is pulled into the closure.

  emacsWrapper = explicitRequires:
   runCommand "emacs-packages-deps"
   { nativeBuildInputs = [ pkgs.xorg.lndir pkgs.emacs ];
     inherit explicitRequires; } ''
  findInputsOld() {
      local pkg="$1"; shift
      local var="$1"; shift
      local propagatedBuildInputsFiles=("$@")
      local varSlice="$var[*]"
      case "''${!varSlice-}" in
    *" $pkg "*) return 0 ;;
      esac
      unset -v varSlice
      eval "$var"'+=("$pkg")'
      if ! [ -e "$pkg" ]; then
    echo "build input $pkg does not exist" >&2
    exit 1
      fi
      local file
      for file in "''${propagatedBuildInputsFiles[@]}"; do
    file="$pkg/nix-support/$file"
    [[ -f "$file" ]] || continue
    local pkgNext
    for pkgNext in $(< "$file"); do
        findInputsOld "$pkgNext" "$var" \
          "''${propagatedBuildInputsFiles[@]}"
    done
      done
  }
  mkdir -p $out/bin
  mkdir -p $out/share/emacs/site-lisp
  local requires
  for pkg in $explicitRequires; do
    findInputsOld $pkg requires propagated-user-env-packages
  done
  linkPath() {
    local pkg=$1
    local origin_path=$2
    local dest_path=$3
    if [ -d "$pkg/$origin_path" ]; then
      lndir -silent "$pkg/$origin_path" \
             "$out/$dest_path"
    fi
  }
  linkEmacsPackage() {
    linkPath "$1" "bin" "bin"
    linkPath "$1" "share/emacs/site-lisp" \
      "share/emacs/site-lisp"
  }
  for pkg in "''${requires[@]}"; do
    linkEmacsPackage $pkg
  done
  emacs --batch -f batch-byte-compile \
          "$siteStart"
  '';
  

  requiredPackages is a function that takes two arguments.

  requiredPackages = epkgs: map (x:
    if builtins.hasAttr x epkgs
      then builtins.getAttr x epkgs
    else if builtins.hasAttr x pkgs.emacsPackages
      then builtins.getAttr x pkgs.emacsPackages
    else abort "no attribute found for use-package ${x}");
  

  Now we build our Emacs distribution.

  TODO: use dump-emacs here to speed up config.

  myEmacsPackages = buildEnv {
    name = "emacs-packages-env";
    paths = (requiredPackages customEmacsPackages myEmacsPackages')
    ++ [ customEmacsPackages.use-package customEmacsPackages.delight ];
  };
  
  myEmacs = customEmacsPackages.emacsWithPackages (epkgs:
    (requiredPackages epkgs myEmacsPackages')
    ++ [default epkgs.use-package epkgs.delight]
  );
  

The environment

infopages = buildEnv {
  name = "info-pages";
  buildInputs = [ pkgs.texinfoInteractive ];
  paths = userPackages ++ [customEmacsPackages.emacs]
    ++ lib.optional hostPlatform.isLinux pkgs.glibcInfo;
  extraOutputsToInstall = [ "info" "doc" "devdoc" ];
  pathsToLink = [ "/share/info" ];
  postBuild = ''
    shopt -s nullglob
    find -L ${myEmacsPackages}/share/emacs/ -name '*.info*' -exec ln -s {} $out/share/info \;
    for i in $out/share/info/*.info*; do
      install-info $i $out/share/info/dir
    done
  '';
};

manpages = buildEnv {
  name = "man-pages";
  ignoreCollisions = (!(config.bauer.small or false));
  paths = userPackages ++ [pkgs.posix_man_pages
         pkgs.stdman
         # pkgs.llvmPackages.clang-manpages
         # pkgs.llvmPackages.llvm-manpages
         ]
    ++ lib.optional (hostPlatform.isDarwin && big && allowUnfree)
         "${apple_sdk}/usr"
    ++ lib.optional hostPlatform.isLinux pkgs.man-pages;
  extraOutputsToInstall = [ "man" "doc" "devdoc" "devman" ];
  pathsToLink = [ "/share/man" ];
};

xdg-data = buildEnv {
  name = "xdg-data-dirs";
  buildInputs = [ pkgs.desktop-file-utils pkgs.shared-mime-info ];
  paths = userPackages ++ [ customEmacsPackages.emacs pkgs.zsh ];
  pathsToLink = [
    "/share/applications"
    "/share/mime"
    "/share/menus"
    "/share/icons"
  ];
  postBuild = ''
    export XDG_DATA_DIRS=$out/share

    if [ -w $out/share/applications ]; then
      update-desktop-database $out/share/applications
    fi

    if [ -w $out/share/mime ] \
       && [ -w $out/share/mime/packages ]; then
      update-mime-database -V $out/share/mime
    fi
  '';
};

zsh-completions = buildEnv {
  name = "zsh-completions";
  paths = [ pkgs.zsh-completions pkgs.nix-zsh-completions ] ++ userPackages;
  pathsToLink = [ "/share/zsh" ];
};

bins = buildEnv {
  name = "bins";
  paths = userPackages;
  extraOutputsToInstall = [ "bin" ];
  pathsToLink = [ "/bin" ];
  postBuild = ''
    find $out/bin -maxdepth 1 -name ".*" -type l -delete
  '';
};

sysheaders = buildEnv {
  name = "headers";
  pathsToLink = [ "/include" ];
  extraOutputsToInstall = [ "dev" ];
  paths = [ stdenv.cc.libc ]
    ++ lib.optional hostPlatform.isDarwin pkgs.libcxx
    ++ lib.optional (hostPlatform.isDarwin && big && allowUnfree)
        "${apple_sdk}/usr";
};

apple_sdk = "${pkgs.darwin.xcode}/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk";
sysframeworks = buildEnv {
  name = "frameworks";
  paths = lib.optionals (hostPlatform.isDarwin && big && allowUnfree)
    [ "${apple_sdk}/System/Library/Frameworks"
      "${apple_sdk}/System/Library/PrivateFrameworks" ];
};

schemas = writeText "schemas.xml" ''
<locatingRules
    xmlns="http://thaiopensource.com/ns/locating-rules/1.0"
>
  <documentElement localName="section" typeId="DocBook"/>
  <documentElement localName="chapter" typeId="DocBook"/>
  <documentElement localName="article" typeId="DocBook"/>
  <documentElement localName="book" typeId="DocBook"/>
  <typeId id="DocBook"
    uri="${pkgs.docbook5}/xml/rng/docbook/docbookxi.rnc"
  />
</locatingRules>
'';

userPackages = (with pkgs; [
  # From common-path.nix
  coreutils findutils diffutils gnused gnugrep gawk gnutar
  gzip bzip2 gnumake bashInteractive patch xz

  # Helpful core tools
  curl zsh cacert file lsof pstree which rsync
  unzip man openssh less calc ag ripgrep
  tree gnutls
] ++ lib.optionals big ([
  # Useful tools
  isync notmuch graphviz indent
  graphviz imagemagick

  bazaar mercurial

  # Programming interpreters/compilers
  myTex rEnv perl python lua coq ocaml
  openjdk nodejs gcc gdb

  travis v8
] ++ (with netbsd; [ getent getconf ])
  ++ (with nodePackages; [ tern heroku node2nix ])
  ++ (with gitAndTools; [ hub ])
  ++ (with haskellPackages; [ ghc jq nix-diff cabal2nix cabal-install ])
  ++ (with unixtools; [ utillinux nettools procps ])
));

global-dirs = [ "/nix/var/nix/profiles/default"
    "/run/wrappers"
    "/run/current-system/sw"
    "/usr/local"
    "/usr"
    "" ];

PATH = lib.concatStringsSep ":" [
   (lib.makeBinPath ([ bins customEmacsPackages.emacs pkgs.zsh ]
         ++ global-dirs))
   (lib.makeSearchPath "sbin" [ "/usr" "" ])
       ];
MANPATH = ":" + lib.makeSearchPathOutput "man" "share/man"
  ([ manpages customEmacsPackages.emacs pkgs.zsh ] ++ global-dirs);
INFOPATH = "${infopages}/share/info";
XDG_DATA_DIRS = lib.makeSearchPathOutput "xdg" "share"
  ([ xdg-data ] ++ global-dirs);
TERMINFO_DIRS = lib.makeSearchPathOutput "terminfo" "share/terminfo"
  ([ pkgs.ncurses ]);

INPUTRC = builtins.toFile "inputrc" ''
  $include /etc/inputrc

  "\C-p":history-search-backward
  "\C-n":history-search-forward

  set colored-stats on
  set completion-ignore-case on
  set completion-prefix-display-length 3
  set mark-symlinked-directories on
  set show-all-if-ambiguous on
  set show-all-if-unmodified on
  set visible-stats on
  set editing-mode emacs

  Space:magic-space
'';

in buildEnv {
  name = "bauer-1.5.1";
  buildInputs = [ pkgs.makeWrapper pkgs.bash ];
  postBuild = ''
    mkdir -p $out/etc
    substituteAll ${./zshrc.sh} $out/etc/.zshrc
    substituteInPlace $out/etc/.zshrc \
      --subst-var-by completions ${zsh-completions} \
      --subst-var-by coreutils ${pkgs.coreutils}
    ln -s $out/etc/.zshrc $out/etc/zshrc
    makeWrapper ${pkgs.zsh}/bin/zsh $out/bin/zsh --set ZDOTDIR $out/etc
    substituteAll ${./etc-profile.sh} $out/etc/profile
    substituteInPlace $out/etc/profile \
      --subst-var-by coreutils ${pkgs.coreutils}
    substitute ${./runemacs.sh} $out/bin/run \
      --subst-var-by emacs ${myEmacs}
    chmod +x $out/bin/run
    patchShebangs $out/bin/run
    ln -s $out/bin/run $out/bin/bauer
  '';
  pathsToLink = [
    "/bin"
    "/etc/profile.d"
    "/share/applications"
  ] ++ lib.optional hostPlatform.isDarwin "/Applications";
  meta = with lib; {
    description = "Bauer's automated unified Emacs realm";
    maintainers = with maintainers; [ matthewbauer ];
    platforms = platforms.all;
    priority = 4;
  };
  passthru = with lib; {
    shellPath = "/bin/zsh";
    run = "/bin/run";
    sourceFile = "/etc/profile.d/profile";
    PATH = makeSearchPath "bin" [bins];
    MANPATH = makeSearchPath "share/man" [manpages];
    INFOPATH = makeSearchPath "share/info" [infopages];
    XDG_DATA_DIRS = makeSearchPath "share" [xdg-data];
    TERMINFO_DIRS = makeSearchPath "share/terminfo" [terminfo];
  };
  paths = [
    myEmacs
    (runCommand "my-profile" {
      emacs = myEmacs;
      inherit (pkgs) cacert;
      inherit PATH MANPATH XDG_DATA_DIRS INFOPATH TERMINFO_DIRS;
    } ''
      mkdir -p $out/etc/profile.d
      substituteAll ${./profile.sh} $out/etc/profile.d/my-profile.sh
      substituteInPlace $out/etc/profile.d/my-profile.sh \
  --subst-var-by PATH ${PATH} \
  --subst-var-by INFOPATH ${INFOPATH} \
  --subst-var-by MANPATH ${MANPATH} \
  --subst-var-by XDG_DATA_DIRS ${XDG_DATA_DIRS} \
  --subst-var-by TERMINFO_DIRS ${TERMINFO_DIRS} \
  --subst-var-by INPUTRC ${INPUTRC}
    '')
    pkgs.git
  ];
}