;;; default.el --- default config -*- lexical-binding: t -*-

 ;;; Code:

 ;;; Settings

 (put 'upcase-region 'disabled nil)

 (put 'list-threads 'disabled nil)

 (put 'list-timers 'disabled nil)

 (setq show-paren-context-when-offscreen 'overlay)

 (setopt

  ;; tabs = bad

  indent-tabs-mode nil

  make-backup-files nil

  auto-save-list-file-prefix (expand-file-name "auto-save/." user-emacs-directory)

  tramp-auto-save-directory (expand-file-name "auto-save/tramp/" user-emacs-directory)

  dired-free-space nil

  mml-attach-file-at-the-end t

  dired-mouse-drag-files t

  confirm-kill-emacs nil

  confirm-kill-processes nil

  use-short-answers t

  display-time-format "%Y-%m-%d %H:%M"

  ring-bell-function 'ignore

  completion-ignore-case t

  ;; NOTE 2023-11-04: you need to add the following lines to ~/.gnupg/gpg-agent.conf:

  ;; allow-emacs-pinentry

  ;; allow-loopback-pinentry

  epg-pinentry-mode 'loopback

  shr-use-colors nil

  shr-use-fonts nil

  shr-max-image-proportion 0.6

  shr-image-animate nil

  shr-discard-aria-hidden t

  bookmark-default-file (expand-file-name "bookmarks" user-emacs-directory)

  project-list-file (expand-file-name "projects" user-emacs-directory)

  emms-directory (expand-file-name "emms" user-emacs-directory)

  gnus-cache-directory (expand-file-name "gnus" user-emacs-directory)

  url-cache-directory (expand-file-name "url" user-emacs-directory)

  tab-always-indent 'complete

  shr-cookie-policy nil

  ;; NOTE 2023-11-04: EXPERIMENTAL

  shr-use-xwidgets-for-media t

  browse-url-browser-function 'browse-url-default-browser

  eww-auto-rename-buffer 'title

  eww-search-prefix "https://duckduckgo.com/html?q="

  view-read-only t)

 ;;; Variables

 (defvar user-custom-file (expand-file-name (format "%s.el" user-login-name) user-emacs-directory))

 (defvar user-home-directory (expand-file-name "~"))

 (defvar user-lab-directory (expand-file-name "lab" user-home-directory))

 (defvar user-stash-directory (expand-file-name "stash" user-home-directory))

 (defvar user-store-directory (expand-file-name "store" user-home-directory))

 (defvar user-shed-directory (expand-file-name "shed" user-home-directory))

 (defvar user-mail-directory (expand-file-name "mail" user-home-directory))

 (defvar user-media-directory (expand-file-name "media" user-home-directory))

 (defvar default-theme 'leuven-dark)

 (defvar company-source-directory (join-paths user-lab-directory "comp"))

 (defvar company-domain "compiler.company")

 (defvar company-name "The Compiler Company, LLC")

 (defvar company-vc-domain "vc.compiler.company")

 (defvar company-home "the.compiler.company")

 ;;; Theme

 (defun load-default-theme () (interactive) (load-theme default-theme))

 (add-hook 'after-init-hook #'load-default-theme)

 ;;; Packages

 (package-initialize)

 (with-eval-after-load 'package

   (setq package-archives

     '(("gnu" . "https://elpa.gnu.org/packages/")

       ("nongnu" . "https://elpa.nongnu.org/nongnu/")

       ("melpa" . "https://melpa.org/packages/"))

     use-package-always-ensure t

     use-package-expand-minimally t)

   (add-packages

    org-web-tools ;; web parsing

    citeproc ;; citations

    all-the-icons all-the-icons-dired all-the-icons-ibuffer ;; icons

    corfu orderless cape ;; completion

    slime ;; common lisp server

    slime-company

    which-key ;; key helper

    ;; langs

    rust-mode)

   (package-install-selected-packages t))

 ;;; Env

 (require 'exec-path-from-shell)

 (exec-path-from-shell-copy-env "SSH_AGENT_PID")

 (exec-path-from-shell-copy-env "SSH_AUTH_SOCK")

 (exec-path-from-shell-copy-env "PATH")

 (add-to-list 'exec-path (expand-file-name "~/.cargo/bin/"))

 (add-to-list 'exec-path (expand-file-name "~/.local/bin/"))

 (add-to-list 'exec-path "/bin/")

 (add-to-list 'exec-path "/usr/local/sbin/")

 ;;; Completions

 (use-package corfu

   :init (global-corfu-mode))

 (use-package cape

   ;; Bind dedicated completion commands

   ;; Alternative prefix keys: C-c p, M-p, M-+, ...

   :bind (("C-c p p" . completion-at-point) ;; capf

          ("C-c p t" . complete-tag)        ;; etags

          ("C-c p d" . cape-dabbrev)        ;; or dabbrev-completion

          ("C-c p h" . cape-history)

          ("C-c p f" . cape-file)

          ("C-c p k" . cape-keyword)

          ("C-c p s" . cape-elisp-symbol)

          ("C-c p e" . cape-elisp-block)

          ("C-c p a" . cape-abbrev)

          ("C-c p l" . cape-line)

          ("C-c p w" . cape-dict)

          ("C-c p :" . cape-emoji)

          ("C-c p \\" . cape-tex)

          ("C-c p _" . cape-tex)

          ("C-c p ^" . cape-tex)

          ("C-c p &" . cape-sgml)

          ("C-c p r" . cape-rfc1345))

   :init

   ;; Add to the global default value of `completion-at-point-functions' which is

   ;; used by `completion-at-point'.  The order of the functions matters, the

   ;; first function returning a result wins.  Note that the list of buffer-local

   ;; completion functions takes precedence over the global list.

   ;; (add-to-list 'completion-at-point-functions #'cape-dabbrev)

   ;; (add-to-list 'completion-at-point-functions #'cape-abbrev)

   ;; (add-to-list 'completion-at-point-functions #'cape-history)

   ;; (add-to-list 'completion-at-point-functions #'cape-keyword)

   ;; (add-to-list 'completion-at-point-functions #'cape-file)

   ;; (add-to-list 'completion-at-point-functions #'cape-line)

   ;; (add-to-list 'completion-at-point-functions #'cape-elisp-block)

   ;; (add-to-list 'completion-at-point-functions #'cape-tex)

   ;; (add-to-list 'completion-at-point-functions #'cape-sgml)

   ;; (add-to-list 'completion-at-point-functions #'cape-rfc1345)

   ;; (add-to-list 'completion-at-point-functions #'cape-dict)

   ;; (add-to-list 'completion-at-point-functions #'cape-elisp-symbol)

   ;; (add-to-list 'completion-at-point-functions #'cape-emoji)

   )

 (use-package orderless

   :custom

   (completion-styles '(orderless basic))

   (completion-category-overrides '((file (styles basic partial-completion)))))

 ;;; Desktop

 (setopt desktop-dirname (expand-file-name "sessions" user-emacs-directory))

 ;;; Multisession

 (setq multisession-storage 'sqlite)

 ;;; VC

 ;; use rhg, fallback to hg. see hgrc

 (if (file-exists-p "~/.local/bin/rhg")

     (setq hg-binary "~/.local/bin/rhg"))

 ;;; Dired

 (add-hook 'dired-mode-hook #'all-the-icons-dired-mode)

 (add-hook 'ibuffer-mode-hook #'all-the-icons-ibuffer-mode)

 ;;; Lisp

 (use-package lisp-mode

   :ensure nil

   :custom

   inferior-lisp-program "sbcl"

   scheme-program-name "gsi"

   guile-program "guile"

   cmulisp-program "lisp"

   scsh-program "scsh")

 (use-package slime

   :ensure t

   :config

   (setq slime-contribs '(slime-fancy slime-quicklisp))

   (put 'make-instance 'common-lisp-indent-function 1)

   (put 'reinitialize-instance 'common-lisp-indent-function 1)

   (defvar slime-toggle nil)

   (defun slime-toggle ()

     "toggle between lisp file and slime-repl"

     (interactive)

     (if (eq major-mode 'slime-repl-mode)

     (setq slime-toggle (pop-to-buffer (or slime-toggle (read-buffer "lisp file: "))))

       (progn

         (setq slime-toggle (current-buffer))

         (slime-repl))))

   (defun clouseau-inspect (string)

     "Inspect a lisp value with Clouseau. make sure to load clouseau

 with a custom core or in your init file before using this

 function: '(ql:quickload :clouseau)'."

     (interactive

      (list (slime-read-from-minibuffer

             "Inspect value (evaluated): "

             (slime-sexp-at-point))))

     (let ((inspector 'cl-user::*clouseau-inspector*))

       (slime-eval-async

           `(cl:progn

             (cl:defvar ,inspector nil)

             ;; (Re)start the inspector if necessary.

             (cl:unless (cl:and (clim:application-frame-p ,inspector)

                                (clim-internals::frame-process ,inspector))

                        (cl:setf ,inspector (cl:nth-value 1 (clouseau:inspect nil :new-process t))))

             ;; Tell the inspector to visualize the correct datum.

             (cl:setf (clouseau:root-object ,inspector :run-hook-p t)

                      (cl:eval (cl:read-from-string ,string)))

             ;; Return nothing.

             (cl:values)))))

   (define-key slime-prefix-map (kbd "i") 'clouseau-inspect))

 ;;; Rust

 (add-hook 'rust-mode-hook 'eglot-ensure)

 (setq rust-rustfmt-switches nil

       rust-indent-offset 2)

 (with-eval-after-load 'eglot

   (add-to-list 'eglot-server-programs '(rust-mode . ("rust-analyzer"))))

 ;;; Python

 (setq python-indent-offset 2)

 (add-hook 'python-mode-hook 'eglot-ensure)

 ;;; Bash

 (setq sh-basic-offset 2)

 ;;; Comments

 (defcustom prog-comment-keywords

   '("TODO" "REVIEW" "FIX" "HACK" "RESEARCH")

   "List of strings with comment keywords."

   :group 'default)

 (defcustom prog-comment-timestamp-format-concise "%F"

   "Specifier for date in `prog-comment-timestamp-keyword'.

 Refer to the doc string of `format-time-string' for the available

 options."

   :group 'default)

 (defcustom prog-comment-timestamp-format-verbose "%F %T %z"

   "Like `prog-comment-timestamp-format-concise', but longer."

   :group 'default)

 ;;;###autoload

 (defun prog-comment-dwim (arg)

   "Flexible, do-what-I-mean commenting.

 If region is active and ARG is either a numeric argument greater

 than one or a universal prefix (\\[universal-argument]), then

 apply `comment-kill' on all comments in the region.

 If the region is active and no ARG is supplied, or is equal to a

 numeric prefix of 1, then toggle the comment status of the region.

 Else toggle the comment status of the line at point.  With a

 numeric prefix ARG, do so for ARGth lines (negative prefix

 operates on the lines before point)."

   (interactive "p")

   (cond

    ((and (> arg 1) (use-region-p))

     (let* ((beg (region-beginning))

            (end (region-end))

            (num (count-lines beg end)))

       (save-excursion

         (goto-char beg)

         (comment-kill num))))

    ((use-region-p)

     (comment-or-uncomment-region (region-beginning) (region-end)))

    (t

     (save-excursion (comment-line (or arg 1))))))

 (defvar prog-comment--keyword-hist '()

   "Input history of selected comment keywords.")

 (defun prog-comment--keyword-prompt (keywords)

   "Prompt for candidate among KEYWORDS."

   (let ((def (car prog-comment--keyword-hist)))

     (completing-read

      (format "Select keyword [%s]: " def)

      keywords nil nil nil 'prog-comment--keyword-hist def)))

 ;;;###autoload

 (defun prog-comment-timestamp-keyword (keyword &optional verbose)

   "Add timestamped comment with KEYWORD.

 When called interactively, the list of possible keywords is that

 of `prog-comment-keywords', though it is possible to

 input arbitrary text.

 If point is at the beginning of the line or if line is empty (no

 characters at all or just indentation), the comment is started

 there in accordance with `comment-style'.  Any existing text

 after the point will be pushed to a new line and will not be

 turned into a comment.

 If point is anywhere else on the line, the comment is indented

 with `comment-indent'.

 The comment is always formatted as 'DELIMITER KEYWORD DATE:',

 with the date format being controlled by the variable

 `prog-comment-timestamp-format-concise'.

 With optional VERBOSE argument (such as a prefix argument

 `\\[universal-argument]'), use an alternative date format, as

 specified by `prog-comment-timestamp-format-verbose'."

   (interactive

    (list

     (prog-comment--keyword-prompt prog-comment-keywords)

     current-prefix-arg))

   (let* ((date (if verbose

                    comment-timestamp-format-verbose

          prog-comment-timestamp-format-concise))

      (string (format "%s %s: " keyword (format-time-string date)))

          (beg (point)))

     (cond

      ((or (eq beg (point-at-bol))

           (default-line-regexp-p 'empty))

       (let* ((maybe-newline (unless (default-line-regexp-p 'empty 1) "\n")))

         ;; NOTE 2021-07-24: we use this `insert' instead of

         ;; `comment-region' because of a yet-to-be-determined bug that

         ;; traps `undo' to the two states between the insertion of the

         ;; string and its transformation into a comment.

         (insert

          (concat comment-start

                  ;; NOTE 2021-07-24: See function `comment-add' for

                  ;; why we need this.

                  (make-string

                   (comment-add nil)

                   (string-to-char comment-start))

                  comment-padding

                  string

                  comment-end))

         (indent-region beg (point))

         (when maybe-newline

           (save-excursion (insert maybe-newline)))))

      (t

       (comment-indent t)

       (insert (concat " " string))))))

 (setq hexl-bits 8)

 (setq tab-width 4)

 ;;; Keyboard Macros

 (defun toggle-macro-recording ()

   (interactive)

   (if defining-kbd-macro

       (end-kbd-macro)

     (start-kbd-macro nil)))

 (defun play-macro-if-not-playing ()

   (interactive)

   (if defining-kbd-macro

       (end-kbd-macro)

     (call-last-kbd-macro)))

 ;;; Registers

 ;; - additional register vtypes: buffer

 (defun decrement-register (number register)

   "Subtract NUMBER from the contents of register REGISTER.

 Interactively, NUMBER is the prefix arg."

   (interactive "p\ncDecrement register: ")

   (increment-register (- number) register))

 (defun copy-register (a b)

   "Copy register A to B."

   (interactive

    (list (register-read-with-preview "From register: ")

      (register-read-with-preview "To register: ")))

   (set-register b (get-register a)))

 (defun buffer-to-register (register &optional delete)

   "Put current buffer in register - this would also work for

   just buffers, as switch-to-buffer can use both, but it

   facilitates for easier saving/restoring of registers."

   (interactive "cPut current buffername in register: \nP.")

   (set-register register (cons 'buffer (buffer-name (current-buffer)))))

 (defun file-to-register (register &optional delete)

   "This is better than put-buffer-in-register for file-buffers, because a closed

    file can be opened again, but does not work for no-file-buffers."

   (interactive "cPut the filename of current buffer in register: \nP")

   (set-register register (cons 'file (buffer-file-name (current-buffer)))))

 (defun file-query-to-register (register &optional delete)

   (interactive

    (list

     (register-read-with-preview "File query to register: ")))

   (set-register register (list 'file-query (buffer-file-name (current-buffer)) (point))))

 ;; additional register-val handlers

 ;; (cl-defmethod register-val-jump-to :around ((val cons) delete)

 ;;   (cond

 ;;    (t (cl-call-next-method val delete))))

 ;;; Outlines