;;; 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)

  project-mode-line t

  project-file-history-behavior 'relativize

  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

  ediff-floating-control-frame t

  register-use-preview nil

  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

 (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

    eglot-x ;; LSP extensions

    org-web-tools ;; web parsing

    citeproc ;; citations

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

    hide-mode-line ;; ui

    corfu orderless cape ;; completion

    slime ;; common lisp server

    bbdb

    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-history)

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

   ;; (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-category-overrides '((file (styles basic partial-completion)))))

 ;;; Desktop

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

 ;;; Multisession

 (setq multisession-storage 'sqlite)

 ;;; Kill Ring

 (kill-ring-deindent-mode)

 ;;; VC

 ;; use rhg, fallback to hg. see hgrc

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

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

 ;;; Dired

 ;;; Lisp

 (use-package lisp-mode

   :ensure nil

   :custom

   inferior-lisp-program "sbcl --dynamic-space-size=8G"

   scheme-program-name "gsi"

   guile-program "guile"

   cmulisp-program "lisp"

   scsh-program "scsh")

 (use-package slime

   :ensure t

   :config

   (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)

     (unless (slime-connected-p) (slime))

     (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)

   (setq slime-threads-update-interval 1))

 ;;; Eglot

 (with-eval-after-load 'eglot

   (unless (package-installed-p 'eglot-x)

     (package-vc-install '(eglot-x :url "https://vc.compiler.company/packy/eglot-x.git")))

   (require 'eglot-x)

   (add-to-list 'eglot-server-programs

                '((rust-ts-mode rust-mode) .

                  ("rust-analyzer" :initializationOptions (:check (:command "clippy")))))

   (eglot-x-setup))

 ;;; Rust

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

 (setq rust-rustfmt-switches nil

       rust-indent-offset 2)

 ;;; Python

 (setq python-indent-offset 2)

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

 ;;; Javascript

 (setq js-indent-level 2)

 ;;; 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)