emacs: let Gnus use full window

[~bandali/configs] / .emacs.d / init.el

;;; init.el --- Amin Bandali's Emacs config -*- lexical-binding: t -*-

;; Copyright (C) 2018-2019  Amin Bandali <bandali@gnu.org>

;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <https://www.gnu.org/licenses/>.

;;; Commentary:

;; Emacs configuration of Amin Bandali, computer scientist, functional
;; programmer, and free software advocate.  Uses straight.el for
;; purely functional and fully reproducible package management.

;; Over the years, I've taken inspiration from configurations of many
;; great people.  Some that I can remember off the top of my head are:
;;
;; - https://github.com/dieggsy/dotfiles
;; - https://github.com/dakra/dmacs
;; - http://pages.sachachua.com/.emacs.d/Sacha.html
;; - https://github.com/dakrone/eos
;; - http://doc.rix.si/cce/cce.html
;; - https://github.com/jwiegley/dot-emacs
;; - https://github.com/wasamasa/dotemacs
;; - https://github.com/hlissner/doom-emacs

;;; Code:

;;; Emacs initialization

(defvar a/before-user-init-time (current-time)
  "Value of `current-time' when Emacs begins loading `user-init-file'.")
(message "Loading Emacs...done (%.3fs)"
         (float-time (time-subtract a/before-user-init-time
                                    before-init-time)))

;; temporarily increase `gc-cons-threshhold' and `gc-cons-percentage'
;; during startup to reduce garbage collection frequency.  clearing
;; `file-name-handler-alist' seems to help reduce startup time too.
(defvar a/gc-cons-threshold gc-cons-threshold)
(defvar a/gc-cons-percentage gc-cons-percentage)
(defvar a/file-name-handler-alist file-name-handler-alist)
(setq gc-cons-threshold (* 400 1024 1024)  ; 400 MiB
      gc-cons-percentage 0.6
      file-name-handler-alist nil
      ;; sidesteps a bug when profiling with esup
      esup-child-profile-require-level 0)

;; set them back to their defaults once we're done initializing
(add-hook
 'after-init-hook
 (lambda ()
   (setq gc-cons-threshold a/gc-cons-threshold
         gc-cons-percentage a/gc-cons-percentage
         file-name-handler-alist a/file-name-handler-alist)))

;; increase number of lines kept in *Messages* log
(setq message-log-max 20000)

;; optionally, uncomment to supress some byte-compiler warnings
;;   (see C-h v byte-compile-warnings RET for more info)
;; (setq byte-compile-warnings
;;       '(not free-vars unresolved noruntime lexical make-local))

\f
;;; whoami

(setq user-full-name "Amin Bandali"
      user-mail-address "amin@bndl.org")

\f
;;; comment macro

;; useful for commenting out multiple sexps at a time
(defmacro comment (&rest _)
  "Comment out one or more s-expressions."
  (declare (indent defun))
  nil)

\f
;;; Package management

;; No package.el  (for emacs 26 and before, uncomment the following)
;; Not necessary when using straight.el
;;   (C-h v straight-package-neutering-mode RET)

(when (and
       (not (featurep 'straight))
       (version< emacs-version "27"))
  (setq package-enable-at-startup nil)
  ;; (package-initialize)
  )

;; for emacs 27 and later, we use early-init.el.  see
;; https://git.savannah.gnu.org/cgit/emacs.git/commit/?id=24acb31c04b4048b85311d794e600ecd7ce60d3b

;; straight.el

;; Main engine start...

(setq straight-repository-branch "develop"
      straight-check-for-modifications '(check-on-save find-when-checking))

(defun a/bootstrap-straight ()
  (defvar bootstrap-version)
  (let ((bootstrap-file
         (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
        (bootstrap-version 5))
    (unless (file-exists-p bootstrap-file)
      (with-current-buffer
          (url-retrieve-synchronously
           "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
           'silent 'inhibit-cookies)
        (goto-char (point-max))
        (eval-print-last-sexp)))
    (load bootstrap-file nil 'nomessage)))

;; Solid rocket booster ignition...

(a/bootstrap-straight)

;; We have lift off!

(setq straight-use-package-by-default t)

(defmacro use-feature (name &rest args)
  "Like `use-package', but with `straight-use-package-by-default' disabled."
  (declare (indent defun))
  `(use-package ,name
     :straight nil
     ,@args))

(with-eval-after-load 'recentf
  (add-to-list 'recentf-exclude
               (expand-file-name "~/.emacs.d/straight/build/")))

(defun a/reload-init ()
  "Reload init.el."
  (interactive)
  (straight-transaction
    (straight-mark-transaction-as-init)
    (load user-init-file)))

;; use-package
(straight-use-package 'use-package)
(if nil                             ; set to t when need to debug init
    (progn
      (setq use-package-verbose t
            use-package-expand-minimally nil
            use-package-compute-statistics t
            debug-on-error t)
      (require 'use-package))
  (setq use-package-verbose nil
        use-package-expand-minimally t))

(setq use-package-always-defer t)
(require 'bind-key)

;; for browsing the Emacsmirror package database
(comment
  (use-package epkg
    :commands (epkg-list-packages epkg-describe-package)
    :bind
    (("C-c p e d" . epkg-describe-package)
     ("C-c p e p" . epkg-list-packages))
    :config
    (setq epkg-repository "~/.emacs.d/straight/repos/epkgs/")
    (eval-when-compile (defvar ivy-initial-inputs-alist))
    (with-eval-after-load 'ivy
      (add-to-list
       'ivy-initial-inputs-alist '(epkg-describe-package . "^") t))))

\f
;;; Initial setup

;; keep ~/.emacs.d clean
(use-package no-littering
  :demand t
  :config
  (savehist-mode 1)
  (add-to-list 'savehist-additional-variables 'kill-ring)
  (save-place-mode 1)
  (setq auto-save-file-name-transforms
        `((".*" ,(no-littering-expand-var-file-name "auto-save/") t))))

;; separate custom file (don't want it mixing with init.el)
(use-feature custom
  :no-require t
  :config
  (setq custom-file (no-littering-expand-etc-file-name "custom.el"))
  (when (file-exists-p custom-file)
    (load custom-file))
  ;; while at it, treat themes as safe
  (setf custom-safe-themes t))

;; load the secrets file if it exists, otherwise show a warning
(with-demoted-errors
    (load (no-littering-expand-etc-file-name "secrets")))

;; better $PATH (and other environment variable) handling
(use-package exec-path-from-shell
  :defer 0.4
  :init
  (setq exec-path-from-shell-arguments           nil
        exec-path-from-shell-check-startup-files nil)
  :config
  (exec-path-from-shell-initialize)
  ;; while we're at it, let's fix access to our running ssh-agent
  (exec-path-from-shell-copy-env "SSH_AGENT_PID")
  (exec-path-from-shell-copy-env "SSH_AUTH_SOCK"))

;; only one custom theme at a time
(comment
  (defadvice load-theme (before clear-previous-themes activate)
    "Clear existing theme settings instead of layering them"
    (mapc #'disable-theme custom-enabled-themes)))

;; start up emacs server.  see
;; https://www.gnu.org/software/emacs/manual/html_node/emacs/Emacs-Server.html#Emacs-Server
(use-feature server
  :defer 0.4
  :config (or (server-running-p) (server-mode)))

;; unicode support
(comment
  (dolist (ft (fontset-list))
    (set-fontset-font
     ft
     'unicode
     (font-spec :name "Source Code Pro" :size 14))
    (set-fontset-font
     ft
     'unicode
     (font-spec :name "DejaVu Sans Mono")
     nil
     'append)
    ;; (set-fontset-font
    ;;  ft
    ;;  'unicode
    ;;  (font-spec
    ;;   :name "Symbola monospacified for DejaVu Sans Mono")
    ;;  nil
    ;;  'append)
    ;; (set-fontset-font
    ;;  ft
    ;;  #x2115  ; ℕ
    ;;  (font-spec :name "DejaVu Sans Mono")
    ;;  nil
    ;;  'append)
    (set-fontset-font
     ft
     (cons ?Α ?ω)
     (font-spec :name "DejaVu Sans Mono" :size 14)
     nil
     'prepend)))

;; gentler font resizing
(setq text-scale-mode-step 1.05)

;; focus follows mouse
(setq mouse-autoselect-window t)

(defun a/no-mouse-autoselect-window ()
  "Conveniently disable `focus-follows-mouse'.
For disabling the behaviour for certain buffers and/or modes."
  (make-local-variable 'mouse-autoselect-window)
  (setq mouse-autoselect-window nil))

;; better scrolling
(setq ;; scroll-margin 1
      ;; scroll-conservatively 10000
      scroll-step 1
      scroll-conservatively 10
      scroll-preserve-screen-position 1)

(use-feature mwheel
  :defer 0.4
  :config
  (setq mouse-wheel-scroll-amount '(1 ((shift) . 1)) ; one line at a time
        mouse-wheel-progressive-speed nil            ; don't accelerate scrolling
        mouse-wheel-follow-mouse t))                 ; scroll window under mouse

(use-feature pixel-scroll
  :defer 0.4
  :config (pixel-scroll-mode 1))

;; ask for GPG passphrase in minibuffer
(setq epg-pinentry-mode 'loopback)

;; useful libraries
(require 'cl-lib)
(require 'subr-x)

\f
;;; Useful utilities

(defmacro a/setq-every (value &rest vars)
  "Set all the variables from VARS to value VALUE."
  (declare (indent defun) (debug t))
  `(progn ,@(mapcar (lambda (x) (list 'setq x value)) vars)))

(defun a/start-process (program &rest args)
  "Same as `start-process', but doesn't bother about name and buffer."
  (let ((process-name (concat program "_process"))
        (buffer-name  (generate-new-buffer-name
                       (concat program "_output"))))
    (apply #'start-process
           process-name buffer-name program args)))

(defun a/dired-start-process (program &optional args)
  "Open current file with a PROGRAM."
  ;; Shell command looks like this: "program [ARGS]... FILE" (ARGS can
  ;; be nil, so remove it).
  (apply #'a/start-process
         program
         (remove nil (list args (dired-get-file-for-visit)))))

(defun a/add-elisp-section ()
  (interactive)
  (insert "\n")
  (previous-line)
  (insert "\n\f\n;;; "))

\f
;;; Defaults

;; time and battery in mode-line
(comment
  (use-package time
    :init
    (setq display-time-default-load-average nil)
    :config
    (display-time-mode))

  (use-package battery
    :config
    (display-battery-mode)))

;; smaller fringe
;; (fringe-mode '(3 . 1))
(fringe-mode nil)

;; disable disabled commands
(setq disabled-command-function nil)

;; Save what I copy into clipboard from other applications into Emacs'
;; kill-ring, which would allow me to still be able to easily access
;; it in case I kill (cut or copy) something else inside Emacs before
;; yanking (pasting) what I'd originally intended to.
(setq save-interprogram-paste-before-kill t)

;; minibuffer
(setq enable-recursive-minibuffers t
      resize-mini-windows t)

;; lazy-person-friendly yes/no prompts
(defalias 'yes-or-no-p #'y-or-n-p)

;; i want *scratch* as my startup buffer
(setq initial-buffer-choice t)

;; i don't need the default hint
(setq initial-scratch-message nil)

;; use customizable text-mode as major mode for *scratch*
(setq initial-major-mode 'text-mode)

;; inhibit buffer list when more than 2 files are loaded
(setq inhibit-startup-buffer-menu t)

;; don't need to see the startup screen or the echo area message
(advice-add #'display-startup-echo-area-message :override #'ignore)
(setq inhibit-startup-screen t
      inhibit-startup-echo-area-message user-login-name)

;; more useful frame titles
(setq frame-title-format
      '("" invocation-name " - "
        (:eval (if (buffer-file-name)
                   (abbreviate-file-name (buffer-file-name))
                 "%b"))))

;; backups (C-h v make-backup-files RET)
(setq backup-by-copying t
      version-control t
      delete-old-versions t)

;; enable automatic reloading of changed buffers and files
(global-auto-revert-mode 1)
(setq auto-revert-verbose nil
      global-auto-revert-non-file-buffers nil)

;; always use space for indentation
(setq-default
 indent-tabs-mode nil
 require-final-newline t
 tab-width 4)

;; enable winner-mode (C-h f winner-mode RET)
(winner-mode 1)

;; don't display *compilation* buffer on success.  based on
;; https://stackoverflow.com/a/17788551, with changes to use `cl-letf'
;; instead of the now obsolete `flet'.
(with-eval-after-load 'compile
  (defun a/compilation-finish-function (buffer outstr)
    (unless (string-match "finished" outstr)
      (switch-to-buffer-other-window buffer))
    t)

  (setq compilation-finish-functions #'a/compilation-finish-function)

  (require 'cl-macs)

  (defadvice compilation-start
      (around inhibit-display
              (command &optional mode name-function highlight-regexp))
    (if (not (string-match "^\\(find\\|grep\\)" command))
        (cl-letf (((symbol-function 'display-buffer) #'ignore))
          (save-window-excursion ad-do-it))
      ad-do-it))
  (ad-activate 'compilation-start))

;; search for non-ASCII characters: i’d like non-ASCII characters such
;; as ‘’“”«»‹›áⓐ𝒶 to be selected when i search for their ASCII
;; counterpart.  shoutout to
;; http://endlessparentheses.com/new-in-emacs-25-1-easily-search-non-ascii-characters.html
(setq search-default-mode #'char-fold-to-regexp)
;; uncomment to extend this behaviour to query-replace
;; (setq replace-char-fold t)

;; cursor shape
(setq-default cursor-type 'bar)

;; allow scrolling in Isearch
(setq isearch-allow-scroll t)

(use-feature vc
  :bind ("C-x v C-=" . vc-ediff))

(use-feature ediff
  :config (add-hook 'ediff-after-quit-hook-internal 'winner-undo)
  :custom ((ediff-window-setup-function 'ediff-setup-windows-plain)
           (ediff-split-window-function 'split-window-horizontally)))

\f
;;; General bindings

(bind-keys
 ("C-c a i" . ielm)

 ("C-c e b" . eval-buffer)
 ("C-c e r" . eval-region)

 ("C-c e i" . emacs-init-time)
 ("C-c e u" . emacs-uptime)

 ("C-c F m" . make-frame-command)
 ("C-c F d" . delete-frame)
 ("C-c F D" . server-edit)

 ("C-c o"   . other-window)

 ("C-S-h C" . describe-char)
 ("C-S-h F" . describe-face)

 ("C-x k"   . kill-this-buffer)
 ("C-x K"   . kill-buffer)

 ("s-p"     . beginning-of-buffer)
 ("s-n"     . end-of-buffer)

 :map emacs-lisp-mode-map
 ("<C-return>" . a/add-elisp-section))

(when (display-graphic-p)
  (unbind-key "C-z" global-map))

(bind-keys
 :prefix-map a/straight-prefix-map
 :prefix "C-c p s"
 ("u" . straight-use-package)
 ("f" . straight-freeze-versions)
 ("t" . straight-thaw-versions)
 ("P" . straight-prune-build)
 ("g" . straight-get-recipe)
 ("r" . a/reload-init)
 ;; M-x ^straight-.*-all$
 ("a c" . straight-check-all)
 ("a f" . straight-fetch-all)
 ("a m" . straight-merge-all)
 ("a n" . straight-normalize-all)
 ("a F" . straight-pull-all)
 ("a P" . straight-push-all)
 ("a r" . straight-rebuild-all)
 ;; M-x ^straight-.*-package$
 ("p c" . straight-check-package)
 ("p f" . straight-fetch-package)
 ("p m" . straight-merge-package)
 ("p n" . straight-normalize-package)
 ("p F" . straight-pull-package)
 ("p P" . straight-push-package)
 ("p r" . straight-rebuild-package))

\f
;;; Essential packages

(use-package auto-compile
  :demand t
  :config
  (auto-compile-on-load-mode)
  (auto-compile-on-save-mode)
  (setq auto-compile-display-buffer               nil
        auto-compile-mode-line-counter            t
        auto-compile-source-recreate-deletes-dest t
        auto-compile-toggle-deletes-nonlib-dest   t
        auto-compile-update-autoloads             t)
  (add-hook 'auto-compile-inhibit-compile-hook
            'auto-compile-inhibit-compile-detached-git-head))

;; use the org-plus-contrib package to get the whole deal
(straight-use-package 'org-plus-contrib)

(use-feature org
  :defer 0.5
  :config
  (setq org-src-tab-acts-natively t
        org-src-preserve-indentation nil
        org-edit-src-content-indentation 0
        org-link-email-description-format "Email %c: %s" ; %.30s
        org-highlight-latex-and-related '(entities)
        org-use-speed-commands t
        org-startup-folded 'content
        org-catch-invisible-edits 'show-and-error
        org-log-done 'time)
  (add-to-list 'org-structure-template-alist '("L" . "src emacs-lisp") t)
  :bind
  (("C-c a o a" . org-agenda)
   :map org-mode-map
   ("M-L" . org-insert-last-stored-link)
   ("s-T" . org-todo))
  :hook ((org-mode . org-indent-mode)
         (org-mode . auto-fill-mode)
         (org-mode . flyspell-mode))
  :custom
  (org-agenda-files '("~/usr/org/todos/personal.org"
                      "~/usr/org/todos/masters.org"))
  (org-agenda-start-on-weekday 0)
  (org-latex-packages-alist '(("" "listings") ("" "color")))
  :custom-face
  '(org-block-begin-line ((t (:foreground "#5a5b5a" :background "#1d1f21"))))
  '(org-block ((t (:background "#1d1f21"))))
  '(org-latex-and-related ((t (:foreground "#b294bb")))))

(use-feature ox-latex
  :after ox
  :config
  (setq org-latex-listings 'listings
        ;; org-latex-prefer-user-labels t
        )
  (add-to-list 'org-latex-classes
               '("IEEEtran" "\\documentclass[11pt]{IEEEtran}"
                 ("\\section{%s}"       . "\\section*{%s}")
                 ("\\subsection{%s}"    . "\\subsection*{%s}")
                 ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                 ("\\paragraph{%s}"     . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}"  . "\\subparagraph*{%s}"))
               t)
  (require 'ox-beamer))

(use-feature ox-extra
  :config
  (ox-extras-activate '(latex-header-blocks ignore-headlines)))

;; asynchronous tangle, using emacs-async to asynchronously tangle an
;; org file.  closely inspired by
;; https://github.com/dieggsy/dotfiles/tree/cc10edf7701958eff1cd94d4081da544d882a28c/emacs.d#dotfiles
(with-eval-after-load 'org
  (defvar a/show-async-tangle-results nil
    "Keep *emacs* async buffers around for later inspection.")

  (defvar a/show-async-tangle-time nil
    "Show the time spent tangling the file.")

  (defun a/async-babel-tangle ()
    "Tangle org file asynchronously."
    (interactive)
    (let* ((file-tangle-start-time (current-time))
           (file (buffer-file-name))
           (file-nodir (file-name-nondirectory file))
           ;; (async-quiet-switch "-q")
           (file-noext (file-name-sans-extension file)))
      (async-start
       `(lambda ()
          (require 'org)
          (org-babel-tangle-file ,file))
       (unless a/show-async-tangle-results
         `(lambda (result)
            (if result
                (message "Tangled %s%s"
                         ,file-nodir
                         (if a/show-async-tangle-time
                             (format " (%.3fs)"
                                     (float-time (time-subtract (current-time)
                                                                ',file-tangle-start-time)))
                           ""))
              (message "Tangling %s failed" ,file-nodir))))))))

(add-to-list
 'safe-local-variable-values
 '(eval add-hook 'after-save-hook #'a/async-babel-tangle 'append 'local))

;; *the* right way to do git
(use-package magit
  :defer 0.5
  :bind (("C-x g" . magit-status)
         ("s-g s" . magit-status)
         ("s-g l" . magit-log-buffer-file))
  :config
  (magit-add-section-hook 'magit-status-sections-hook
                          'magit-insert-modules
                          'magit-insert-stashes
                          'append)
  (setq magit-repository-directories '(("~/" . 0)
                                       ("~/src/git/" . 1)))
  (nconc magit-section-initial-visibility-alist
         '(([unpulled status] . show)
           ([unpushed status] . show)))
  :custom (magit-display-buffer-function #'magit-display-buffer-fullframe-status-v1)
  :custom-face (magit-diff-file-heading ((t (:weight normal)))))

;; recently opened files
(use-feature recentf
  :defer 0.2
  :config
  (add-to-list 'recentf-exclude "^/\\(?:ssh\\|su\\|sudo\\)?:")
  (setq recentf-max-saved-items 40))

;; smart M-x enhancement (needed by counsel for history)
(use-package smex)

(use-package ivy
  :defer 0.3
  :bind
  (:map ivy-minibuffer-map
   ([escape] . keyboard-escape-quit)
   ([S-up]   . ivy-previous-history-element)
   ([S-down] . ivy-next-history-element)
   ("DEL"    . ivy-backward-delete-char))
  :config
  (setq ivy-wrap t
        ivy-height 14
        ivy-use-virtual-buffers t
        ivy-virtual-abbreviate 'abbreviate
        ivy-count-format "%d/%d ")
  (ivy-mode 1)
  ;; :custom-face
  ;; (ivy-minibuffer-match-face-2 ((t (:background "#e99ce8" :weight semi-bold))))
  ;; (ivy-minibuffer-match-face-3 ((t (:background "#bbbbff" :weight semi-bold))))
  ;; (ivy-minibuffer-match-face-4 ((t (:background "#ffbbff" :weight semi-bold))))
)

(use-package swiper
  :after ivy
  :bind (("C-s"   . swiper-isearch)
         ("C-r"   . swiper)
         ("C-S-s" . isearch-forward)))

(use-package counsel
  :after ivy
  :bind (([remap execute-extended-command] . counsel-M-x)
         ([remap find-file]                . counsel-find-file)
         ("C-c x"                          . counsel-M-x)
         ("C-c f ."                        . counsel-find-file)
         ("C-c f l"                        . counsel-find-library)
         ("C-c f r"                        . counsel-recentf)
         ("s-."                            . counsel-find-file)
         ("s-r"                            . ivy-switch-buffer)
         :map minibuffer-local-map
         ("C-r" . counsel-minibuffer-history))
  :config
  (counsel-mode 1)
  (defalias 'locate #'counsel-locate))

(comment
  (use-package helm
    :commands (helm-M-x helm-mini helm-resume)
    :bind (("M-x"     . helm-M-x)
           ("M-y"     . helm-show-kill-ring)
           ("C-x b"   . helm-mini)
           ("C-x C-b" . helm-buffers-list)
           ("C-x C-f" . helm-find-files)
           ("C-h r"   . helm-info-emacs)
           ("s-r"     . helm-recentf)
           ("C-s-r"   . helm-resume)
           :map helm-map
           ("<tab>" . helm-execute-persistent-action)
           ("C-i"   . helm-execute-persistent-action) ; Make TAB work in terminals
           ("C-z"   . helm-select-action))            ; List actions
    :config (helm-mode 1)))

(use-feature eshell
  :defer 0.5
  :commands eshell
  :bind ("C-c a s e" . eshell)
  :config
  (eval-when-compile (defvar eshell-prompt-regexp))
  (defun a/eshell-quit-or-delete-char (arg)
    (interactive "p")
    (if (and (eolp) (looking-back eshell-prompt-regexp nil))
        (eshell-life-is-too-much)
      (delete-char arg)))

  (defun a/eshell-clear ()
    (interactive)
    (let ((inhibit-read-only t))
      (erase-buffer))
    (eshell-send-input))

  (defun a/eshell-setup ()
    (make-local-variable 'company-idle-delay)
    (defvar company-idle-delay)
    (setq company-idle-delay nil)
    (bind-keys :map eshell-mode-map
               ("C-d"   . a/eshell-quit-or-delete-char)
               ("C-S-l" . a/eshell-clear)
               ("M-r"   . counsel-esh-history)
               ([tab]   . company-complete)))

  :hook (eshell-mode . a/eshell-setup)
  :custom
  (eshell-hist-ignoredups t)
  (eshell-input-filter 'eshell-input-filter-initial-space))

(use-feature ibuffer
  :bind
  (("C-x C-b" . ibuffer-other-window)
   :map ibuffer-mode-map
   ("P"   . ibuffer-backward-filter-group)
   ("N"   . ibuffer-forward-filter-group)
   ("M-p" . ibuffer-do-print)
   ("M-n" . ibuffer-do-shell-command-pipe-replace))
  :config
  ;; Use human readable Size column instead of original one
  (define-ibuffer-column size-h
    (:name "Size" :inline t)
    (cond
     ((> (buffer-size) 1000000) (format "%7.1fM" (/ (buffer-size) 1000000.0)))
     ((> (buffer-size) 100000) (format "%7.0fk" (/ (buffer-size) 1000.0)))
     ((> (buffer-size) 1000) (format "%7.1fk" (/ (buffer-size) 1000.0)))
     (t (format "%8d" (buffer-size)))))
  :custom
  (ibuffer-saved-filter-groups
   '(("default"
      ("dired" (mode . dired-mode))
      ("org"   (mode . org-mode))
      ("gnus"
       (or
        (mode . gnus-group-mode)
        (mode . gnus-summary-mode)
        (mode . gnus-article-mode)
        ;; not really, but...
        (mode . message-mode)))
      ("web"
       (or
        (mode . web-mode)
        (mode . css-mode)
        (mode . scss-mode)
        (mode . js2-mode)))
      ("shell"
       (or
        (mode . eshell-mode)
        (mode . shell-mode)
        (mode . term-mode)))
      ("programming"
       (or
        (mode . python-mode)
        (mode . c-mode)
        (mode . c++-mode)
        (mode . java-mode)
        (mode . emacs-lisp-mode)
        (mode . scheme-mode)
        (mode . haskell-mode)
        (mode . lean-mode)
        (mode . alloy-mode)))
      ("tex"
       (or
        (mode . bibtex-mode)
        (mode . latex-mode)))
      ("emacs"
       (or
        (name . "^\\*scratch\\*$")
        (name . "^\\*Messages\\*$")))
      ("erc" (mode . erc-mode)))))
  (ibuffer-formats
   '((mark modified read-only locked " "
           (name 18 18 :left :elide)
           " "
           (size-h 9 -1 :right)
           " "
           (mode 16 16 :left :elide)
           " " filename-and-process)
     (mark " "
           (name 16 -1)
           " " filename)))
  :hook (ibuffer . (lambda () (ibuffer-switch-to-saved-filter-groups "default"))))

(use-feature outline
  :hook (prog-mode . outline-minor-mode)
  :bind
  (:map
   outline-minor-mode-map
   ("<s-tab>"  . outline-toggle-children)
   ("M-p"      . outline-previous-visible-heading)
   ("M-n"      . outline-next-visible-heading)
   :prefix-map a/outline-prefix-map
   :prefix "s-o"
   ("TAB" . outline-toggle-children)
   ("a"   . outline-hide-body)
   ("H"   . outline-hide-body)
   ("S"   . outline-show-all)
   ("h"   . outline-hide-subtree)
   ("s"   . outline-show-subtree)))

(use-feature ls-lisp
  :custom (ls-lisp-dirs-first t))

(use-feature dired
  :config
  (setq dired-listing-switches "-alh"
        ls-lisp-use-insert-directory-program nil)

  ;; easily diff 2 marked files
  ;; https://oremacs.com/2017/03/18/dired-ediff/
  (defun dired-ediff-files ()
    (interactive)
    (require 'dired-aux)
    (defvar ediff-after-quit-hook-internal)
    (let ((files (dired-get-marked-files))
          (wnd (current-window-configuration)))
      (if (<= (length files) 2)
          (let ((file1 (car files))
                (file2 (if (cdr files)
                           (cadr files)
                         (read-file-name
                          "file: "
                          (dired-dwim-target-directory)))))
            (if (file-newer-than-file-p file1 file2)
                (ediff-files file2 file1)
              (ediff-files file1 file2))
            (add-hook 'ediff-after-quit-hook-internal
                      (lambda ()
                        (setq ediff-after-quit-hook-internal nil)
                        (set-window-configuration wnd))))
        (error "no more than 2 files should be marked"))))
  :bind (:map dired-mode-map
              ("b"  . dired-up-directory)
              ("e"  . dired-ediff-files)
              ("E"  . dired-toggle-read-only)
              ("\\" . dired-hide-details-mode)
              ("z"  . (lambda ()
                        (interactive)
                        (a/dired-start-process "zathura"))))
  :hook (dired-mode . dired-hide-details-mode))

(use-feature help
  :config
  (temp-buffer-resize-mode)
  (setq help-window-select t))

(use-feature tramp
  :config
  (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" "/ssh:%h:"))
  (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil))
  (add-to-list 'tramp-default-proxies-alist
               (list (regexp-quote (system-name)) nil nil)))

(use-package dash
  :config (dash-enable-font-lock))

(use-package doc-view
  :bind (:map doc-view-mode-map
              ("M-RET" . image-previous-line)))

\f
;;; Editing

;; highlight uncommitted changes in the left fringe
(use-package diff-hl
  :defer 0.6
  :config
  (setq diff-hl-draw-borders nil)
  (global-diff-hl-mode)
  :hook (magit-post-refresh . diff-hl-magit-post-refresh))

;; display Lisp objects at point in the echo area
(use-feature eldoc
  :when (version< "25" emacs-version)
  :config (global-eldoc-mode))

;; highlight matching parens
(use-feature paren
  :demand
  :config (show-paren-mode))

(use-feature simple
  :config (column-number-mode))

;; save minibuffer history
(use-feature savehist
  :config (savehist-mode))

;; automatically save place in files
(use-feature saveplace
  :when (version< "25" emacs-version)
  :config (save-place-mode))

(use-feature prog-mode
  :config (global-prettify-symbols-mode)
  (defun indicate-buffer-boundaries-left ()
    (setq indicate-buffer-boundaries 'left))
  (add-hook 'prog-mode-hook #'indicate-buffer-boundaries-left))

(use-feature text-mode
  :hook ((text-mode . indicate-buffer-boundaries-left)
         (text-mode . abbrev-mode)))

(use-package company
  :defer 0.6
  :bind
  (:map company-active-map
        ([tab]    . company-complete-common-or-cycle)
        ([escape] . company-abort))
  :custom
  (company-minimum-prefix-length 1)
  (company-selection-wrap-around t)
  (company-dabbrev-char-regexp "\\sw\\|\\s_\\|[-_]")
  (company-dabbrev-downcase nil)
  (company-dabbrev-ignore-case nil)
  :config
  (global-company-mode t))

(use-package flycheck
  :defer 0.6
  :hook (prog-mode . flycheck-mode)
  :bind
  (:map flycheck-mode-map
        ("M-P" . flycheck-previous-error)
        ("M-N" . flycheck-next-error))
  :config
  ;; Use the load-path from running Emacs when checking elisp files
  (setq flycheck-emacs-lisp-load-path 'inherit)

  ;; Only flycheck when I actually save the buffer
  (setq flycheck-check-syntax-automatically '(mode-enabled save)))

;; http://endlessparentheses.com/ispell-and-apostrophes.html
(use-package ispell
  :defer 0.6
  :config
  ;; ’ can be part of a word
  (setq ispell-local-dictionary-alist
        `((nil "[[:alpha:]]" "[^[:alpha:]]"
               "['\x2019]" nil ("-B") nil utf-8)))
  ;; don't send ’ to the subprocess
  (defun endless/replace-apostrophe (args)
    (cons (replace-regexp-in-string
           "’" "'" (car args))
          (cdr args)))
  (advice-add #'ispell-send-string :filter-args
              #'endless/replace-apostrophe)

  ;; convert ' back to ’ from the subprocess
  (defun endless/replace-quote (args)
    (if (not (derived-mode-p 'org-mode))
        args
      (cons (replace-regexp-in-string
             "'" "’" (car args))
            (cdr args))))
  (advice-add #'ispell-parse-output :filter-args
              #'endless/replace-quote))

\f
;;; Programming modes

(use-feature lisp-mode
  :config
  (add-hook 'emacs-lisp-mode-hook 'outline-minor-mode)
  (add-hook 'emacs-lisp-mode-hook 'reveal-mode)
  (defun indent-spaces-mode ()
    (setq indent-tabs-mode nil))
  (add-hook 'lisp-interaction-mode-hook #'indent-spaces-mode))

(use-package alloy-mode
  :straight (:host github :repo "dwwmmn/alloy-mode")
  :mode "\\.als\\'"
  :config (setq alloy-basic-offset 2))

(use-package proof-site                 ; for Coq
  :straight proof-general)

(eval-when-compile (defvar lean-mode-map))
(use-package lean-mode
  :defer 0.4
  :bind (:map lean-mode-map
              ("S-SPC" . company-complete))
  :config
  (require 'lean-input)
  (setq default-input-method "Lean"
        lean-input-tweak-all '(lean-input-compose
                               (lean-input-prepend "/")
                               (lean-input-nonempty))
        lean-input-user-translations '(("/" "/")))
  (lean-input-setup))

(use-package haskell-mode
  :config
  (setq haskell-indentation-layout-offset 4
        haskell-indentation-left-offset 4
        flycheck-checker 'haskell-hlint
        flycheck-disabled-checkers '(haskell-stack-ghc haskell-ghc)))

(use-package dante
  :after haskell-mode
  :commands dante-mode
  :hook (haskell-mode . dante-mode))

(use-package hlint-refactor
  :after haskell-mode
  :bind (:map hlint-refactor-mode-map
              ("C-c l b" . hlint-refactor-refactor-buffer)
              ("C-c l r" . hlint-refactor-refactor-at-point))
  :hook (haskell-mode . hlint-refactor-mode))

(use-package flycheck-haskell
  :after haskell-mode)
;; alternative: hs-lint https://github.com/ndmitchell/hlint/blob/20e116a043f2073c57b17b24ae6364b5e433ba7e/data/hs-lint.el

(use-package sgml-mode
  :config
  (setq sgml-basic-offset 2))

(use-package css-mode
  :config
  (setq css-indent-offset 2))

(use-package web-mode
  :mode "\\.html\\'"
  :config
  (a/setq-every 2
    web-mode-code-indent-offset
    web-mode-css-indent-offset
    web-mode-markup-indent-offset))

(use-package emmet-mode
  :after (:any web-mode css-mode sgml-mode)
  :bind* (("C-)" . emmet-next-edit-point)
          ("C-(" . emmet-prev-edit-point))
  :config
  (unbind-key "C-j" emmet-mode-keymap)
  (setq emmet-move-cursor-between-quotes t)
  :hook (web-mode css-mode html-mode sgml-mode))

(comment
  (use-package meghanada
    :bind
    (:map meghanada-mode-map
          (("C-M-o" . meghanada-optimize-import)
           ("C-M-t" . meghanada-import-all)))
    :hook (java-mode . meghanada-mode)))

(comment
  (use-package treemacs
    :config (setq treemacs-never-persist t))

  (use-package yasnippet
    :config
    ;; (yas-global-mode)
    )

  (use-package lsp-mode
    :init (setq lsp-eldoc-render-all nil
                lsp-highlight-symbol-at-point nil)
    )

  (use-package hydra)

  (use-package company-lsp
    :after company
    :config
    (setq company-lsp-cache-candidates t
          company-lsp-async t))

  (use-package lsp-ui
    :config
    (setq lsp-ui-sideline-update-mode 'point))

  (use-package lsp-java
    :config
    (add-hook 'java-mode-hook
	          (lambda ()
	            (setq-local company-backends (list 'company-lsp))))

    (add-hook 'java-mode-hook 'lsp-java-enable)
    (add-hook 'java-mode-hook 'flycheck-mode)
    (add-hook 'java-mode-hook 'company-mode)
    (add-hook 'java-mode-hook 'lsp-ui-mode))

  (use-package dap-mode
    :after lsp-mode
    :config
    (dap-mode t)
    (dap-ui-mode t))

  (use-package dap-java
    :after (lsp-java))

  (use-package lsp-java-treemacs
    :after (treemacs)))

(comment
  (use-package eclim
    :bind (:map eclim-mode-map ("S-SPC" . company-complete))
    :hook ((java-mode . eclim-mode)
           (eclim-mode . (lambda ()
                           (make-local-variable 'company-idle-delay)
                           (defvar company-idle-delay)
                           ;; (setq company-idle-delay 0.7)
                           (setq company-idle-delay nil))))
    :custom
    (eclim-auto-save nil)
    ;; (eclimd-default-workspace "~/src/eclipse-workspace-exp")
    (eclim-executable "~/.p2/pool/plugins/org.eclim_2.8.0/bin/eclim")
    (eclim-eclipse-dirs '("~/usr/eclipse/dsl-2018-09/eclipse"))))

(use-package geiser)

(use-feature geiser-guile
  :config
  (setq geiser-guile-load-path "~/src/git/guix"))

(use-package guix)

(comment
  (use-package auctex
    :custom
    (font-latex-fontify-sectioning 'color)))

\f
;;; Theme

(add-to-list 'custom-theme-load-path "~/.emacs.d/lisp")
(load-theme 'tangomod t)

(use-package smart-mode-line
  :commands (sml/apply-theme)
  :demand
  :config
  (sml/setup))

(use-package doom-themes)

(defvar a/org-mode-font-lock-keywords
  '(("[ \t]*\\(#\\+\\(BEGIN\\|END\\|begin\\|end\\)_\\(\\S-+\\)\\)[ \t]*\\([^\n:]*\\)"
      (1 '(:foreground "#5a5b5a" :background "#292b2b") t) ; directive
      (3 '(:foreground "#81a2be" :background "#292b2b") t) ; kind
      (4 '(:foreground "#c5c8c6") t))))                    ; title

(defun a/lights-on ()
  "Enable my favourite light theme."
  (interactive)
  (mapc #'disable-theme custom-enabled-themes)
  (load-theme 'tangomod t)
  (sml/apply-theme 'automatic)
  (font-lock-remove-keywords
   'org-mode a/org-mode-font-lock-keywords))

(defun a/lights-off ()
  "Go dark."
  (interactive)
  (mapc #'disable-theme custom-enabled-themes)
  (load-theme 'doom-tomorrow-night t)
  (sml/apply-theme 'automatic)
  (font-lock-add-keywords
   'org-mode a/org-mode-font-lock-keywords t))

(bind-keys
 ("s-t d" . a/lights-off)
 ("s-t l" . a/lights-on))

\f
;;; Emacs enhancements & auxiliary packages

(use-feature man
  :config (setq Man-width 80))

(use-package which-key
  :defer 0.4
  :config
  (which-key-add-key-based-replacements
    ;; prefixes for global prefixes and minor modes
    "C-c @"   "outline"
    "C-c !"   "flycheck"
    "C-c 8"   "typo"
    "C-c 8 -" "typo/dashes"
    "C-c 8 <" "typo/left-brackets"
    "C-c 8 >" "typo/right-brackets"
    "C-x 8"   "unicode"
    "C-x a"   "abbrev/expand"
    "C-x r"   "rectangle/register/bookmark"
    "C-x v"   "version control"
    ;; prefixes for my personal bindings
    "C-c a"   "applications"
    "C-c a e" "erc"
    "C-c a o" "org"
    "C-c a s" "shells"
    "C-c p"   "package-management"
    ;; "C-c p e" "package-management/epkg"
    "C-c p s" "straight.el"
    "C-c psa" "all"
    "C-c psp" "package"
    "C-c c"   "compile-and-comments"
    "C-c e"   "eval"
    "C-c f"   "files"
    "C-c F"   "frames"
    "C-S-h"   "help(ful)"
    "C-c m"   "multiple-cursors"
    "C-c P"   "projectile"
    "C-c P s" "projectile/search"
    "C-c P x" "projectile/execute"
    "C-c P 4" "projectile/other-window"
    "C-c q"   "boxquote"
    "s-g"     "magit"
    "s-o"     "outline"
    "s-t"     "themes")

  ;; prefixes for major modes
  (which-key-add-major-mode-key-based-replacements 'message-mode
    "C-c f"   "footnote")
  (which-key-add-major-mode-key-based-replacements 'org-mode
    "C-c C-v" "org-babel")
  (which-key-add-major-mode-key-based-replacements 'web-mode
    "C-c C-a" "web/attributes"
    "C-c C-b" "web/blocks"
    "C-c C-d" "web/dom"
    "C-c C-e" "web/element"
    "C-c C-t" "web/tags")

  (which-key-mode)
  :custom
  (which-key-add-column-padding 5)
  (which-key-max-description-length 32))

(use-package crux            ; results in Waiting for git... [2 times]
  :defer 0.4
  :bind (("C-c b k" . crux-kill-other-buffers)
         ("C-c d"   . crux-duplicate-current-line-or-region)
         ("C-c D"   . crux-duplicate-and-comment-current-line-or-region)
         ("C-c f c" . crux-copy-file-preserve-attributes)
         ("C-c f d" . crux-delete-file-and-buffer)
         ("C-c f r" . crux-rename-file-and-buffer)
         ("C-c j"   . crux-top-join-line)
         ("C-S-j"   . crux-top-join-line)))

(use-package mwim
  :bind (("C-a"    . mwim-beginning-of-code-or-line)
         ("C-e"    . mwim-end-of-code-or-line)
         ("<home>" . mwim-beginning-of-line-or-code)
         ("<end>"  . mwim-end-of-line-or-code)))

(use-package projectile
  :bind-keymap ("C-c P" . projectile-command-map)
  :config
  (projectile-mode)

  (defun my-projectile-invalidate-cache (&rest _args)
    ;; ignore the args to `magit-checkout'
    (projectile-invalidate-cache nil))

  (eval-after-load 'magit-branch
    '(progn
       (advice-add 'magit-checkout
                   :after #'my-projectile-invalidate-cache)
       (advice-add 'magit-branch-and-checkout
                   :after #'my-projectile-invalidate-cache)))
  :custom (projectile-completion-system 'ivy))

(use-package helpful
  :defer 0.6
  :bind
  (("C-S-h c" . helpful-command)
   ("C-S-h f" . helpful-callable)        ; helpful-function
   ("C-S-h v" . helpful-variable)
   ("C-S-h k" . helpful-key)
   ("C-S-h p" . helpful-at-point)))

(use-package unkillable-scratch
  :defer 0.6
  :config
  (unkillable-scratch 1)
  :custom
  (unkillable-buffers '("^\\*scratch\\*$" "^\\*Messages\\*$")))

;; ,----
;; | make pretty boxed quotes like this
;; `----
(use-package boxquote
  :defer 0.6
  :bind
  (:prefix-map a/boxquote-prefix-map
   :prefix "C-c q"
   ("b"   . boxquote-buffer)
   ("B"   . boxquote-insert-buffer)
   ("d"   . boxquote-defun)
   ("F"   . boxquote-insert-file)
   ("hf"  . boxquote-describe-function)
   ("hk"  . boxquote-describe-key)
   ("hv"  . boxquote-describe-variable)
   ("hw"  . boxquote-where-is)
   ("k"   . boxquote-kill)
   ("p"   . boxquote-paragraph)
   ("q"   . boxquote-boxquote)
   ("r"   . boxquote-region)
   ("s"   . boxquote-shell-command)
   ("t"   . boxquote-text)
   ("T"   . boxquote-title)
   ("u"   . boxquote-unbox)
   ("U"   . boxquote-unbox-region)
   ("y"   . boxquote-yank)
   ("M-q" . boxquote-fill-paragraph)
   ("M-w" . boxquote-kill-ring-save)))

(use-package orgalist
  ;; http://lists.gnu.org/archive/html/emacs-orgmode/2019-04/msg00007.html
  :disabled t
  :after message
  :hook (message-mode . orgalist-mode))

;; easily type pretty quotes & other typography, like ‘’“”-–—«»‹›
(use-package typo
  :defer 0.5
  :config
  (typo-global-mode 1)
  :hook (text-mode . typo-mode))

;; highlight TODOs in buffers
(use-package hl-todo
  :defer 0.5
  :config
  (global-hl-todo-mode))

(use-package shrink-path
  :defer 0.5
  :after eshell
  :config
  (defvar user-@-host (concat (user-login-name) "@" (system-name) " "))
  (defun +eshell/prompt ()
    (let ((base/dir (shrink-path-prompt default-directory)))
      (concat (propertize user-@-host 'face 'default)
              (propertize (car base/dir)
                          'face 'font-lock-comment-face)
              (propertize (cdr base/dir)
                          'face 'font-lock-constant-face)
              (propertize "> " 'face 'default))))
  (setq eshell-prompt-regexp (concat user-@-host ".*> ")
        eshell-prompt-function #'+eshell/prompt))

(use-package eshell-up
  :after eshell
  :commands eshell-up)

(use-package multi-term
  :defer 0.6
  :bind (("C-c a s m m" . multi-term)
         ("C-c a s m d" . multi-term-dedicated-toggle)
         ("C-c a s m p" . multi-term-prev)
         ("C-c a s m n" . multi-term-next)
         :map term-mode-map
         ("C-c C-j" . term-char-mode))
  :config
  (setq multi-term-program "screen"
        multi-term-program-switches (concat "-c"
                                            (getenv "XDG_CONFIG_HOME")
                                            "/screen/screenrc")
        ;; TODO: add separate bindings for connecting to existing
        ;; session vs. always creating a new one
        multi-term-dedicated-select-after-open-p t
        multi-term-dedicated-window-height 20
        multi-term-dedicated-max-window-height 30
        term-bind-key-alist
        '(("C-c C-c" . term-interrupt-subjob)
          ("C-c C-e" . term-send-esc)
          ("C-c C-j" . term-line-mode)
          ("C-k" . kill-line)
          ;; ("C-y" . term-paste)
          ("C-y" . term-send-raw)
          ("M-f" . term-send-forward-word)
          ("M-b" . term-send-backward-word)
          ("M-p" . term-send-up)
          ("M-n" . term-send-down)
          ("M-j" . term-send-raw-meta)
          ("M-y" . term-send-raw-meta)
          ("M-/" . term-send-raw-meta)
          ("M-0" . term-send-raw-meta)
          ("M-1" . term-send-raw-meta)
          ("M-2" . term-send-raw-meta)
          ("M-3" . term-send-raw-meta)
          ("M-4" . term-send-raw-meta)
          ("M-5" . term-send-raw-meta)
          ("M-6" . term-send-raw-meta)
          ("M-7" . term-send-raw-meta)
          ("M-8" . term-send-raw-meta)
          ("M-9" . term-send-raw-meta)
          ("<C-backspace>" . term-send-backward-kill-word)
          ("<M-DEL>" . term-send-backward-kill-word)
          ("M-d" . term-send-delete-word)
          ("M-," . term-send-raw)
          ("M-." . comint-dynamic-complete))
        term-unbind-key-alist
        '("C-z" "C-x" "C-c" "C-h"
          ;; "C-y"
          "<ESC>")))

(use-package page-break-lines
  :defer 0.5
  :config
  (global-page-break-lines-mode))

(use-package expand-region
  :bind ("C-=" . er/expand-region))

(use-package multiple-cursors
  :bind
  (("C-S-<mouse-1>" . mc/add-cursor-on-click)
   (:prefix-map a/mc-prefix-map
               :prefix "C-c m"
               ("c" . mc/edit-lines)
               ("n" . mc/mark-next-like-this)
               ("p" . mc/mark-previous-like-this)
               ("a" . mc/mark-all-like-this))))

(use-package forge
  :after magit
  :demand)

(use-package yasnippet
  :defer 0.6
  :config
  (defconst yas-verbosity-cur yas-verbosity)
  (setq yas-verbosity 2)
  (add-to-list 'yas-snippet-dirs "~/src/git/guix/etc/snippets")
  (yas-reload-all)
  (setq yas-verbosity yas-verbosity-cur)
  :hook
  (text-mode . yas-minor-mode))

(use-package debbugs
  :straight (debbugs
             :host github
             :repo "emacs-straight/debbugs"
             :files (:defaults "Debbugs.wsdl")))

(use-package org-ref
  :init
  (a/setq-every '("~/usr/org/references.bib")
    reftex-default-bibliography
    org-ref-default-bibliography)
  (setq
   org-ref-bibliography-notes "~/usr/org/notes.org"
   org-ref-pdf-directory "~/usr/org/bibtex-pdfs/"))

;; ugh, temporary (still better than using the proprietary web app)
(use-package slack
  :commands (slack-start)
  :init
  (eval-when-compile                    ; silence the byte-compiler
    (defvar url-http-data nil)
    (defvar url-http-extra-headers nil)
    (defvar url-http-method nil)
    (defvar url-callback-function nil)
    (defvar url-callback-arguments nil)
    (defvar oauth--token-data nil))
  (setq slack-buffer-emojify t
        slack-prefer-current-team t)
  :config
  (slack-register-team
   :name "nday-students"
   :default t
   :token nday-students-token
   :subscribed-channels '(general)
   :full-and-display-names t)
  (add-to-list 'swiper-font-lock-exclude 'slack-message-buffer-mode t)
  (setq lui-time-stamp-format "[%Y-%m-%d %H:%M:%S]"
        lui-time-stamp-only-when-changed-p t
        lui-time-stamp-position 'right)
  :bind
  (("C-c s s" . slack-start)
   ("C-c s u" . slack-select-unread-rooms)
   ("C-c s b" . slack-select-rooms)
   ("C-c s t" . slack-change-current-team)
   ("C-c s c" . slack-ws-close)
   :map slack-mode-map
   ("M-p"     . slack-buffer-goto-prev-message)
   ("M-n"     . slack-buffer-goto-next-message)
   ("C-c e"   . slack-message-edit)
   ("C-c k"   . slack-message-delete)
   ("C-c C-k" . slack-channel-leave)
   ("C-c r a" . slack-message-add-reaction)
   ("C-c r r" . slack-message-remove-reaction)
   ("C-c r s" . slack-message-show-reaction-users)
   ("C-c p l" . slack-room-pins-list)
   ("C-c p a" . slack-message-pins-add)
   ("C-c p r" . slack-message-pins-remove)
   ("@"       . slack-message-embed-mention)
   ("#"       . slack-message-embed-channel)))

(use-package alert
  :commands (alert)
  :init
  (setq alert-default-style 'notifier))

\f
;;; Email (with Gnus)

(defvar a/maildir (expand-file-name "~/mail/"))
(with-eval-after-load 'recentf
  (add-to-list 'recentf-exclude a/maildir))

(setq
 a/gnus-init-file  (no-littering-expand-etc-file-name "gnus")
 mail-user-agent   'gnus-user-agent
 read-mail-command 'gnus)

(use-feature gnus
  :bind (("s-m"   . gnus)
         ("s-M"   . gnus-unplugged))
  :init
  (setq
   gnus-select-method '(nnnil "")
   gnus-secondary-select-methods
   '((nnimap "amin"
            (nnimap-stream plain)
            (nnimap-address "127.0.0.1")
            (nnimap-server-port 143)
            (nnimap-authenticator plain)
            (nnimap-user "amin@bndl.local"))
     (nnimap "uw"
             (nnimap-stream plain)
             (nnimap-address "127.0.0.1")
             (nnimap-server-port 143)
             (nnimap-authenticator plain)
             (nnimap-user "abandali@uw.local"))
     (nnimap "csc"
             (nnimap-stream plain)
             (nnimap-address "127.0.0.1")
             (nnimap-server-port 143)
             (nnimap-authenticator plain)
             (nnimap-user "abandali@csc.uw.local")))
   gnus-message-archive-group "nnimap+amin:Sent"
   gnus-parameters
   '(("gnu\\.deepspec"
      (to-address . "deepspec@lists.cs.princeton.edu")
      (to-list    . "deepspec@lists.cs.princeton.edu"))
     ("gnu\\.emacs-devel"
      (to-address . "emacs-devel@gnu.org")
      (to-list    . "emacs-devel@gnu.org"))
     ("gnu\\.emacs-orgmode"
      (to-address . "emacs-orgmode@gnu.org")
      (to-list    . "emacs-orgmode@gnu.org"))
     ("gnu\\.emacsconf-discuss"
      (to-address . "emacsconf-discuss@gnu.org")
      (to-list    . "emacsconf-discuss@gnu.org"))
     ("gnu\\.fencepost-users"
      (to-address . "fencepost-users@gnu.org")
      (to-list    . "fencepost-users@gnu.org"))
     ("gnu\\.gnunet-developers"
      (to-address . "gnunet-developers@gnu.org")
      (to-list    . "gnunet-developers@gnu.org"))
     ("gnu\\.guile-devel"
      (to-address . "guile-devel@gnu.org")
      (to-list    . "guile-devel@gnu.org"))
     ("gnu\\.guix-devel"
      (to-address . "guix-devel@gnu.org")
      (to-list    . "guix-devel@gnu.org"))
     ("gnu\\.haskell-art"
      (to-address . "haskell-art@we.lurk.org")
      (to-list    . "haskell-art@we.lurk.org"))
     ("gnu\\.haskell-cafe"
      (to-address . "haskell-cafe@haskell.org")
      (to-list    . "haskell-cafe@haskell.org"))
     ("gnu\\.help-gnu-emacs"
      (to-address . "help-gnu-emacs@gnu.org")
      (to-list    . "help-gnu-emacs@gnu.org"))
     ("gnu\\.info-gnu-emacs"
      (to-address . "info-gnu-emacs@gnu.org")
      (to-list    . "info-gnu-emacs@gnu.org"))
     ("gnu\\.info-guix"
      (to-address . "info-guix@gnu.org")
      (to-list    . "info-guix@gnu.org"))
     ("gnu\\.notmuch"
      (to-address . "notmuch@notmuchmail.org")
      (to-list    . "notmuch@notmuchmail.org"))
     ("gnu\\.parabola-dev"
      (to-address . "dev@lists.parabola.nu")
      (to-list    . "dev@lists.parabola.nu"))
     ("gnu\\.webmasters"
      (to-address . "webmasters@gnu.org")
      (to-list    . "webmasters@gnu.org"))
     ("gnu\\.www-commits"
      (to-address . "www-commits@gnu.org")
      (to-list    . "www-commits@gnu.org"))
     ("gnu\\.www-discuss"
      (to-address . "www-discuss@gnu.org")
      (to-list    . "www-discuss@gnu.org"))
     ("gnu\\.~bandali\\.public-inbox"
      (to-address . "~bandali/public-inbox@lists.sr.ht")
      (to-list    . "~bandali/public-inbox@lists.sr.ht"))
     ("gnu\\.~sircmpwn\\.srht-admins"
      (to-address . "~sircmpwn/sr.ht-admins@lists.sr.ht")
      (to-list    . "~sircmpwn/sr.ht-admins@lists.sr.ht"))
     ("gnu\\.~sircmpwn\\.srht-announce"
      (to-address . "~sircmpwn/sr.ht-announce@lists.sr.ht")
      (to-list    . "~sircmpwn/sr.ht-announce@lists.sr.ht"))
     ("gnu\\.~sircmpwn\\.srht-dev"
      (to-address . "~sircmpwn/sr.ht-dev@lists.sr.ht")
      (to-list    . "~sircmpwn/sr.ht-dev@lists.sr.ht"))
     ("gnu\\.~sircmpwn\\.srht-discuss"
      (to-address . "~sircmpwn/sr.ht-discuss@lists.sr.ht")
      (to-list    . "~sircmpwn/sr.ht-discuss@lists.sr.ht"))
     ("gnu.*"
      (gcc-self . t))
     ("gnu\\."
      (subscribed . t)))
   gnus-large-newsgroup  50
   gnus-home-directory   (no-littering-expand-var-file-name "gnus/")
   gnus-directory        (concat gnus-home-directory "news/")
   message-directory     (concat gnus-home-directory "mail/")
   nndraft-directory     (concat gnus-home-directory "drafts/")
   gnus-save-newsrc-file nil
   gnus-read-newsrc-file nil
   gnus-interactive-exit nil
   gnus-gcc-mark-as-read t)
  :config
  (require 'ebdb)
  (require 'ebdb-mua)
  (require 'ebdb-gnus)

  (with-eval-after-load 'recentf
    (add-to-list 'recentf-exclude gnus-home-directory)))

(use-feature gnus-art
  :config
  (setq
   gnus-visible-headers
   (concat gnus-visible-headers "\\|^List-Id:\\|^X-RT-Originator:\\|^User-Agent:")
   gnus-sorted-header-list
   '("^From:" "^Subject:" "^Summary:" "^Keywords:"
     "^Followup-To:" "^To:" "^Cc:" "X-RT-Originator"
     "^Newsgroups:" "List-Id:" "^Organization:"
     "^User-Agent:" "^Date:")
  ;; local-lapsed article dates
  ;; from https://www.emacswiki.org/emacs/GnusFormatting#toc11
  gnus-article-date-headers '(user-defined)
  gnus-article-time-format
  (lambda (time)
    (let* ((date (format-time-string "%a, %d %b %Y %T %z" time))
           (local (article-make-date-line date 'local))
           (combined-lapsed (article-make-date-line date
                                                    'combined-lapsed))
           (lapsed (progn
                     (string-match " (.+" combined-lapsed)
                     (match-string 0 combined-lapsed))))
      (concat local lapsed))))
  (bind-keys
   :map gnus-article-mode-map
   ("M-L" . org-store-link)))

(use-feature gnus-sum
  :bind (:map gnus-summary-mode-map
              :prefix-map a/gnus-summary-prefix-map
              :prefix "v"
              ("r" . gnus-summary-reply)
              ("w" . gnus-summary-wide-reply)
              ("v" . gnus-summary-show-raw-article))
  :config
  (bind-keys
   :map gnus-summary-mode-map
   ("M-L" . org-store-link))
  :hook (gnus-summary-mode . a/no-mouse-autoselect-window))

(use-feature gnus-msg
  :config
  (setq gnus-posting-styles
        '((".*"
           (address "amin@bndl.org")
           (body "\nBest,\n")
           (eval (setq a/message-cite-say-hi t)))
          ("gnu.*"
           (address "bandali@gnu.org")
           (eval (set (make-local-variable 'message-user-fqdn) "fencepost.gnu.org")))
          ((header "subject" "ThankCRM")
           (to "webmasters-comment@gnu.org")
           (body "Added  to 2019supporters.html.\n\nMoving to campaigns.\n\n-amin\n")
           (eval (setq a/message-cite-say-hi nil)))
          ("nnimap\\+uw:.*"
           (address "abandali@uwaterloo.ca")
           (gcc "\"nnimap+uw:Sent Items\""))
          ("nnimap\\+csc:.*"
           (address "abandali@csclub.uwaterloo.ca")
           (gcc "nnimap+csc:Sent")))))

(use-feature gnus-topic
  :hook (gnus-group-mode . gnus-topic-mode)
  :config (setq gnus-topic-line-format "%i[ %A: %(%{%n%}%) ]%v\n"))

(use-feature gnus-agent
  :config
  (setq gnus-agent-synchronize-flags 'ask)
  :hook (gnus-group-mode . gnus-agent-mode))

(use-feature gnus-group
  :config
  (setq gnus-permanently-visible-groups "\\(:INBOX$\\|:gnu$\\)"))

(comment
  ;; problematic with ebdb's popup, *EBDB-Gnus*
  (use-feature gnus-win
    :config
    (setq gnus-use-full-window nil)))

(use-feature gnus-dired
  :commands gnus-dired-mode
  :init
  (add-hook 'dired-mode-hook 'gnus-dired-mode))

(use-feature mm-decode
  :config
  (setq mm-discouraged-alternatives '("text/html" "text/richtext")))

(use-feature sendmail
  :config
  (setq sendmail-program "/usr/bin/msmtp"
        ;; message-sendmail-extra-arguments '("-v" "-d")
        mail-specify-envelope-from t
        mail-envelope-from 'header))

(use-feature message
  :config
  ;; redefine for a simplified In-Reply-To header
  ;; (see https://todo.sr.ht/~sircmpwn/lists.sr.ht/67)
  (defun message-make-in-reply-to ()
    "Return the In-Reply-To header for this message."
    (when message-reply-headers
      (let ((from (mail-header-from message-reply-headers))
	        (msg-id (mail-header-id message-reply-headers)))
        (when from
          msg-id))))

  (defconst a/message-cite-style-format "On %Y-%m-%d %l:%M %p, %N wrote:")
  (defconst message-cite-style-bandali
    '((message-cite-function  'message-cite-original)
      (message-citation-line-function  'message-insert-formatted-citation-line)
      (message-cite-reply-position 'traditional)
      (message-yank-prefix  "> ")
      (message-yank-cited-prefix  ">")
      (message-yank-empty-prefix  ">")
      (message-citation-line-format
       (if a/message-cite-say-hi
           (concat "Hi %F,\n\n" a/message-cite-style-format)
         a/message-cite-style-format)))
    "Citation style based on Mozilla Thunderbird's. Use with message-cite-style.")
  (setq ;; message-cite-style 'message-cite-style-bandali
        message-kill-buffer-on-exit t
        message-send-mail-function 'message-send-mail-with-sendmail
        message-sendmail-envelope-from 'header
        message-subscribed-address-functions
        '(gnus-find-subscribed-addresses)
        message-dont-reply-to-names
        "\\(\\(amin@bndl\\.org\\)\\|\\(.*@\\(aminb\\|amin\\.bndl\\)\\.org\\)\\|\\(\\(bandali\\|aminb?\\|mab\\)@gnu\\.org\\)\\|\\(a\\(min\\.\\)?bandali@uwaterloo\\.ca\\)\\|\\(abandali@csclub\\.uwaterloo\\.ca\\)\\)")
  (require 'company-ebdb)
  :hook (;; (message-setup . mml-secure-message-sign-pgpmime)
         (message-mode . flyspell-mode)
         (message-mode . (lambda ()
                           ;; (setq fill-column 65
                           ;;       message-fill-column 65)
                           (make-local-variable 'company-idle-delay)
                           (setq company-idle-delay 0.2))))
  ;; :custom-face
  ;; (message-header-subject ((t (:foreground "#111" :weight semi-bold))))
  ;; (message-header-to      ((t (:foreground "#111" :weight normal))))
  ;; (message-header-cc      ((t (:foreground "#333" :weight normal))))
  )

(with-eval-after-load 'mml-sec
  (setq mml-secure-openpgp-encrypt-to-self t
        mml-secure-openpgp-sign-with-sender t))

(use-feature footnote
  :after message
  ;; :config
  ;; (setq footnote-start-tag ""
  ;;       footnote-end-tag   ""
  ;;       footnote-style     'unicode)
  :bind
  (:map message-mode-map
        :prefix-map a/footnote-prefix-map
        :prefix "C-c f"
        ("a" . footnote-add-footnote)
        ("b" . footnote-back-to-message)
        ("c" . footnote-cycle-style)
        ("d" . footnote-delete-footnote)
        ("g" . footnote-goto-footnote)
        ("r" . footnote-renumber-footnotes)
        ("s" . footnote-set-style)))

(use-package ebdb
  :straight (:host github :repo "girzel/ebdb")
  :after gnus
  :bind (:map gnus-group-mode-map ("e" . ebdb))
  :config
  (setq ebdb-sources (no-littering-expand-var-file-name "ebdb"))
  (with-eval-after-load 'swiper
    (add-to-list 'swiper-font-lock-exclude 'ebdb-mode t)))

(use-feature ebdb-com
  :after ebdb)

;; (use-package ebdb-complete
;;   :after ebdb
;;   :config
;;   (ebdb-complete-enable))

(use-package company-ebdb
  :config
  (defun company-ebdb--post-complete (_) nil))

(use-feature ebdb-gnus
  :after ebdb
  :custom
  (ebdb-gnus-window-configuration
   '(article
     (vertical 1.0
               (summary 0.25 point)
               (horizontal 1.0
                           (article 1.0)
                           (ebdb-gnus 0.3))))))

(use-feature ebdb-mua
  :after ebdb
  ;; :custom (ebdb-mua-pop-up nil)
  )

;; (use-package ebdb-message
;;   :after ebdb)


;; (use-package ebdb-vcard
;;   :after ebdb)

(use-package message-x)

(comment
  (use-package message-x
    :custom
    (message-x-completion-alist
     (quote
      (("\\([rR]esent-\\|[rR]eply-\\)?[tT]o:\\|[bB]?[cC][cC]:" . gnus-harvest-find-address)
       ((if
            (boundp
             (quote message-newgroups-header-regexp))
            message-newgroups-header-regexp message-newsgroups-header-regexp)
        . message-expand-group))))))

(comment
  (use-package gnus-harvest
    :commands gnus-harvest-install
    :demand t
    :config
    (if (featurep 'message-x)
        (gnus-harvest-install 'message-x)
      (gnus-harvest-install))))

\f
;;; IRC

(use-package znc
  :straight (:host nil :repo "https://git.bndl.org/amin/znc.el")
  :bind (("C-c a e e" . znc-erc)
         ("C-c a e a" . znc-all))
  :config
  (let ((pwd (let ((auth (auth-source-search :host "znca")))
               (cond
                ((null auth) (error "Couldn't find znca's authinfo"))
                (t (funcall (plist-get (car auth) :secret)))))))
    (setq znc-servers
          `(("znc.bndl.org" 1337 t
             ((freenode "amin/freenode" ,pwd)))
            ("znc.bndl.org" 1337 t
             ((moznet "amin/moznet" ,pwd)))))))

\f
;;; Post initialization

(message "Loading %s...done (%.3fs)" user-init-file
         (float-time (time-subtract (current-time)
                                    a/before-user-init-time)))

;;; init.el ends here