spacemacs/layers/+spacemacs/spacemacs-editing/packages.el

;;; packages.el --- Spacemacs Editing Layer packages File
;;
;; Copyright (c) 2012-2021 Sylvain Benner & Contributors
;;
;; Author: Sylvain Benner <sylvain.benner@gmail.com>
;; URL: https://github.com/syl20bnr/spacemacs
;;
;; This file is not part of GNU Emacs.
;;
;; 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 <http://www.gnu.org/licenses/>.


(setq spacemacs-editing-packages
      '(aggressive-indent
        avy
        (clean-aindent-mode :toggle dotspacemacs-use-clean-aindent-mode)
        dired-quick-sort
        drag-stuff
        editorconfig
        eval-sexp-fu
        expand-region
        (hexl :location built-in)
        hungry-delete
        link-hint
        lorem-ipsum
        (origami :toggle (eq 'origami dotspacemacs-folding-method))
        password-generator
        (persistent-scratch :toggle dotspacemacs-scratch-buffer-persistent)
        pcre2el
        (smartparens :toggle dotspacemacs-activate-smartparens-mode)
        (evil-swap-keys :toggle dotspacemacs-swap-number-row)
        (spacemacs-whitespace-cleanup :location local)
        string-edit
        string-inflection
        multi-line
        undo-tree
        (unkillable-scratch :toggle dotspacemacs-scratch-buffer-unkillable)
        uuidgen
        (vimish-fold :toggle (eq 'vimish dotspacemacs-folding-method))
        (evil-vimish-fold :toggle (eq 'vimish dotspacemacs-folding-method))
        (evil-easymotion :toggle (memq dotspacemacs-editing-style '(vim hybrid)))
        ws-butler))

;; Initialization of packages
(defun spacemacs-editing/init-aggressive-indent ()
  (use-package aggressive-indent
    :defer t
    :init
    (progn
      (spacemacs|add-toggle aggressive-indent
        :mode aggressive-indent-mode
        :documentation "Always keep code indented."
        :evil-leader "tI")
      (spacemacs|add-toggle aggressive-indent-globally
        :mode global-aggressive-indent-mode
        :documentation "Always keep code indented globally."
        :evil-leader "t C-I"))
    :config
    (progn
      (add-hook 'diff-auto-refine-mode-hook 'spacemacs/toggle-aggressive-indent-off)
      (spacemacs|diminish aggressive-indent-mode " Ⓘ" " I"))))

(defun spacemacs-editing/init-avy ()
  (use-package avy
    :defer t
    :commands (spacemacs/avy-open-url spacemacs/avy-goto-url avy-pop-mark avy-with)
    :init
    (progn
      (setq avy-all-windows 'all-frames)
      (setq avy-background t)
      (spacemacs/set-leader-keys
        "jb" 'avy-pop-mark
        "jj" 'evil-avy-goto-char-timer
        "jl" 'evil-avy-goto-line
        "ju" 'spacemacs/avy-goto-url
        "jU" 'spacemacs/avy-open-url
        "jw" 'evil-avy-goto-word-or-subword-1
        "xo" 'spacemacs/avy-open-url))
    :config
    (progn
      (defun spacemacs/avy-goto-url ()
        "Use avy to go to an URL in the buffer."
        (interactive)
        (avy-jump "https?://"))
      (defun spacemacs/avy-open-url ()
        "Use avy to select an URL in the buffer and open it."
        (interactive)
        (save-excursion
          (spacemacs/avy-goto-url)
          (browse-url-at-point))))))

(defun spacemacs-editing/init-clean-aindent-mode ()
  (use-package clean-aindent-mode
    :config
    (progn
      (clean-aindent-mode)
      (add-hook 'prog-mode-hook 'spacemacs//put-clean-aindent-last t))))

(defun spacemacs-editing/init-dired-quick-sort ()
  (use-package dired-quick-sort
    :defer t
    :init
    (spacemacs|add-transient-hook dired-mode-hook
      (lambda ()
        (let ((dired-quick-sort-suppress-setup-warning 'message))
          (dired-quick-sort-setup))))
    :config
    (evil-define-key 'normal dired-mode-map "s" 'hydra-dired-quick-sort/body)))

(defun spacemacs-editing/init-drag-stuff ()
  (use-package drag-stuff
    :defer t
    :init
    (progn
      (spacemacs|diminish drag-stuff-mode)
      (drag-stuff-mode t)
      (spacemacs|define-transient-state drag-stuff
        :title "Drag Stuff Transient State"
        :doc "
[_k_/_K_] up    [_h_/_H_] left   [_q_] quit
[_j_/_J_] down  [_l_/_L_] right"
        :bindings
        ("j" drag-stuff-down)
        ("J" drag-stuff-down)
        ("<down>" drag-stuff-down)
        ("k" drag-stuff-up)
        ("K" drag-stuff-up)
        ("<up>" drag-stuff-up)
        ("h" drag-stuff-left)
        ("H" drag-stuff-left)
        ("<left>" drag-stuff-left)
        ("l" drag-stuff-right)
        ("L" drag-stuff-right)
        ("<right>" drag-stuff-right)
        ("q" nil :exit t))
      (spacemacs/set-leader-keys
        "x." 'spacemacs/drag-stuff-transient-state/body
        "xK" 'spacemacs/drag-stuff-transient-state/drag-stuff-up
        "xJ" 'spacemacs/drag-stuff-transient-state/drag-stuff-down))))

(defun spacemacs-editing/init-editorconfig ()
  (use-package editorconfig
    :init
    (spacemacs|diminish editorconfig-mode)
    :config
    (editorconfig-mode t)))

(defun spacemacs-editing/init-eval-sexp-fu ()
  (use-package eval-sexp-fu
    :commands eval-sexp-fu-flash-mode))

;; ;; ignore obsolete function warning generated on startup
;; (let ((byte-compile-not-obsolete-funcs (append byte-compile-not-obsolete-funcs '(preceding-sexp))))
;;   (require 'eval-sexp-fu)))

(defun spacemacs-editing/init-expand-region ()
  (use-package expand-region
    :defer t
    :init (spacemacs/set-leader-keys "v" 'er/expand-region)
    :config
    (progn
      ;; add search capability to expand-region
      (when (configuration-layer/package-used-p 'helm-ag)
        (defadvice er/prepare-for-more-expansions-internal
            (around helm-ag/prepare-for-more-expansions-internal activate)
          ad-do-it
          (let ((new-msg (concat (car ad-return-value)
                                 ", / to search in project, "
                                 "f to search in files, "
                                 "b to search in opened buffers"))
                (new-bindings (cdr ad-return-value)))
            (cl-pushnew
             '("/" (lambda ()
                     (call-interactively
                      'spacemacs/helm-project-smart-do-search-region-or-symbol)))
             new-bindings)
            (cl-pushnew
             '("f" (lambda ()
                     (call-interactively
                      'spacemacs/helm-files-smart-do-search-region-or-symbol)))
             new-bindings)
            (cl-pushnew
             '("b" (lambda ()
                     (call-interactively
                      'spacemacs/helm-buffers-smart-do-search-region-or-symbol)))
             new-bindings)
            (setq ad-return-value (cons new-msg new-bindings)))))
      (setq expand-region-contract-fast-key "V"
            expand-region-reset-fast-key "r"))))

(defun spacemacs-editing/init-hexl ()
  (use-package hexl
    :defer t
    :init
    (progn
      (spacemacs/set-leader-keys "fh" 'hexl-find-file)
      (spacemacs/set-leader-keys-for-major-mode 'hexl-mode
        "d" 'hexl-insert-decimal-char
        "c" 'hexl-insert-octal-char
        "x" 'hexl-insert-hex-char
        "X" 'hexl-insert-hex-string
        "g" 'hexl-goto-address)
      (evil-define-key 'motion hexl-mode-map
        "]]" 'hexl-end-of-1k-page
        "[[" 'hexl-beginning-of-1k-page
        "h" 'hexl-backward-char
        "l" 'hexl-forward-char
        "j" 'hexl-next-line
        "k" 'hexl-previous-line
        "$" 'hexl-end-of-line
        "^" 'hexl-beginning-of-line
        "0" 'hexl-beginning-of-line))))

(defun spacemacs-editing/init-hungry-delete ()
  (use-package hungry-delete
    :defer t
    :init
    (spacemacs|add-toggle hungry-delete
      :mode hungry-delete-mode
      :documentation "Delete consecutive horizontal whitespace with a single key."
      :evil-leader "td")
    :config
    (progn
      (setq-default hungry-delete-chars-to-skip " \t\f\v") ; only horizontal whitespace
      (define-key hungry-delete-mode-map (kbd "DEL") 'hungry-delete-backward)
      (define-key hungry-delete-mode-map (kbd "S-DEL") 'delete-backward-char))))

(defun spacemacs-editing/init-link-hint ()
  (use-package link-hint
    :defer t
    :init
    (spacemacs/set-leader-keys
      "xA" 'link-hint-open-all-links
      "xm" 'link-hint-open-multiple-links
      "xo" 'link-hint-open-link-at-point
      "xO" 'link-hint-open-link
      "xy" 'link-hint-copy-link-at-point
      "xY" 'link-hint-copy-link)))

(defun spacemacs-editing/init-lorem-ipsum ()
  (use-package lorem-ipsum
    :commands (lorem-ipsum-insert-list
               lorem-ipsum-insert-paragraphs
               lorem-ipsum-insert-sentences)
    :init
    (progn
      (spacemacs/declare-prefix "il" "lorem ipsum")
      (spacemacs/set-leader-keys
        "ill" 'lorem-ipsum-insert-list
        "ilp" 'lorem-ipsum-insert-paragraphs
        "ils" 'lorem-ipsum-insert-sentences))))

(defun spacemacs-editing/init-origami ()
  (use-package origami
    :defer t
    :init
    (let
        ((rebind-normal-to-motion-state-map
          (lambda (key def)
            (define-key evil-normal-state-map key nil)
            (define-key evil-motion-state-map key def))))
      (global-origami-mode)
      (funcall rebind-normal-to-motion-state-map "za" 'origami-forward-toggle-node)
      (funcall rebind-normal-to-motion-state-map "zc" 'origami-close-node)
      (funcall rebind-normal-to-motion-state-map "zC" 'origami-close-node-recursively)
      (funcall rebind-normal-to-motion-state-map "zO" 'origami-open-node-recursively)
      (funcall rebind-normal-to-motion-state-map "zo" 'origami-open-node)
      (funcall rebind-normal-to-motion-state-map "zr" 'origami-open-all-nodes)
      (funcall rebind-normal-to-motion-state-map "zm" 'origami-close-all-nodes)
      (funcall rebind-normal-to-motion-state-map "zs" 'origami-show-only-node)
      (funcall rebind-normal-to-motion-state-map "zn" 'origami-next-fold)
      (funcall rebind-normal-to-motion-state-map "zp" 'origami-previous-fold)
      (funcall rebind-normal-to-motion-state-map "zR" 'origami-reset)
      (funcall rebind-normal-to-motion-state-map (kbd "z <tab>") 'origami-recursively-toggle-node)
      (funcall rebind-normal-to-motion-state-map (kbd "z TAB") 'origami-recursively-toggle-node)

      (spacemacs|define-transient-state fold
        :title "Code Fold Transient State"
        :doc "
 Close^^            Open^^             Toggle^^         Goto^^         Other^^
 ───────^^───────── ─────^^─────────── ─────^^───────── ──────^^────── ─────^^─────────
 [_c_] at point     [_o_] at point     [_a_] at point   [_n_] next     [_s_] single out
 [_C_] recursively  [_O_] recursively  [_A_] all        [_p_] previous [_R_] reset
 [_m_] all          [_r_] all          [_TAB_] like org ^^             [_q_] quit"
        :foreign-keys run
        :on-enter (unless (bound-and-true-p origami-mode) (origami-mode 1))
        :bindings
        ("a" origami-forward-toggle-node)
        ("A" origami-toggle-all-nodes)
        ("c" origami-close-node)
        ("C" origami-close-node-recursively)
        ("o" origami-open-node)
        ("O" origami-open-node-recursively)
        ("r" origami-open-all-nodes)
        ("m" origami-close-all-nodes)
        ("n" origami-next-fold)
        ("p" origami-previous-fold)
        ("s" origami-show-only-node)
        ("R" origami-reset)
        ("TAB" origami-recursively-toggle-node)
        ("<tab>" origami-recursively-toggle-node)
        ("q" nil :exit t)
        ("C-g" nil :exit t)
        ("<SPC>" nil :exit t)))))
;; Note: The key binding for the fold transient state is defined in
;; evil config

(defun spacemacs-editing/init-vimish-fold ()
  (use-package vimish-fold
    :ensure
    :after evil))

(defun spacemacs-editing/init-evil-vimish-fold ()
  (use-package evil-vimish-fold
    :ensure
    :after vimish-fold
    :init
    (setq evil-vimish-fold-target-modes '(prog-mode conf-mode text-mode))
    :config (global-evil-vimish-fold-mode)))

(defun spacemacs-editing/init-evil-easymotion ()
  (use-package evil-easymotion
    :defer t
    :init
    (defun buffer-evil-avy-goto-char-timer ()
      "Call jump to the given chars use avy"
      (interactive)
      (let ((current-prefix-arg t))
        (evil-avy-goto-char-timer)))

    (evilem-default-keybindings "gs")
    (define-key evilem-map "a" (evilem-create #'evil-forward-arg))
    (define-key evilem-map "A" (evilem-create #'evil-backward-arg))
    (define-key evilem-map "o" (evilem-create #'evil-jump-out-args))
    (define-key evilem-map "s" #'evil-avy-goto-char-2)
    (define-key evilem-map "/" #'evil-avy-goto-char-timer)
    (define-key evilem-map (kbd "SPC") #'buffer-evil-avy-goto-char-timer)

    ;; Provide proper prefixes for which key
    (which-key-add-keymap-based-replacements evil-motion-state-map
      "gs"  "evil-easymotion")
    (which-key-add-keymap-based-replacements evilem-map
      "g" "misc"
      "[" "section backward"
      "]" "section forward")

    ;; Use evil-search backend, instead of isearch
    (evilem-make-motion evilem-motion-search-next #'evil-ex-search-next
                        :bind ((evil-ex-search-highlight-all nil)))
    (evilem-make-motion evilem-motion-search-previous #'evil-ex-search-previous
                        :bind ((evil-ex-search-highlight-all nil)))
    (evilem-make-motion evilem-motion-search-word-forward #'evil-ex-search-word-forward
                        :bind ((evil-ex-search-highlight-all nil)))
    (evilem-make-motion evilem-motion-search-word-backward #'evil-ex-search-word-backward
                        :bind ((evil-ex-search-highlight-all nil)))))

(defun spacemacs-editing/init-password-generator ()
  (use-package password-generator
    :defer t
    :init
    (progn
      (spacemacs/declare-prefix "ip" "passwords")
      (evil-leader/set-key
        "ip1" 'password-generator-simple
        "ip2" 'password-generator-strong
        "ip3" 'password-generator-paranoid
        "ipp" 'password-generator-phonetic
        "ipn" 'password-generator-numeric))))

(defun spacemacs-editing/post-init-pcre2el ()
  (spacemacs/declare-prefix "xr" "regular expressions")
  (spacemacs/declare-prefix "xre" "elisp")
  (spacemacs/declare-prefix "xrp" "pcre")
  (spacemacs/set-leader-keys
    "xr/"  'rxt-explain
    "xr'"  'rxt-convert-to-strings
    "xrt"  'rxt-toggle-elisp-rx
    "xrx"  'rxt-convert-to-rx
    "xrc"  'rxt-convert-syntax
    "xre/" 'rxt-explain-elisp
    "xre'" 'rxt-elisp-to-strings
    "xrep" 'rxt-elisp-to-pcre
    "xret" 'rxt-toggle-elisp-rx
    "xrex" 'rxt-elisp-to-rx
    "xrp/" 'rxt-explain-pcre
    "xrp'" 'rxt-pcre-to-strings
    "xrpe" 'rxt-pcre-to-elisp
    "xrpx" 'rxt-pcre-to-rx))

(defun spacemacs-editing/init-smartparens ()
  (use-package smartparens
    :defer t
    :commands (sp-point-in-string-or-comment sp-forward-symbol sp-split-sexp sp-newline sp-up-sexp)
    :init
    (progn
      ;; settings
      (setq sp-show-pair-delay
            ;; Use this form to allow users to override this setting from
            ;; dotspacemacs/user-init
            (or (bound-and-true-p sp-show-pair-delay) 0.2)
            ;; fix paren highlighting in normal mode
            sp-show-pair-from-inside t
            sp-cancel-autoskip-on-backward-movement nil
            sp-highlight-pair-overlay nil
            sp-highlight-wrap-overlay nil
            sp-highlight-wrap-tag-overlay nil)
      (spacemacs/add-to-hooks #'spacemacs//activate-smartparens
                              '(prog-mode-hook comint-mode-hook))
      ;; enable smartparens-mode in `eval-expression'
      (add-hook 'minibuffer-setup-hook 'spacemacs//conditionally-enable-smartparens-mode)
      ;; toggles
      (spacemacs|add-toggle smartparens
        :status (or (bound-and-true-p smartparens-mode)
                    (bound-and-true-p smartparens-strict-mode))
        :on (spacemacs//activate-smartparens)
        :off (spacemacs//deactivate-smartparens)
        :documentation "Enable smartparens."
        :evil-leader "tp")
      (spacemacs|add-toggle smartparens-globally
        :status (or smartparens-global-mode smartparens-global-strict-mode)
        :on (spacemacs//activate-smartparens t)
        :off (spacemacs//deactivate-smartparens t)
        :documentation "Enable smartparens globally."
        :evil-leader "t C-p")
      ;; key bindings
      (spacemacs/set-leader-keys
        "js" 'sp-split-sexp
        "jn" 'sp-newline))
    :config
    (progn
      (require 'smartparens-config)
      (spacemacs|diminish smartparens-mode " ⓟ" " p")
      (spacemacs//adaptive-smartparent-pair-overlay-face)
      (add-hook 'spacemacs-post-theme-change-hook
                'spacemacs//adaptive-smartparent-pair-overlay-face)
      (show-smartparens-global-mode +1)
      ;; don't create a pair with single quote in minibuffer
      (sp-local-pair 'minibuffer-inactive-mode "'" nil :actions nil)
      (sp-pair "{" nil :post-handlers
               '(:add (spacemacs/smartparens-pair-newline-and-indent "RET")))
      (sp-pair "[" nil :post-handlers
               '(:add (spacemacs/smartparens-pair-newline-and-indent "RET")))
      (when dotspacemacs-smart-closing-parenthesis
        (define-key evil-insert-state-map ")"
          'spacemacs/smart-closing-parenthesis)))))

(defun spacemacs-editing/init-spacemacs-whitespace-cleanup ()
  (use-package spacemacs-whitespace-cleanup
    :commands (spacemacs-whitespace-cleanup-mode
               global-spacemacs-whitespace-cleanup-mode)
    :init
    (progn
      (spacemacs|add-toggle whitespace-cleanup
        :mode spacemacs-whitespace-cleanup-mode
        :documentation "Automatic whitespace clean up."
        :on-message (spacemacs-whitespace-cleanup/on-message)
        :evil-leader "tW")
      (spacemacs|add-toggle global-whitespace-cleanup
        :mode global-spacemacs-whitespace-cleanup-mode
        :status spacemacs-whitespace-cleanup-mode
        :on (let ((spacemacs-whitespace-cleanup-globally t))
              (spacemacs-whitespace-cleanup-mode))
        :off (let ((spacemacs-whitespace-cleanup-globally t))
               (spacemacs-whitespace-cleanup-mode -1))
        :on-message (spacemacs-whitespace-cleanup/on-message t)
        :documentation "Global automatic whitespace clean up."
        :evil-leader "t C-S-w")
      (with-eval-after-load 'ws-butler
        (when dotspacemacs-whitespace-cleanup
          (spacemacs/toggle-global-whitespace-cleanup-on))))
    :config
    (progn
      (spacemacs|diminish spacemacs-whitespace-cleanup-mode " Ⓦ" " W")
      (spacemacs|diminish global-spacemacs-whitespace-cleanup-mode
                          " Ⓦ" " W"))))

(defun spacemacs-editing/init-string-inflection ()
  (use-package string-inflection
    :init
    (progn
      (spacemacs|define-transient-state string-inflection
        :title "String Inflection Transient State"
        :doc "\n [_i_] cycle"
        :bindings
        ("i" string-inflection-all-cycle))
      (spacemacs/declare-prefix "xi" "inflection")
      (spacemacs/set-leader-keys
        "xic" 'string-inflection-lower-camelcase
        "xiC" 'string-inflection-camelcase
        "xii" 'spacemacs/string-inflection-transient-state/body
        "xi-" 'string-inflection-kebab-case
        "xik" 'string-inflection-kebab-case
        "xi_" 'string-inflection-underscore
        "xiu" 'string-inflection-underscore
        "xiU" 'string-inflection-upcase))))

(defun spacemacs-editing/init-string-edit ()
  (use-package string-edit
    :init
    (spacemacs/set-leader-keys "xe" 'string-edit-at-point)
    (spacemacs/set-leader-keys-for-minor-mode 'string-edit-mode
      "," 'string-edit-conclude
      "c" 'string-edit-conclude
      "a" 'string-edit-abort
      "k" 'string-edit-abort)))

(defun spacemacs-editing/init-multi-line ()
  (use-package multi-line
    :init
    (progn
      (spacemacs|define-transient-state multi-line
        :title "Multi-line Transient State"
        :doc "\n [_n_] cycle"
        :bindings
        ("n" multi-line))
      (spacemacs/set-leader-keys
        "xn" 'spacemacs/multi-line-transient-state/body))))

(defun spacemacs-editing/init-undo-tree ()
  (use-package undo-tree
    :defer t
    :init
    (progn
      (setq undo-tree-visualizer-timestamps t
            undo-tree-visualizer-diff t
            ;; 10X bump of the undo limits to avoid issues with premature
            ;; Emacs GC which truncages the undo history very aggresively
            undo-limit 800000
            undo-strong-limit 12000000
            undo-outer-limit 120000000)
      (global-undo-tree-mode))
    :config
    (progn
      ;; restore diff window after quit.  TODO fix upstream
      (defun spacemacs/undo-tree-restore-default ()
        (setq undo-tree-visualizer-diff t))
      (advice-add 'undo-tree-visualizer-quit :after #'spacemacs/undo-tree-restore-default)
      (spacemacs|hide-lighter undo-tree-mode)
      (evilified-state-evilify-map undo-tree-visualizer-mode-map
        :mode undo-tree-visualizer-mode
        :bindings
        (kbd "j") 'undo-tree-visualize-redo
        (kbd "k") 'undo-tree-visualize-undo
        (kbd "h") 'undo-tree-visualize-switch-branch-left
        (kbd "l") 'undo-tree-visualize-switch-branch-right))))

(defun spacemacs-editing/init-uuidgen ()
  (use-package uuidgen
    :commands (uuidgen-1 uuidgen-4)
    :init
    (progn
      (spacemacs/declare-prefix "iU" "uuid")
      (spacemacs/set-leader-keys
        "iU1" 'spacemacs/uuidgen-1
        "iU4" 'spacemacs/uuidgen-4
        "iUU" 'spacemacs/uuidgen-4))))

(defun spacemacs-editing/init-ws-butler ()
  ;; not deferred on purpose, init-spacemacs-whitespace-cleanup need
  ;; it to be loaded.
  (use-package ws-butler
    :config (spacemacs|hide-lighter ws-butler-mode)))

(defun spacemacs-editing/init-evil-swap-keys ()
  (use-package evil-swap-keys
    :defer t
    :init
    (progn
      (setq evil-swap-keys-number-row-keys
            (pcase dotspacemacs-swap-number-row
              ('qwerty-us '(("1" . "!")
                            ("2" . "@")
                            ("3" . "#")
                            ("4" . "$")
                            ("5" . "%")
                            ("6" . "^")
                            ("7" . "&")
                            ("8" . "*")
                            ("9" . "(")
                            ("0" . ")")))
              ('qwertz-de '(("1" . "!")
                            ("2" . "\"")
                            ("3" . "§")
                            ("4" . "$")
                            ("5" . "%")
                            ("6" . "&")
                            ("7" . "/")
                            ("8" . "(")
                            ("9" . ")")
                            ("0" . "=")))
              ('qwerty-ca-fr '(("1" . "!")
                               ("2" . "@")
                               ("3" . "#")
                               ("4" . "$")
                               ("5" . "%")
                               ("6" . "?")
                               ("7" . "&")
                               ("8" . "*")
                               ("9" . "(")
                               ("0" . ")")))
              (x (message "dotspacemacs-swap-number-row %s is not supported." x))))
      (add-hook 'prog-mode-hook #'evil-swap-keys-swap-number-row))))

(defun spacemacs-editing/init-persistent-scratch ()
  (use-package persistent-scratch
    :defer t
    :init
    (progn
      (setq persistent-scratch-save-file (concat spacemacs-cache-directory ".persistent-scratch")
            persistent-scratch-autosave-interval 60
            persistent-scratch-what-to-save '(point narrowing))
      (add-hook 'spacemacs-scratch-mode-hook 'persistent-scratch-mode)
      (persistent-scratch-autosave-mode t))))

(defun spacemacs-editing/init-unkillable-scratch ()
  (use-package unkillable-scratch
    :defer t
    :init
    (progn
      (setq unkillable-scratch-do-not-reset-scratch-buffer t)
      (unkillable-scratch dotspacemacs-scratch-buffer-unkillable))))