.emacs.d/init.d/text/common.el

;;; common.el --- Common settings for text files. -*- lexical-binding: t; -*-

;; Time-stamp: <2020-03-27T17:52:34+0100>

;;; Commentary:

;;; Code:

(require 'basics/package-management)
(require 'basics/global-variables)

(use-package emacs
  :custom ((require-final-newline t)   ; Always add newline at end of file.
           (fill-column 80)            ; Documents are 80 chars wide by default.
           (word-wrap t))              ; Wrap at word for continuation lines.
  :bind (("C-r"    . jump-to-register) ; Move point to location in register.
         ("C-S-r"  . point-to-register); Store location of point in register.
         ("M-W"    . copy-to-register) ; Store text in register.
         ("C-S-y"  . insert-register)  ; Insert text from register.
         ("M-<f7>" . list-registers))  ; List all registers.
  :hook (text-mode . auto-fill-mode))  ; Enable word-wrapping at fill-column.

;; Quickly jump to next/previous register.
(use-package register-quicknav
  :straight (register-quicknav
             :type git
             :repo "https://schlomp.space/tastytea/register-quicknav.git"
             :branch "main")
  ;;         ^^^^^^^ See <https://github.com/raxod502/straight.el/issues/279>.
  :custom (register-quicknav-buffer-only t)
  :bind (("C-<f5>"   . register-quicknav-prev-register)
         ("C-<f6>"   . register-quicknav-next-register)
         ("C-<f7>"   . register-quicknav-point-to-unused-register)
         ("C-S-<f7>" . register-quicknav-clear-current-register)))

;; Save cursor position.
(use-package saveplace
  :config (save-place-mode t))

;; Ruler with fill-column marker.
(use-package ruler-mode
  :config (progn
            (defun my/ruler-on ()
              "Turn `ruler-mode' on."
              (ruler-mode 1)))
  :custom-face
  (ruler-mode-default ((t
                        (:inherit default
                         :background "gray18"
                         :foreground "dim gray"
                         :box nil))))
  (ruler-mode-column-number ((t
                              (:inherit ruler-mode-default
                               :foreground "dark gray"))))
  :hook ((find-file . my/ruler-on)
         (text-mode . my/ruler-on)))             ; For the scratch buffer.

;; Show a fill-column indicator vertically across the buffer.
(when (>= emacs-major-version 27)
  (use-package display-fill-column-indicator
    :hook ((find-file . display-fill-column-indicator-mode)
           (text-mode . display-fill-column-indicator-mode))))

;; Spell checking.
(unless slow-computer
  (use-package flyspell
    :if (or (executable-find "aspell")
            (executable-find "hunspell")
            (executable-find "ispell"))
    :diminish flyspell-mode
    :custom (flyspell-default-dictionary "english")
    :config (progn
              (defun my/toggle-flyspell ()
                "Toggle flyspell-mode and run flyspell-buffer after activating."
                (interactive)
                (if (bound-and-true-p flyspell-mode)
                    (flyspell-mode 0)
                  (flyspell-mode)
                  (flyspell-buffer)))

              (defun my/flyspell-german ()
                "Set dictionary to german."
                (interactive)
                (ispell-change-dictionary "german")))
    :bind (("<f9>" . my/toggle-flyspell)
           (:map flyspell-mode-map
                 ("C-;" . nil)))        ; iedit needs C-;.
    :hook ((prog-mode . flyspell-prog-mode) ; Spellcheck comments.
           (text-mode . flyspell-mode)      ; Spellcheck text documents ↓.
           (LaTeX-mode . my/flyspell-german)
           (LaTeX-mode . flyspell-mode)
           (adoc-mode . flyspell-mode)
           (markdown-mode . flyspell-mode)
           (git-commit-mode . flyspell-mode))
    :mode ("COMMIT_EDITMSG\\'" . flyspell-mode))
  ) ; unless slow-computer.

;; The string Time-stamp: <> in the first 8 lines of the file will be updated
;; with the current timestamp.
(use-package time-stamp
  :config (progn
            (if (>= emacs-major-version 27)
                (setq time-stamp-format "%Y-%02m-%02dT%02H:%02M:%02S%5z")
              ;; Set to UTC since ISO 8601 is not supported.
              (setq time-stamp-format "%Y-%02m-%02dT%02H:%02M:%02S+0000")
              (setq time-stamp-time-zone t)))
  :hook (before-save . time-stamp))

;; A template system.
(use-package yasnippet
  :after (company)
  :defines (company-candidates)
  :functions (yas-reload-all yas-expand-snippet)
  :diminish yas-minor-mode
  :config (progn
            (defun my/tab-yas-or-company ()
              "Complete with company if possible, jump to next field otherwise."
              (interactive)
              (if company-candidates
                  (company-complete-selection)
                (yas-next-field)))
            (yas-reload-all))
  :bind (:map yas-keymap
              ("<tab>" . my/tab-yas-or-company)
              ("TAB" . my/tab-yas-or-company))

  :hook (prog-mode . yas-minor-mode))

;; Install snippet-collection but don't use it.
(use-package yasnippet-snippets
  :after (yasnippet)
  ;; Don't add the snippets.
  :config (delete 'yasnippet-snippets-dir yas-snippet-dirs))

;; Automatically insert text in new files.
(use-package autoinsert
  :after (yasnippet)
  :init (progn
          (defun my/autoinsert-yas-expand ()
            "Replace text in yasnippet template."
            (yas-minor-mode t)
            (yas-expand-snippet (buffer-string) (point-min) (point-max))))
  :custom ((auto-insert-directory (concat user-emacs-directory "auto-insert"))
           (auto-insert-query nil))     ; Don't ask before inserting.
  :config (progn
            (add-to-list
             'auto-insert-alist '(("\\.c\\(pp\\|c\\|xx\\|\\+\\+\\)$" .
                                   "C++ program") .
                                   ["cpp" my/autoinsert-yas-expand]))
            (add-to-list
             'auto-insert-alist '(("\\.h\\(pp\\|h\\|xx\\|\\+\\+\\)$" .
                                   "C++ header") .
                                   ["hpp" my/autoinsert-yas-expand]))
            (add-to-list
             'auto-insert-alist '(("\\.[1-9]\\.adoc$" . "AsciiDoc manpage") .
                                  ["manpage.adoc" my/autoinsert-yas-expand]))
            (add-to-list
             'auto-insert-alist '(("\\.user.js$" . "Userscript") .
                                  ["user.js" my/autoinsert-yas-expand])))
  :hook (find-file . auto-insert))

;; Better search.
(use-package swiper
  :after (ivy)
  :functions (swiper)
  :bind ("C-s" . 'swiper))

;; Visualize and transform whitespace.
(use-package whitespace
  :after (company)
  :functions (my/on-off-whitespace-before-company)
  :diminish whitespace-mode
  :custom (whitespace-line-column nil)  ; Set to fill-column.
  :config (progn (delete 'newline-mark whitespace-style) ; Don't paint $ at eol.
                 (delete 'lines whitespace-style) ; Don't mark whole long lines.
                 (when (< emacs-major-version 27) ; Mark end of too long lines.
                   (add-to-list 'whitespace-style 'lines-tail))

                 ;; Workaround to not show dots in popup menus.
                 (defvar-local my/ws-enabled nil)
                 (defun my/whitespace-mode-off ()
                   (setq-local my/ws-enabled whitespace-mode)
                   (when my/ws-enabled
                     (whitespace-mode -1)))
                 (defun my/whitespace-mode-on ()
                   (when my/ws-enabled
                     (whitespace-mode t)))
                 ;; company:
                 (defun my/on-off-whitespace-before-company (command)
                   (when (string= "show" command)
                     (my/whitespace-mode-off))
                   (when (string= "hide" command)
                     (my/whitespace-mode-off)))
                 (advice-add 'company-call-frontends
                             :before #'my/on-off-whitespace-before-company)
                 ;; popup:
                 (defadvice popup-create (before my/popup-suspend-ws activate)
                   "Suspend whitespace-mode while popups are visible."
                   (my/whitespace-mode-off))
                 (defadvice popup-delete (after my/popup-restore-ws activate)
                   "Restore whitespace-mode when all popups have closed."
                   (my/whitespace-mode-on))

                 (if (display-graphic-p)
                     (custom-set-faces
                      '(whitespace-line
                        ((t (:inherit whitespace-line
                                      :weight normal
                                      :foreground nil
                                      :background nil
                                      :box
                                      (:line-width 1 :color "dark red"))))))
                   (custom-set-faces    ; else
                    '(whitespace-line ((t (:inherit whitespace-line
                                                    :background nil
                                                    :underline t))))))

                 ;; Workaround for
                 ;; <https://debbugs.gnu.org/cgi/bugreport.cgi?bug=36837>, fixed
                 ;; in 28.1.
                 (defun my/ws-load-local-vars-first ()
                   "Loads fill-column before enabling whitespace-mode."
                   ;; We don't use 'lines-tail in Emacs >= 27.
                   (when (< emacs-major-version 27)
                     (hack-local-variables))
                   (whitespace-mode))

                 (defvar-local my/no-ws-cleanup nil
                   "Do not cleanup whitespace if t.")
                 (put 'my/no-ws-cleanup 'safe-local-variable #'booleanp)

                 (defun my/ws-maybe-cleanup ()
                   "Run `whitespace-cleanup' if `my/no-ws-cleanup' is not t."
                   (unless my/no-ws-cleanup
                     (whitespace-cleanup))))
  :bind ("C-c w" . whitespace-mode)
  :hook ((prog-mode   . my/ws-load-local-vars-first)
         (conf-mode   . my/ws-load-local-vars-first)
         (text-mode   . my/ws-load-local-vars-first)
         (before-save . my/ws-maybe-cleanup))
  :custom-face (whitespace-space ((nil :foreground "gray18"))))

(use-package ripgrep)

(provide 'text/common)
;;; common.el ends here