emacs/config.org

#+STARTUP: overview
#+TITLE: My Emacs
#+CREATOR: Laurens Miers
#+LANGUAGE: en

* Elpaca

** Core

#+begin_src emacs-lisp
(defvar elpaca-installer-version 0.7)
(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
(defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
(defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
(defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                              :ref nil :depth 1
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca--activate-package)))
(let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
       (build (expand-file-name "elpaca/" elpaca-builds-directory))
       (order (cdr elpaca-order))
       (default-directory repo))
  (add-to-list 'load-path (if (file-exists-p build) build repo))
  (unless (file-exists-p repo)
    (make-directory repo t)
    (when (< emacs-major-version 28) (require 'subr-x))
    (condition-case-unless-debug err
        (if-let ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                 ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
                                                 ,@(when-let ((depth (plist-get order :depth)))
                                                     (list (format "--depth=%d" depth) "--no-single-branch"))
                                                 ,(plist-get order :repo) ,repo))))
                 ((zerop (call-process "git" nil buffer t "checkout"
                                       (or (plist-get order :ref) "--"))))
                 (emacs (concat invocation-directory invocation-name))
                 ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                       "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                 ((require 'elpaca))
                 ((elpaca-generate-autoloads "elpaca" repo)))
            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
          (error "%s" (with-current-buffer buffer (buffer-string))))
      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
  (unless (require 'elpaca-autoloads nil t)
    (require 'elpaca)
    (elpaca-generate-autoloads "elpaca" repo)
    (load "./elpaca-autoloads")))
(add-hook 'after-init-hook #'elpaca-process-queues)
(elpaca `(,@elpaca-order))
#+end_src

** Use-package integration

#+begin_src emacs-lisp
;; Install use-package support
(elpaca elpaca-use-package
  ;; Enable use-package :ensure support for Elpaca.
  (elpaca-use-package-mode)
  )

;; wait to get elpaca use-package integration
(elpaca-wait)
#+end_src

* Built-in packages
** Eldoc

I got the following error message when loading eglot:
#+BEGIN_SRC
eglot                          failed               eldoc installed version (1 13 0) lower than min required 1.14.0                  00.239351
#+END_SRC

So install the eldoc package to be sure we have the latest version.
But after installing it, we get a new warning:

#+BEGIN_SRC
⛔ Warning (emacs): eldoc loaded before Elpaca activation
#+END_SRC

This seemed tricker than expected, but found a solution in the github issues of elpaca:
https://github.com/progfolio/elpaca/issues/236

#+BEGIN_SRC emacs-lisp
(use-package eldoc
  :preface
  ;; avoid loading of built-in eldoc, see https://github.com/progfolio/elpaca/issues/236#issuecomment-1879838229
  (unload-feature 'eldoc t)
  (setq custom-delayed-init-variables '())
  (defvar global-eldoc-mode nil)
  :demand t
  :config
  (global-eldoc-mode))

#+END_SRC

** Jsonrpc
After eldoc was taken care of, a new error was reported:
#+BEGIN_SRC
eglot                          failed               jsonrpc installed version (1 0 16) lower than min required 1.0.24                00.280828
#+END_SRC

So let's install the latest one:
#+BEGIN_SRC emacs-lisp
(use-package jsonrpc)
#+END_SRC

** Wait for loading updated packages

Wait until updated built-in packages are fully loaded:
#+BEGIN_SRC emacs-lisp
(elpaca-wait)
#+END_SRC

* General config

** Bell

The audible bell is annoying AF.

#+BEGIN_SRC emacs-lisp
(setq visible-bell 1)
#+END_SRC

** Enable column numbers

#+BEGIN_SRC emacs-lisp
(setq column-number-mode 1)
#+END_SRC

** Delete trailing whitespaces

#+BEGIN_SRC emacs-lisp
(add-hook 'before-save-hook 'delete-trailing-whitespace)
#+END_SRC

** Save history and recent files

#+begin_src emacs-lisp
;; The built-in `savehist-mode' saves minibuffer histories.  Vertico
;; can then use that information to put recently selected options at
;; the top.
;;
;; Further reading: https://protesilaos.com/emacs/dotemacs#h:25765797-27a5-431e-8aa4-cc890a6a913a
(savehist-mode 1)

;; The built-in `recentf-mode' keeps track of recently visited files.
;; You can then access those through the `consult-buffer' interface or
;; with `recentf-open'/`recentf-open-files'.
;;
;; I do not use this facility, because the files I care about are
;; either in projects or are bookmarked.
(recentf-mode 1)
#+end_src

** Backups

#+BEGIN_SRC emacs-lisp
(defvar myrmi-backup-directory (concat user-emacs-directory "backups"))
(if (not (file-exists-p myrmi-backup-directory))
    (make-directory myrmi-backup-directory t)
  )
(setq backup-directory-alist `(("." . ,myrmi-backup-directory)))
(setq make-backup-files t
      backup-by-copying t
      version-control t
      delete-old-versions t
      delete-by-moving-to-trash t
      kept-old-versions 6
      kept-new-versions 9
      auto-save-default t
      auto-save-timeout 20
      auto-save-interval 200
  )
#+END_SRC

** Yes-or-no

Because I'm lazy, important yes-or-no questions can be answered with y-or-n:
#+begin_src emacs-lisp
(defalias 'yes-or-no-p 'y-or-n-p)
#+end_src

** Switch windows

#+begin_src emacs-lisp
(global-set-key (kbd "M-o") 'other-window)
#+end_src

** Maximize at startup

More info : https://www.emacswiki.org/emacs/FullScreen

#+begin_src emacs-lisp
(push '(fullscreen . maximized) default-frame-alist)
#+end_src

** ibuffer

Use list-buffers bigger brother.
#+begin_src emacs-lisp
(global-set-key [remap list-buffers] 'ibuffer)
#+end_src

** Mark

#+begin_src emacs-lisp
(global-set-key (kbd "M-SPC") 'mark-word)
#+end_src

** Isearch

Display number of matches:
#+begin_src emacs-lisp
(setq-default isearch-lazy-count t)
#+end_src

Reference that might be interesting for later:
https://endlessparentheses.com/leave-the-cursor-at-start-of-match-after-isearch.html

** Abbrev

#+begin_src emacs-lisp
(global-set-key [remap dabbrev-expand] 'hippie-expand)
#+end_src

** Zap

#+begin_src emacs-lisp
(global-set-key (kbd "M-S-z") 'zap-up-to-char)
#+end_src

** Spell checking

Look into customizing the 'ispell' group.

#+begin_src emacs-lisp
(add-hook 'prog-mode-hook 'flyspell-prog-mode)
#+end_src

** Delete selection mode

#+BEGIN_SRC emacs-lisp
(delete-selection-mode t)
#+END_SRC

** Enable disabled commands

Some commands are disabled to protect the user.
Narrow-region/page is a really handy feature, enable it:

#+BEGIN_SRC emacs-lisp
(put 'narrow-to-page 'disabled nil)
(put 'narrow-to-region 'disabled nil)
#+END_SRC

** Use-package

*** Always ensure

#+BEGIN_SRC emacs-lisp
(require 'use-package-ensure)
(setq use-package-always-ensure t)
#+END_SRC

** Adaptive cursor width

Make cursor the width of the character it is under f.e. full width of a tab.

#+BEGIN_SRC emacs-lisp
(setq x-stretch-cursor t)
#+END_SRC

** Enable auto-revert

#+BEGIN_SRC emacs-lisp
(setq global-auto-revert-mode 1)
#+END_SRC

* Resize-mode

Minor-mode to easily resize frames (works with EXWM (firefox, ...)).
Courtesy goes to kuanyui (https://gist.github.com/kuanyui/65a408d393871048771c):

#+BEGIN_SRC emacs-lisp
;;; resize-frame.el --- A minor mode to resize frames easily.  -*- lexical-binding: t; -*-

;; Copyright (C) 2014  kuanyui

;; Author: kuanyui <azazabc123@gmail.com>
;; Keywords: frames, tools, convenience
;; License: WTFPL 1.0

;;; Commentary:

;; Press "ESC `" and use arrow-keys or i/j/k/l to adjust frames. press any key to done.

;;; Code:

(defvar resize-frame-map
  (let ((map (make-keymap)))
    (define-key map (kbd "<up>") 'enlarge-window)
    (define-key map (kbd "<down>") 'shrink-window)
    (define-key map (kbd "<right>") 'enlarge-window-horizontally)
    (define-key map (kbd "<left>") 'shrink-window-horizontally)
    (set-char-table-range (nth 1 map) t 'resize-frame-done)
    (define-key map (kbd "C-p") 'enlarge-window)
    (define-key map (kbd "C-n") 'shrink-window)
    (define-key map (kbd "C-f") 'enlarge-window-horizontally)
    (define-key map (kbd "C-b") 'shrink-window-horizontally)
    map))

(define-minor-mode resize-frame
  "A simple minor mode to resize-frame.
C-c C-c to apply."
  ;; The initial value.
  :init-value nil
  ;; The indicator for the mode line.
  :lighter " ResizeFrame"
  ;; The minor mode bindings.
  :keymap resize-frame-map
  :global t
  (if (<= (length (window-list)) 1)
      (progn (setq resize-frame nil)
             (message "Only root frame exists, abort."))
      (message "Use arrow-keys or i/j/k/l to adjust frames.")))

(defun resize-frame-done ()
  (interactive)
  (setq resize-frame nil)
  (message "Done."))

(global-set-key (kbd "C-x C-r") 'resize-frame)
#+END_SRC

* Completion
** Minibuffer

#+BEGIN_SRC emacs-lisp
;; Enable vertico
(use-package vertico
  ;; :custom
  ;; (vertico-scroll-margin 0) ;; Different scroll margin
  ;; (vertico-count 20) ;; Show more candidates
  ;; (vertico-resize t) ;; Grow and shrink the Vertico minibuffer
  ;; (vertico-cycle t) ;; Enable cycling for `vertico-next/previous'
  :init
  (vertico-mode))
#+END_SRC

** Consult

#+BEGIN_SRC emacs-lisp
(use-package consult
  ;; Replace bindings. Lazily loaded by `use-package'.
  :bind (;; C-c bindings in `mode-specific-map'
         ;; ("C-c M-x" . consult-mode-command)
         ;; ("C-c h" . consult-history)
         ;; ("C-c k" . consult-kmacro)
         ;; ("C-c m" . consult-man)
         ;; ("C-c i" . consult-info)
         ([remap Info-search] . consult-info)
         ;; C-x bindings in `ctl-x-map'
         ("C-x M-:" . consult-complex-command)     ;; orig. repeat-complex-command
         ("C-x b" . consult-buffer)                ;; orig. switch-to-buffer
         ("C-x 4 b" . consult-buffer-other-window) ;; orig. switch-to-buffer-other-window
         ("C-x 5 b" . consult-buffer-other-frame)  ;; orig. switch-to-buffer-other-frame
         ("C-x t b" . consult-buffer-other-tab)    ;; orig. switch-to-buffer-other-tab
         ("C-x r b" . consult-bookmark)            ;; orig. bookmark-jump
         ("C-x p b" . consult-project-buffer)      ;; orig. project-switch-to-buffer
         ;; Custom M-# bindings for fast register access
         ;; ("M-#" . consult-register-load)
         ("M-'" . consult-register-store)          ;; orig. abbrev-prefix-mark (unrelated)
         ;; ("C-M-#" . consult-register)
         ;; Other custom bindings
         ("M-y" . consult-yank-pop)                ;; orig. yank-pop
         ;; M-g bindings in `goto-map'
         ("M-g e" . consult-compile-error)
         ("M-g f" . consult-flymake)               ;; Alternative: consult-flycheck
         ("M-g g" . consult-goto-line)             ;; orig. goto-line
         ("M-g M-g" . consult-goto-line)           ;; orig. goto-line
         ;; ("M-g o" . consult-outline)               ;; Alternative: consult-org-heading
         ;; ("M-g m" . consult-mark)
         ;; ("M-g k" . consult-global-mark)
         ("M-i" . consult-imenu)
         ("M-I" . consult-imenu-multi)
         ;; M-s bindings in `search-map'
         ("M-s d" . consult-find)                  ;; Alternative: consult-fd
         ;; ("M-s c" . consult-locate)
         ("M-s g" . consult-grep)
         ;; ("M-s G" . consult-git-grep)
         ;; ("M-s r" . consult-ripgrep)
         ("M-s l" . consult-line)
         ;; ("M-s L" . consult-line-multi)
         ;; ("M-s k" . consult-keep-lines)
         ;; ("M-s u" . consult-focus-lines)
         ;; Isearch integration
         ("M-s e" . consult-isearch-history)
         :map isearch-mode-map
         ("M-e" . consult-isearch-history)         ;; orig. isearch-edit-string
         ("M-s e" . consult-isearch-history)       ;; orig. isearch-edit-string
         ("M-s l" . consult-line)                  ;; needed by consult-line to detect isearch
         ("M-s L" . consult-line-multi)            ;; needed by consult-line to detect isearch
         ;; Minibuffer history
         :map minibuffer-local-map
         ("M-s" . consult-history)                 ;; orig. next-matching-history-element
         ("M-r" . consult-history)                 ;; orig. previous-matching-history-element
         )

  ;; Enable automatic preview at point in the *Completions* buffer. This is
  ;; relevant when you use the default completion UI.
  :hook (completion-list-mode . consult-preview-at-point-mode)

  ;; The :init configuration is always executed (Not lazy)
  :init

  ;; Optionally configure the register formatting. This improves the register
  ;; preview for `consult-register', `consult-register-load',
  ;; `consult-register-store' and the Emacs built-ins.
  ;; (setq register-preview-delay 0.5
        ;; register-preview-function #'consult-register-format)

  ;; Optionally tweak the register preview window.
  ;; This adds thin lines, sorting and hides the mode line of the window.
  ;; (advice-add #'register-preview :override #'consult-register-window)

  ;; Use Consult to select xref locations with preview
  (setq xref-show-xrefs-function #'consult-xref
        xref-show-definitions-function #'consult-xref)

  ;; Configure other variables and modes in the :config section,
  ;; after lazily loading the package.
  ;; :config

  ;; Optionally configure preview. The default value
  ;; is 'any, such that any key triggers the preview.
  ;; (setq consult-preview-key 'any)
  ;; (setq consult-preview-key "M-.")
  ;; (setq consult-preview-key '("S-<down>" "S-<up>"))
  ;; For some commands and buffer sources it is useful to configure the
  ;; :preview-key on a per-command basis using the `consult-customize' macro.
  ;; (consult-customize
   ;; consult-theme :preview-key '(:debounce 0.2 any)
   ;; consult-ripgrep consult-git-grep consult-grep
   ;; consult-bookmark consult-recent-file consult-xref
   ;; consult--source-bookmark consult--source-file-register
   ;; consult--source-recent-file consult--source-project-recent-file
   ;; :preview-key "M-."
   ;; :preview-key '(:debounce 0.4 any))

  ;; Optionally configure the narrowing key.
  ;; Both < and C-+ work reasonably well.
  ;; (setq consult-narrow-key "<") ;; "C-+"

  ;; Optionally make narrowing help available in the minibuffer.
  ;; You may want to use `embark-prefix-help-command' or which-key instead.
  ;; (keymap-set consult-narrow-map (concat consult-narrow-key " ?") #'consult-narrow-help)
)
#+END_SRC

** In-buffer completion

*** Consult

#+BEGIN_SRC emacs-lisp
(setq completion-in-region-function
      (lambda (&rest args)
        (apply (if vertico-mode
                   #'consult-completion-in-region
                 #'completion--in-region)
               args)))
#+END_SRC

*** Corfu

#+BEGIN_SRC emacs-lisp
(use-package corfu
  ;; Optional customizations
  :bind (:map corfu-map ("<tab>" . corfu-complete))
  :config
  (setq tab-always-indent 'complete)
  :custom
  (corfu-cycle t)                ;; Enable cycling for `corfu-next/previous'
  (corfu-auto t)                 ;; Enable auto completion
  ;; (corfu-separator ?\s)          ;; Orderless field separator
  ;; (corfu-quit-at-boundary nil)   ;; Never quit at completion boundary
  ;; (corfu-quit-no-match nil)      ;; Never quit, even if there is no match
  ;; (corfu-preview-current nil)    ;; Disable current candidate preview
  ;; (corfu-preselect 'prompt)      ;; Preselect the prompt
  ;; (corfu-on-exact-match nil)     ;; Configure handling of exact matches
  ;; (corfu-scroll-margin 5)        ;; Use scroll margin

  ;; Enable Corfu only for certain modes. See also `global-corfu-modes'.
  ;; :hook ((prog-mode . corfu-mode)
  ;;        (shell-mode . corfu-mode)
  ;;        (eshell-mode . corfu-mode))

  ;; Recommended: Enable Corfu globally.  This is recommended since Dabbrev can
  ;; be used globally (M-/).  See also the customization variable
  ;; `global-corfu-modes' to exclude certain modes.
  :init
  (global-corfu-mode))
#+end_src

*** Company-mode

#+BEGIN_SRC
(use-package company
  :config
  (define-key prog-mode-map
              (kbd "TAB")
              #'company-indent-or-complete-common)
  :init
  (global-company-mode)
  )
#+END_SRC

** Orderless

#+begin_src emacs-lisp
(use-package orderless
  :demand t
  :custom
  (completion-styles '(orderless basic))
  ;;    (gnus-completion-styles '(orderless substring basic))
  ;;    (completion-category-overrides '((file (styles basic partial-completion))))

;; Below not necessary if using vertico
;;  (completion-category-overrides '(
;;                                   (command (styles orderless basic partial-completion))
;;                                   (file (styles orderless basic partial-completion))
;;;;                                   (buffer (styles orderless basic))
;;                                   (variable (styles orderless basic))
;;                                   (symbol (styles orderless basic))
;;                                   (consult-location (styles orderless))
;;                                   (consult-multi (styles orderless))
;;                                   )
;;                                 )
)
#+end_src

** Marginalia

#+begin_src emacs-lisp
;; Enable rich annotations using the Marginalia package
(use-package marginalia
  ;; Bind `marginalia-cycle' locally in the minibuffer.  To make the binding
  ;; available in the *Completions* buffer, add it to the
  ;; `completion-list-mode-map'.
  :bind (:map minibuffer-local-map
           ("M-A" . marginalia-cycle))

  ;; The :init section is always executed.
  :init
  ;; Marginalia must be activated in the :init section of use-package such that
  ;; the mode gets enabled right away. Note that this forces loading the
  ;; package.
  (marginalia-mode))
#+end_src

* Dired

** Dired-x

#+begin_src emacs-lisp
(with-eval-after-load 'dired
  (require 'dired-x)
  ;; Set dired-x global variables here.  For example:
  ;; (setq dired-x-hands-off-my-keys nil)
  )

(add-hook 'dired-mode-hook
          (lambda ()
            ;; Set dired-x buffer-local variables here.  For example:
            ;; (dired-omit-mode 1)
            ))
#+end_src

** Guess target directory

I currently prefer to have two dired windows open in the same frame.
Instruct dired to 'Prefer next windows on the same frame' when renaming/copying files.

#+BEGIN_SRC emacs-lisp
(setq dired-dwim-target 'dired-dwim-target-next)
#+END_SRC

* Whole-line-or-region

Source:
https://github.com/purcell/whole-line-or-region

Operate on the current line if no region is active.

#+begin_src emacs-lisp
(use-package whole-line-or-region

    :config
        (whole-line-or-region-global-mode 1)
)
#+end_src

* Terminal
** Eshell
*** Smart mode

Plan 9 smart terminal features, for more info:
https://www.masteringemacs.org/article/complete-guide-mastering-eshell

#+BEGIN_SRC emacs-lisp
(require 'eshell)
(require 'em-smart)
(setq eshell-where-to-jump 'begin)
(setq eshell-review-quick-commands nil)
(setq eshell-smart-space-goes-to-end t)

(add-hook 'eshell-mode-hook 'eshell-smart-initialize)
#+END_SRC

** Toggle between char- and line-mode

Courtesy goes to https://joelmccracken.github.io/entries/switching-between-term-mode-and-line-mode-in-emacs-term/

#+BEGIN_SRC emacs-lisp
(require 'term)

(defun jnm/term-toggle-mode ()
  "Toggles term between line mode and char mode"
  (interactive)
  (if (term-in-line-mode)
      (term-char-mode)
    (term-line-mode)))

(define-key term-mode-map (kbd "C-c C-j") 'jnm/term-toggle-mode)
(define-key term-mode-map (kbd "C-c C-k") 'jnm/term-toggle-mode)

(define-key term-raw-map (kbd "C-c C-j") 'jnm/term-toggle-mode)
(define-key term-raw-map (kbd "C-c C-k") 'jnm/term-toggle-mode)
#+END_SRC

For the keybindings, we have to defien them in both raw and line mode. From the help page of term mode:
    If you define custom keybindings, make sure to assign them to the
    correct keymap (or to both): use ‘term-raw-map’ in raw mode and
    ‘term-mode-map’ in line mode.

* Theme

#+BEGIN_SRC emacs-lisp
(use-package monokai-theme

  :init
    (load-theme 'monokai t)
)
#+END_SRC

* Dashboard

#+begin_src emacs-lisp
(use-package dashboard
  :config
  (add-hook 'elpaca-after-init-hook #'dashboard-insert-startupify-lists)
  (add-hook 'elpaca-after-init-hook #'dashboard-initialize)
  (dashboard-setup-startup-hook))
#+end_src

* Hydra

Install and wait for hydra to be available since we are using it in this init.el :
#+begin_src emacs-lisp
(use-package hydra
  :ensure (:wait t)
  )
#+end_src

** Text zoom

#+begin_src emacs-lisp
(defhydra hydra-zoom (global-map "<f1>")
  "zoom"
  ("g" text-scale-increase "in")
  ("l" text-scale-decrease "out")
)
#+end_src

* Zygospore

Revert =C-x 1= by pressing =C-x 1= again:
[[https://github.com/louiskottmann/zygospore.el]]

FYI: At one point, used this together with sr-speedbar. They did not play well together...

#+BEGIN_SRC emacs-lisp
(use-package zygospore
  :config
    (global-set-key (kbd "C-x 1") 'zygospore-toggle-delete-other-windows)
)
#+END_SRC

* Iedit

Highlight occurences of symbol and replace them simultanously.
Shortkey: =C-;=

https://github.com/victorhge/iedit

#+BEGIN_SRC emacs-lisp
(use-package iedit)
#+END_SRC

* Programming

** Angry faces

#+BEGIN_SRC emacs-lisp
(defface highlight-angry-faces
  '(
    (default :background "Yellow" :foreground "Red")
    )
  "Angry faces highlighting."
  :group 'basic-faces
)

(mapc (lambda (mode)
        (font-lock-add-keywords
         mode
         '(
           ("\\<\\(FIXME\\)" 1 'highlight-angry-faces t)
           ("\\<\\(TODO\\)" 1 'highlight-angry-faces t)
           )))
      '(text-mode emacs-lisp-mode rust-mode zig-mode c-ts-mode c-mode prog-mode)
)
#+END_SRC

** Electric pair
#+BEGIN_SRC emacs-lisp
(add-hook 'prog-mode-hook 'electric-pair-mode)
#+END_SRC

** Eglot

#+BEGIN_SRC emacs-lisp
  (use-package eglot)

  (setq eglot-stay-out-of '(xref))
  (add-hook 'prog-mode-hook 'eglot-ensure)
  (add-hook 'eglot-managed-mode-hook (lambda ()
				       (if (eglot-managed-p)
					   (add-hook 'xref-backend-functions 'eglot-xref-backend)
					 (remove-hook 'xref-backend-functions 'eglot-xref-backend)
					   )))
#+END_SRC

** Markdown-mode

#+BEGIN_SRC emacs-lisp
(use-package markdown-mode)

#+END_SRC

** Yasnippet

#+BEGIN_SRC emacs-lisp
(use-package yasnippet
  :hook
  (prog-mode . yas-minor-mode)
  (org-mode . yas-minor-mode)
  (text-mode . yas-minor-mode)
  :config
    (yas-reload-all)
)
#+END_SRC

** Magit

*** Transient

Magit depends on this and it seems it's not installed as a dependency, so install it explicitly.

#+BEGIN_SRC emacs-lisp
(use-package transient
  :ensure (:wait t)
)
#+END_SRC

*** Core

#+BEGIN_SRC emacs-lisp
(use-package magit
:ensure (:wait t)
)

#+END_SRC

**** Extra commands

***** Update all submodules

#+BEGIN_SRC emacs-lisp
(transient-define-suffix magit-submodule-update-all ()
 "Update all submodules"
 :description "Update All     git submodule update --init --recursive"
 (interactive)
 (magit-with-toplevel
   (magit-run-git-async "submodule" "update" "--force")))

(transient-append-suffix 'magit-submodule "f"
  '("U" magit-submodule-update-all))
#+END_SRC

** Dumb-jump

#+BEGIN_SRC emacs-lisp
  (use-package dumb-jump
    :init
    (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
  )
#+END_SRC

** C-programming

*** Tree-sitter

#+BEGIN_SRC emacs-lisp
(add-to-list 'major-mode-remap-alist '(c-mode . c-ts-mode))
#+END_SRC

** Compilation

*** Goto end of buffer on completion

Compilation output is almost always bigger than a normal buffer.
Move to the end if the compilation finishes.

#+BEGIN_SRC emacs-lisp
(defun goto-end-compilation-buffer (comp-buffer msg)
  (goto-char (point-max))
  )

(add-hook 'compilation-finish-functions #'goto-end-compilation-buffer)
#+END_SRC

** Rust

#+BEGIN_SRC emacs-lisp
(use-package rust-mode
  :init
  (setq rust-mode-treesitter-derive t))
#+END_SRC

** Zig

#+BEGIN_SRC emacs-lisp
(use-package zig-mode)
#+END_SRC

** Python

#+BEGIN_SRC emacs-lisp
(use-package python-mode)
#+END_SRC

* Multiple cursors

#+BEGIN_SRC emacs-lisp
(use-package multiple-cursors
  :bind
    ("C-x r a" . mc/edit-beginnings-of-lines)
    ("C-x r e" . mc/edit-ends-of-lines)
    ("C->" . mc/mark-next-like-this)
    ("C-<" . mc/mark-previous-like-this)
    ("C-c C->" . mc/mark-all-like-this)
)
#+END_SRC

* Volatile highlights

Show/highlight changes when doing undo/yanks/kills/...

https://github.com/k-talo/volatile-highlights.el

#+BEGIN_SRC emacs-lisp
(use-package volatile-highlights
  :config
    (volatile-highlights-mode t)
)
#+END_SRC

* Comment-dwim-2

Replacement for built-in =comment-dwim=, more comment features.

https://github.com/remyferre/comment-dwim-2

#+BEGIN_SRC emacs-lisp
(use-package comment-dwim-2
    :config
      (global-set-key (kbd "M-;") 'comment-dwim-2)
)
#+END_SRC

* Projectile

#+BEGIN_SRC emacs-lisp
(use-package projectile
  :config
    (setq projectile-enable-caching t)
    (define-key projectile-mode-map (kbd "C-x p") 'projectile-command-map)
    (projectile-mode +1)
    (require 'project)
    (add-hook 'project-find-functions #'project-projectile)
)
#+END_SRC

* Org

** General config
*** Super/Sub-scripts

Use ={}= for subscripting:

https://orgmode.org/manual/Subscripts-and-superscripts.html

#+BEGIN_SRC emacs-lisp
(setq org-use-sub-superscripts '{})
#+END_SRC

*** Indentation

Preserve indentation in SRC blocks

#+BEGIN_SRC emacs-lisp
(setq org-src-preserve-indentation t)
#+END_SRC

** Org-todo

*** Mark parent entry as DONE when children are DONE

#+BEGIN_SRC emacs-lisp
(defun org-summary-todo (n-done n-not-done)
  "Switch entry to DONE when all subentries are done, to TODO otherwise."
  (let (org-log-done org-todo-log-states)   ; turn off logging
    (org-todo (if (= n-not-done 0) "DONE" "TODO"))))

(add-hook 'org-after-todo-statistics-hook #'org-summary-todo)
#+END_SRC

** Org bullets

#+BEGIN_SRC emacs-lisp
(use-package org-bullets
  :config
    (add-hook 'org-mode-hook (lambda () (org-bullets-mode))))
#+END_SRC

** Org Roam

#+BEGIN_SRC emacs-lisp
(use-package org-roam
  :custom
  (org-roam-directory "~/projects/notes")
  (org-roam-completion-everywhere t)
  :config
  (org-roam-setup)
  (setq org-roam-node-display-template (concat "${title:*} " (propertize "${tags}" 'face 'org-tag)))
  (org-roam-db-autosync-mode)
  ;; Add todo lists to org-agenda
  (custom-set-variables '(org-agenda-files (directory-files-recursively org-roam-directory "todo\\.org$")))
)
#+END_SRC

*** UI

#+BEGIN_SRC emacs-lisp
(use-package org-roam-ui
  :ensure
    (:host github :repo "org-roam/org-roam-ui" :branch "main" :files ("*.el" "out"))
    :after org-roam
;;         normally we'd recommend hooking orui after org-roam, but since org-roam does not have
;;         a hookable mode anymore, you're advised to pick something yourself
;;         if you don't care about startup time, use
;;  :hook (after-init . org-roam-ui-mode)
    :config
    (setq org-roam-ui-sync-theme t
          org-roam-ui-follow t
          org-roam-ui-update-on-save t
          org-roam-ui-open-on-start t)
    ;; Start UI
    ;; (org-roam-ui-mode)
    )
#+END_SRC

*** Consult

#+BEGIN_SRC emacs-lisp
(use-package consult-org-roam
   :ensure t
   :after org-roam
   :init
   (require 'consult-org-roam)
   ;; Activate the minor mode
   (consult-org-roam-mode 1)
   ;; :custom
   ;; Use `ripgrep' for searching with `consult-org-roam-search'
   ;; (consult-org-roam-grep-func #'consult-ripgrep)

   ;; Configure a custom narrow key for `consult-buffer', default is 'n', this sets it to 'r'
   ;; (consult-org-roam-buffer-narrow-key ?r)

   ;; Display org-roam buffers right after non-org-roam buffers
   ;; in consult-buffer (and not down at the bottom)
   ;; (consult-org-roam-buffer-after-buffers t)
   :config
   ;; Eventually suppress previewing for certain functions
   (consult-customize
    consult-org-roam-forward-links
    :preview-key "M-.")
   :bind
   ;; Define some convenient keybindings as an addition
   ("C-c n f" . consult-org-roam-file-find)
   ("C-c n b" . consult-org-roam-backlinks)
   ("C-c n B" . consult-org-roam-backlinks-recursive)
   ("C-c n l" . consult-org-roam-forward-links)
   ("C-c n s" . consult-org-roam-search)
   ("C-c n d" . org-roam-dailies-goto-today)
   )
#+END_SRC

* Elisp

** Add demos to describe-function

#+BEGIN_SRC emacs-lisp
(use-package elisp-demos
  :config
  (advice-add 'describe-function-1 :after #'elisp-demos-advice-describe-function-1)
  )
#+END_SRC

* Custom

** Org-roam

Inspired by https://github.com/org-roam/org-roam/wiki/User-contributed-Tricks#filter-by-a-tag .

#+BEGIN_SRC emacs-lisp
(defun myrmi/org-roam-node-find-tag-filter ()
  "Select a single tag from list and filter `org-roam-node' by it."
  (interactive)
  (let ((tag (car (completing-read-multiple "Tag: "
                                            (org-roam-tag-completions)))))
    (org-roam-node-find nil nil
                        (lambda (node)
                          (member tag
                                  (org-roam-node-tags node))))))
#+END_SRC

** Sudo current buffer

#+BEGIN_SRC emacs-lisp
(defun myrmi/sudo-current-buffer ()
  "Use TRAMP to `sudo' the current buffer."
  (interactive)
  (when buffer-file-name
    (find-alternate-file
      (concat "/sudo:root@localhost:"
        buffer-file-name)
    )
  )
)
#+END_SRC

** Save symbol at point

#+BEGIN_SRC emacs-lisp
(defun myrmi/save-symbol-at-point ()
  "Make symbol at point the latest kill in the kill ring."
  (interactive)
  (let ((symbol (thing-at-point 'symbol)))
    (when symbol (kill-new symbol))))

(global-set-key (kbd "C-M-w") 'myrmi/save-symbol-at-point)
#+END_SRC

** Ceedling

#+BEGIN_SRC emacs-lisp
(defvar ceedling-project-file-name "project.yml")
(defvar ceedling-cmd "ceedling")
(defvar ceedling-project-root ".")

(defun myrmi/run-ceedling-tests (&optional file-name)
  (interactive)
  (let* (
          (file-path (or file-name buffer-file-name))
          (root-path (or (locate-dominating-file file-path ceedling-project-file-name) ceedling-project-root))
        )
    (compile
     (concat "cd " root-path " && " ceedling-cmd)
     )
    )
  )
#+END_SRC

** Set path to shell path

#+BEGIN_SRC emacs-lisp
(defun set-exec-path-from-shell-PATH ()
  (let ((path-from-shell
	   (replace-regexp-in-string "[[:space:]\n]*$" ""
	  (shell-command-to-string "$SHELL -l -c 'echo $PATH'"))))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))

(set-exec-path-from-shell-PATH)
#+END_SRC

** Reload dir-locals.el

#+BEGIN_SRC emacs-lisp
(defun myrmi/reload-dir-locals-for-current-buffer ()
  "Reload dir locals for the current buffer"
  (interactive)
  (let ((enable-local-variables :all))
    (hack-dir-local-variables-non-file-buffer)))

(defun myrmi/reload-dir-locals-for-all-buffers-in-this-directory ()
  "For every buffer with the same `default-directory` as the
   current buffer, reload dir-locals."
  (interactive)
  (let ((dir default-directory))
    (dolist (buffer (buffer-list))
      (with-current-buffer buffer
        (when (equal default-directory dir)
          (myrmi/reload-dir-locals-for-current-buffer))))))
#+END_SRC

** Visit/reload config

These snippets assume my-config-file variable is set outside this configuration.
This should normally be done by the init.el to load this configuration.

#+BEGIN_SRC emacs-lisp
(defun myrmi/visit-config ()
  "Reloads ~/.emacs.d/config.org at runtime"
  (interactive)
  (find-file my-config-file))

(defun myrmi/reload-config ()
  "Reloads ~/.emacs.d/config.org at runtime"
  (interactive)
  (org-babel-load-file my-config-file))
#+END_SRC

** Tips and Tricks

*** Cheat-sheet

| Key                   | Explanation                                               |
|-----------------------+-----------------------------------------------------------|
| C-h k <key-sequence>  | Lookup key sequencesmartparens wrapping                   |
| C-q <key>             | Insert <key> quoted/explicitly. F.e. to insert a tab, ... |
| M-x untabify/tabify   | Convert to spaces/tabs                                    |
| M-x describe-bindings | List all mapped keys/commands                             |
| M-q                   | Fill paragraph                                            |

** Minibuffer

*** Close minibuffer when pressing C-g

'Inspired' by https://protesilaos.com/codelog/2024-11-28-basic-emacs-configuration/#h:1e4fde73-a2a2-4dc5-82ad-02cf3884ece6 .
#+BEGIN_SRC emacs-lisp
(defun myrmi/keyboard-quit-dwim ()
  "Do-What-I-Mean behaviour for a general `keyboard-quit'.

The generic `keyboard-quit' does not do the expected thing when
the minibuffer is open.  Whereas we want it to close the
minibuffer, even without explicitly focusing it.

The DWIM behaviour of this command is as follows:

- When the region is active, disable it.
- When a minibuffer is open, but not focused, close the minibuffer.
- When the Completions buffer is selected, close it.
- In every other case use the regular `keyboard-quit'."
  (interactive)
  (cond
   ((region-active-p)
    (keyboard-quit))
   ((derived-mode-p 'completion-list-mode)
    (delete-completion-window))
   ((> (minibuffer-depth) 0)
    (abort-recursive-edit))
   (t
    (keyboard-quit))))

(define-key global-map (kbd "C-g") #'myrmi/keyboard-quit-dwim)

#+END_SRC