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

  org-safe-remote-resources '("\\`https://cdn\\.compiler\\.company/org/clean\\.theme\\'")

  ;; tabs = bad (unless in makefile..)

  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)

  tempo-interactive t

  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

  which-key-mode t

  view-read-only t)

 ;;; Treesitter

 ;;(add-to-list 'treesit-extra-load-path "/usr/local/lib/")

 ;; (let ((grammar-dir "/usr/local/share/tree-sitter/"))

 ;;   (when (file-exists-p grammar-dir)

 ;;     (setq treesit-extra-load-path

 ;;           (append

 ;;            (flatten

 ;;             (mapcar

 ;;              (lambda (f)

 ;;                (unless (or (string= "." f) (string= ".." f))

 ;;                  (concat grammar-dir f)))

 ;;              (directory-files "/usr/local/share/tree-sitter")))

 ;;            treesit-extra-load-path))))

 ;;; Variables

 (defvar user-emacs-lib-directory (expand-file-name (join-paths user-emacs-directory "lib")))

 (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-mail-directory (expand-file-name "mail" user-home-directory))

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

 (defvar default-theme 'leuven-dark)

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

 (defvar company-org-directory (join-paths company-source-directory "org"))

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

 (defvar company-cdn-url "https://cdn.compiler.company")

 ;;; Theme

 (defun load-default-theme (&optional theme)

   (interactive)

   (when theme (setq default-theme theme))

   (load-theme 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/")))

   (setopt

    use-package-always-ensure t

    use-package-expand-minimally t)

   (add-packages

    eglot-x ;; LSP extensions

    org-web-tools ;; web parsing

    citeproc ;; citations

    htmlize ;; html export

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

    hide-mode-line) ;; ui

    ;; bbdb

   (package-install-selected-packages t))

 ;;; Env

 (require 'exec-path-from-shell)

 (exec-path-from-shell-copy-envs (list "SSH_AGENT_PID"

                                       "SSH_AUTH_SOCK"

                                       "PATH" 

                                       "CARGO_HOME"

                                       "CC"

                                       "LD"

                                       "LD_LIBRARY_PATH"

                                       "RUSTUP_HOME"

                                       "QUICKLISP_HOME"

                                       "DEV" "DEV_ID" "DEV_HOME"

                                       "WORKER" "WORKER_ID" "WORKER_HOME"

                                       "SBCL_HOME"

                                       "LISP_HOME"))

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

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

 (add-to-list 'exec-path "/usr/local/share/lisp/bin/")

 ;;; Completions

 (use-package cape :ensure t)

 (use-package orderless

   :ensure t

   :init

   (setq completion-styles '(orderless partial-completion basic)

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

                                         (eglot (styles orderless))

                                         (eglot-capf (styles orderless)))))

 (use-package corfu

   :ensure t

   :config

   (global-corfu-mode)

   (corfu-popupinfo-mode)

   (corfu-echo-mode)

   (dolist (c (list (cons "SPC" " ")

                  (cons "." ".")

                  (cons "," ",")

                  (cons ":" ":")

                  (cons ")" ")")

                  (cons "}" "}")

                  (cons "]" "]")))

   (define-key corfu-map (kbd (car c)) `(lambda ()

                                          (interactive)

                                          (corfu-insert)

                                          (insert ,(cdr c)))))

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

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

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

   (defun corfu-move-to-minibuffer ()

     (interactive)

     (pcase completion-in-region--data

       (`(,beg ,end ,table ,pred ,extras)

        (let ((completion-extra-properties extras)

              completion-cycle-threshold completion-cycling)

          (consult-completion-in-region beg end table pred)))))

   (keymap-set corfu-map "M-m" #'corfu-move-to-minibuffer)

   (add-to-list 'corfu-continue-commands #'corfu-move-to-minibuffer)

   (unless (package-installed-p 'corfu-terminal)

     (package-vc-install '(corfu-terminal :url "https://codeberg.org/akib/emacs-corfu-terminal.git")))

   (unless (display-graphic-p)

     (corfu-terminal-mode 1)))

 (use-package kind-icon

   :ensure t

   :after corfu

   ;:custom

   ; (kind-icon-blend-background t)

   ; (kind-icon-default-face 'corfu-default) ; only needed with blend-background

   :config

   (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))

 (use-package vertico

   :ensure t

   :config (vertico-mode)

   (keymap-set vertico-map "M-q" #'vertico-quick-insert)

   (keymap-set vertico-map "C-q" #'vertico-quick-exit))

 (use-package marginalia :ensure t

   :config (marginalia-mode))

 (use-package embark

   :ensure t)

 (use-package embark-consult :ensure t)

 (use-package consult :ensure t)

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

 ;;; Projects

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

          project-mode-line t

          project-file-history-behavior 'relativize)

 ;;; Tabs

 (add-hook 'tab-bar-mode-hook #'tab-bar-history-mode)

 ;;; Lisp

 (use-package slime

   :ensure t

   :init

   (setq slime-contribs '(slime-fancy

                          slime-quicklisp

                          slime-hyperdoc

                          ;; slime-listener-hooks

                          ;; slime-enclosing-context

                          ;; slime-media

                          ;; slime-mrepl

                          slime-sbcl-exts

                          slime-cape ;; ext

                          ;; slime-cl-indent

                          ;; slime-snapshot

                          slime-sprof

                          slime-tramp

                          ;; slime-typeout-frame

                          slime-xref-browser

                          ;; slime-highlight-edits

                          slime-asdf))

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

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

   (slime-setup)

   (defvar slime-toggle nil)

   (defun slime-toggle ()

     "toggle between lisp file and slime-repl"

     (interactive)

     (cond

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

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

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

       (if (slime-connected-p)

           (progn

             (setq slime-toggle (current-buffer))

             (slime-switch-to-output-buffer))

         (setq slime-toggle (current-buffer))

         (slime)))))

   ;; X11-only (mcclim requires clx)

   (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-common-lisp-style "core" "Core Common Lisp Indentation Style"

                             (:inherit "sbcl")

                             (:indentation

                              (defpkg (as defpackage))

                              (define-package (as defpackage))))

   ;; lisp font-lock defaults: https://www.n16f.net/blog/custom-font-lock-configuration-in-emacs/

   ;; (defface cl-character-face

   ;;   '((default :inherit font-lock-constant-face))

   ;;   "The face used to highlight Common Lisp character literals.")

   ;; (defface cl-standard-function-face

   ;;   '((default :inherit font-lock-keyword-face))

   ;;   "The face used to highlight standard Common Lisp function symbols.")

   ;; (defface cl-standard-value-face

   ;;   '((default :inherit font-lock-variable-name-face))

   ;;   "The face used to highlight standard Common Lisp value symbols.")

   ;; (defvar cl-font-lock-keywords

   ;;   (let* ((character-re (concat "#\\\\" lisp-mode-symbol-regexp "\\_>"))

   ;;          (function-re (concat "(" (regexp-opt cl-function-names t) "\\_>"))

   ;;          (value-re (regexp-opt cl-value-names 'symbols)))

   ;;     `((,character-re . 'cl-character-face)

   ;;       (,function-re

   ;;        (1 'cl-standard-function-face))

   ;;       (,value-re . 'cl-standard-value-face))))

   (setq common-lisp-style-default "core")

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

   (setq slime-threads-update-interval 1)

   (add-hook 'slime-mode-hook #'slime-cape-maybe-enable 100)

   (add-hook 'slime-repl-mode-hook #'slime-cape-maybe-enable 100))

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

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

   (with-eval-after-load '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)

 ;;; Graphviz

 (use-package graphviz-dot-mode

   :config

   (setq graphviz-dot-indent-width 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))