JosephFerano/dotfiles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

emacs: clojure stuff, magit functions, lsp, cider error stuff

Browse Source
This commit is contained in:
Joseph Ferano 2026-02-23 14:15:01 +07:00
parent 9cb8126a8c
commit e9a736f9c2
1 changed files with 390 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

576
.config/emacs/init.org
View File

@ -163,7 +163,6 @@ Finish up
("nongnu" . "https://elpa.nongnu.org/nongnu/") ("nongnu" . "https://elpa.nongnu.org/nongnu/")
("melpa" . "https://melpa.org/packages/"))) ("melpa" . "https://melpa.org/packages/")))
;; Proof-of-concept to install a list of packages ;; Proof-of-concept to install a list of packages
(mapc (mapc
(lambda (package) (lambda (package)
@ -270,6 +269,7 @@ Finish up
(indent-bars :url "https://github.com/jdtsmith/indent-bars") (indent-bars :url "https://github.com/jdtsmith/indent-bars")
(pyenv :url "https://github.com/jorgenschaefer/pyvenv") (pyenv :url "https://github.com/jorgenschaefer/pyvenv")
(time-zones :url "https://github.com/xenodium/time-zones") (time-zones :url "https://github.com/xenodium/time-zones")
(nano-calendar :url "https://github.com/rougier/nano-calendar")
(org-timeblock :url "https://github.com/ichernyshovvv/org-timeblock") (org-timeblock :url "https://github.com/ichernyshovvv/org-timeblock")
(dape :url "https://github.com/svaante/dape") (dape :url "https://github.com/svaante/dape")
(odin-mode :url "https://github.com/mattt-b/odin-mode") (odin-mode :url "https://github.com/mattt-b/odin-mode")
@ -376,12 +376,13 @@ Use Dashboard.el. First load `all-the-icons` for nicer rendering
;; (add-hook 'prog-mode-hook 'olivetti-mode) ;; (add-hook 'prog-mode-hook 'olivetti-mode)
(defun joe/toggle-olivetti-based-on-width () (defun joe/toggle-olivetti-based-on-width ()
(when (derived-mode-p 'prog-mode) (when (derived-mode-p 'prog-mode)
(if (> (window-total-width) 140) (if (> (window-total-width) 440)
(olivetti-mode 1) (olivetti-mode 1)
(olivetti-mode -1)))) (olivetti-mode -1))))
(add-hook 'window-configuration-change-hook #'joe/toggle-olivetti-based-on-width) (add-hook 'window-configuration-change-hook #'joe/toggle-olivetti-based-on-width)
(remove-hook 'window-configuration-change-hook #'joe/toggle-olivetti-based-on-width)
#+end_src #+end_src
Remove this hook from Olivetti so that lines can truncate [[https://github.com/rnkn/olivetti/issues/76][Github issue]] Remove this hook from Olivetti so that lines can truncate [[https://github.com/rnkn/olivetti/issues/76][Github issue]]
@ -592,21 +593,6 @@ Ligatures... are they that useful?
Emacs is an great operating system, if only it had a good text editor... Emacs is an great operating system, if only it had a good text editor...
*** COMMENT Hydra
#+begin_src emacs-lisp
(require 'hydra)
(defhydra hydra-navigate (global-map "<f2>")
"Window Navigation"
("q" nil "quit")
("d" joe/smooth-scroll-half-page-down "half page down")
("u" joe/smooth-scroll-half-page-up "half page up")
("e" joe/smooth-scroll-short-down "line down")
("y" joe/smooth-scroll-short-up "line up")
("n" next-line "line down")
("p" previous-line "line up")
("M-r" move-to-window-line-top-bottom "Reposition cursor"))
#+end_src
*** Text editing *** Text editing
#+begin_src emacs-lisp #+begin_src emacs-lisp
@ -628,6 +614,7 @@ Emacs is an great operating system, if only it had a good text editor...
(move-to-column col))) (move-to-column col)))
(global-set-key (kbd "C-w") #'backward-kill-word) (global-set-key (kbd "C-w") #'backward-kill-word)
(global-set-key (kbd "C-w") #'kill-region)
(global-set-key (kbd "C-c d") 'duplicate-line) (global-set-key (kbd "C-c d") 'duplicate-line)
(global-set-key (kbd "C-c C-;") 'joe/duplicate-line-comment) (global-set-key (kbd "C-c C-;") 'joe/duplicate-line-comment)
@ -655,6 +642,12 @@ Emacs is an great operating system, if only it had a good text editor...
#+end_src #+end_src
Compilation mode hook to recenter the screen after a jump
#+begin_src emacs-lisp
(add-hook 'next-error-hook #'recenter)
#+end_src
Stole this from [[https://github.com/purcell/unfill/][Purcell]] but didn't feel like making it a package depencendy Stole this from [[https://github.com/purcell/unfill/][Purcell]] but didn't feel like making it a package depencendy
#+begin_src emacs-lisp #+begin_src emacs-lisp
@ -737,168 +730,15 @@ Fill region is great, except when you don't need it...
;; Handy key definition ;; Handy key definition
(define-key global-map (kbd "C-M-q") #'unfill-region) (define-key global-map (kbd "C-M-q") #'unfill-region)
#+end_src
*** COMMENT Multiple Cursors
#+begin_src emacs-lisp
(require 'multiple-cursors)
#+end_src
*** COMMENT Meow
#+begin_src emacs-lisp
(elpaca 'meow)
(defun meow-setup ()
(setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
(meow-motion-overwrite-define-key
'("j" . meow-next)
'("k" . meow-prev)
'("<escape>" . ignore))
(meow-leader-define-key
;; SPC j/k will run the original command in MOTION state.
'("j" . "H-j")
'("k" . "H-k")
;; Use SPC (0-9) for digit arguments.
'("1" . meow-digit-argument)
'("2" . meow-digit-argument)
'("3" . meow-digit-argument)
'("4" . meow-digit-argument)
'("5" . meow-digit-argument)
'("6" . meow-digit-argument)
'("7" . meow-digit-argument)
'("8" . meow-digit-argument)
'("9" . meow-digit-argument)
'("0" . meow-digit-argument)
'("/" . meow-keypad-describe-key)
'("?" . meow-cheatsheet))
(meow-normal-define-key
'("0" . meow-expand-0)
'("9" . meow-expand-9)
'("8" . meow-expand-8)
'("7" . meow-expand-7)
'("6" . meow-expand-6)
'("5" . meow-expand-5)
'("4" . meow-expand-4)
'("3" . meow-expand-3)
'("2" . meow-expand-2)
'("1" . meow-expand-1)
'("-" . negative-argument)
'(";" . meow-reverse)
'("," . meow-inner-of-thing)
'("." . meow-bounds-of-thing)
'("[" . meow-beginning-of-thing)
'("]" . meow-end-of-thing)
'("a" . meow-append)
'("A" . meow-open-below)
'("b" . meow-back-word)
'("B" . meow-back-symbol)
'("c" . meow-change)
'("d" . meow-delete)
'("D" . meow-backward-delete)
'("e" . meow-next-word)
'("E" . meow-next-symbol)
'("f" . meow-find)
'("g" . meow-cancel-selection)
'("G" . meow-grab)
'("h" . meow-left)
'("H" . meow-left-expand)
'("i" . meow-insert)
'("I" . meow-open-above)
'("j" . meow-next)
'("J" . meow-next-expand)
'("k" . meow-prev)
'("K" . meow-prev-expand)
'("l" . meow-right)
'("L" . meow-right-expand)
'("m" . meow-join)
'("n" . meow-search)
'("o" . meow-block)
'("O" . meow-to-block)
'("p" . meow-yank)
'("q" . meow-quit)
'("Q" . meow-goto-line)
'("r" . meow-replace)
'("R" . meow-swap-grab)
'("s" . meow-kill)
'("t" . meow-till)
'("u" . meow-undo)
'("U" . meow-undo-in-selection)
'("v" . meow-visit)
'("w" . meow-mark-word)
'("W" . meow-mark-symbol)
'("x" . meow-line)
'("X" . meow-goto-line)
'("y" . meow-save)
'("Y" . meow-sync-grab)
'("z" . meow-pop-selection)
'("'" . repeat)
'("<escape>" . ignore)))
(require 'meow)
(meow-setup)
(meow-global-mode t)
(setq scroll-preserve-screen-position nil)
#+end_src
*** COMMENT expand-region
#+begin_src emacs-lisp
(evil-global-set-key 'insert (kbd "C-M-e") #'er/expand-region)
(evil-global-set-key 'insert (kbd "C-M-p") #'er/mark-inside-pairs)
(evil-global-set-key 'insert (kbd "C-M-f") #'er/mark-method-call)
(define-key global-map (kbd "C-=") #'er/expand-region)
(define-key global-map (kbd "C-+") #'er/contract-region)
#+end_src
*** COMMENT Boon
#+begin_src emacs-lisp
(defun joe/psp-scroll-down-half-page ()
(interactive)
(pixel-scroll-precision-scroll-down-page (/ (window-pixel-height) 2)))
(defun joe/psp-scroll-up-half-page ()
(interactive)
(pixel-scroll-precision-scroll-up-page (/ (window-pixel-height) 2)))
(elpaca 'boon
(require 'boon-qwerty)
(boon-mode)
(define-key boon-moves-map "h" 'backward-char)
(define-key boon-moves-map "j" 'next-line)
(define-key boon-moves-map "k" 'previous-line)
(define-key boon-moves-map "l" 'forward-char)
(define-key boon-moves-map "b" 'boon-smarter-backward)
(define-key boon-moves-map "w" 'boon-smarter-forward)
(define-key boon-moves-map "q" '("hop" . avy-goto-char-2))
(define-key boon-command-map (kbd "C-k") #'joe/scroll-down-line)
(define-key boon-command-map (kbd "C-j") #'joe/scroll-up-line)
(define-key boon-command-map (kbd "C-d") #'joe/psp-scroll-down-half-page)
(define-key boon-command-map (kbd "C-u") #'joe/psp-scroll-up-half-page)
(defun joe/scroll-up-line () (interactive) (scroll-up-line 2))
(defun joe/scroll-down-line () (interactive) (scroll-down-line 2))
(define-key boon-moves-map "H" 'backward-paragraph)
(define-key boon-moves-map "L" 'forward-paragraph)
(define-key boon-moves-map "K" 'boon-smarter-upward)
(define-key boon-moves-map "J" 'boon-smarter-downward)
(define-key boon-moves-map "o" 'boon-open-next-line-and-insert)
(define-key boon-moves-map "O" 'boon-open-line-and-insert)
(define-key boon-moves-map "i" 'boon-set-insert-like-state)
(define-key boon-moves-map "r" 'boon-replace-by-character)
(define-key boon-moves-map "y" 'boon-replace-by-character)
(define-key boon-moves-map "p" 'boon-splice)
(define-key boon-moves-map "y" 'boon-treasure-region)
(define-key ctl-x-map "s" 'save-buffer))
#+end_src #+end_src
*** Evil *** Evil
#+begin_src emacs-lisp #+begin_src emacs-lisp
(setopt evil-disable-insert-state-bindings t)
(setq evil-want-keybinding nil) (setq evil-want-keybinding nil)
(setq evil-undo-system 'undo-fu) (setq evil-undo-system 'undo-fu)
(setq evil-want-C-u-scroll t) (setq evil-want-C-u-scroll t)
(setq evil-want-Y-yank-to-eol t) (setq evil-want-Y-yank-to-eol t)
(setq evil-disable-insert-state-bindings t)
(setq evil-echo-state nil) (setq evil-echo-state nil)
(require 'evil) (require 'evil)
@ -1011,6 +851,332 @@ Fill region is great, except when you don't need it...
(setq evil-goggles-pulse t) (setq evil-goggles-pulse t)
(setq evil-goggles-async-duration 0.55) (setq evil-goggles-async-duration 0.55)
;; Recenter lines after mark jump
(advice-add 'evil-goto-mark :after (lambda (&rest _) (evil-scroll-line-to-center (line-number-at-pos))))
#+end_src
*** COMMENT easy-kill
#+begin_src emacs-lisp
;; (global-set-key [remap kill-ring-save] nil)
;; (global-set-key [remap mark-sexp] nil)
(require 'easy-kill)
(global-set-key [remap kill-ring-save] 'easy-kill)
(global-set-key [remap mark-sexp] 'easy-mark)
(global-set-key [remap mark-sexp] nil)
;; (global-set-key [remap mark-sexp] 'easy-mark)
;; (keymap-global-set "C-w" #'backward-kill-word)
(require 'extra-things)
(add-to-list 'easy-kill-alist '(?q quoted-string "") t)
(add-to-list 'easy-kill-alist '(?\) parentheses-pair-content "\n") t)
(add-to-list 'easy-kill-alist '(?\( parentheses-pair "\n") t)
(add-to-list 'easy-kill-alist '(?\] brackets-pair-content "\n") t)
(add-to-list 'easy-kill-alist '(?} curlies-pair-content "\n") t)
(add-to-list 'easy-kill-alist '(?{ curlies-pair "\n") t)
(add-to-list 'easy-kill-alist '(?> angles-pair-content "\n") t)
(add-to-list 'easy-kill-alist '(?< angles-pair "\n") t)
(add-to-list 'easy-kill-alist '(?b buffer ""))
(add-to-list 'easy-kill-alist '(?f string-to-char-forward ""))
(add-to-list 'easy-kill-alist '(?F string-up-to-char-forward ""))
(add-to-list 'easy-kill-alist '(?t string-to-char-backward ""))
(add-to-list 'easy-kill-alist '(?T string-up-to-char-backward ""))
(keymap-set easy-kill-base-map "<backspace>" #'easy-kill-delete-region)
;; (keymap-global-set "C-," 'universal-argument)
(keymap-global-set "s-d" 'View-scroll-half-page-forward)
(keymap-global-set "s-u" 'View-scroll-half-page-backward)
;; (add-to-list 'easy-kill-alist '(?^ backward-line-edge ""))
;; (add-to-list 'easy-kill-alist '(?$ forward-line-edge ""))
;; (add-to-list 'easy-kill-alist '(?< buffer-before-point ""))
;; (add-to-list 'easy-kill-alist '(?> buffer-after-point ""))
#+end_src
*** Something
#+begin_src emacs-lisp
(defun joe/backward-kill-word-or-kill-region ()
(interactive)
(cond
((use-region-p)
(kill-region (region-beginning) (region-end)))
((and (boundp 'easy-kill-candidate)
(overlayp easy-kill-candidate)
(overlay-buffer easy-kill-candidate))
(call-interactively 'easy-kill-region))
(t
(backward-kill-word 1))))
(keymap-global-set "C-w" #'joe/backward-kill-word-or-kill-region)
(evil-global-set-key 'visual (kbd "C-w") #'kill-region)
(defun joe/kill-region-or-window-management ()
(interactive)
(cond
((and (boundp 'easy-kill-candidate)
(overlayp easy-kill-candidate)
(overlay-buffer easy-kill-candidate))
(call-interactively 'easy-kill-region))
(t
(set-transient-map evil-window-map))))
(evil-global-set-key 'normal (kbd "C-w") #'joe/kill-region-or-window-management)
(defun joe/backward-delete-word-or-delete-region ()
(interactive)
(cond
((and (boundp 'easy-kill-candidate)
(overlayp easy-kill-candidate)
(overlay-buffer easy-kill-candidate))
(call-interactively 'easy-kill-delete-region))
(t
(delete-char 1))))
(keymap-global-set "C-d" #'joe/backward-delete-word-or-delete-region)
#+end_src
*** smartparens
#+begin_src emacs-lisp
(keymap-set smartparens-mode-map "C-M-f" 'sp-forward-sexp)
(keymap-set smartparens-mode-map "C-M-b" 'sp-backward-sexp)
(keymap-set smartparens-mode-map "C-M-d" 'sp-down-sexp)
(keymap-set smartparens-mode-map "C-M-a" 'sp-backward-down-sexp)
(keymap-set smartparens-mode-map "C-S-d" 'sp-beginning-of-sexp)
(keymap-set smartparens-mode-map "C-S-a" 'sp-end-of-sexp)
(keymap-set smartparens-mode-map "C-M-r" 'sp-raise-sexp)
(keymap-set smartparens-mode-map "C-M-c" 'sp-convolute-sexp)
(keymap-set smartparens-mode-map "C-M-e" 'sp-up-sexp)
(keymap-set smartparens-mode-map "C-M-u" 'sp-backward-up-sexp)
(keymap-set smartparens-mode-map "C-M-t" 'sp-transpose-sexp)
(keymap-set smartparens-mode-map "C-M-n" 'sp-forward-hybrid-sexp)
(keymap-set smartparens-mode-map "C-M-p" 'sp-backward-hybrid-sexp)
(keymap-set smartparens-mode-map "C-M-k" 'sp-kill-sexp)
(keymap-set smartparens-mode-map "C-M-w" 'sp-copy-sexp)
(keymap-set smartparens-mode-map "M-<delete>" 'sp-unwrap-sexp)
(keymap-set smartparens-mode-map "M-<backspace>" 'sp-backward-unwrap-sexp)
(keymap-set smartparens-mode-map "C-<right>" 'sp-forward-slurp-sexp)
(keymap-set smartparens-mode-map "C-<left>" 'sp-forward-barf-sexp)
(keymap-set smartparens-mode-map "C-M-<left>" 'sp-backward-slurp-sexp)
(keymap-set smartparens-mode-map "C-M-<right>" 'sp-backward-barf-sexp)
(keymap-set smartparens-mode-map "M-D" 'sp-splice-sexp)
(keymap-set smartparens-mode-map "C-M-<delete>" 'sp-splice-sexp-killing-forward)
(keymap-set smartparens-mode-map "C-M-<delete>" 'sp-kill-sexp)
(keymap-set smartparens-mode-map "C-M-<backspace>" 'sp-backward-kill-sexp)
(keymap-set smartparens-mode-map "C-M-S-<backspace>" 'sp-splice-sexp-killing-backward)
(keymap-set smartparens-mode-map "C-S-<backspace>" 'sp-splice-sexp-killing-around)
(keymap-set smartparens-mode-map "C-]" 'sp-select-next-thing-exchange)
(keymap-set smartparens-mode-map "C-<left_bracket>" 'sp-select-previous-thing)
(keymap-set smartparens-mode-map "C-M-]" 'sp-select-next-thing)
(keymap-set smartparens-mode-map "M-F" 'sp-forward-symbol)
(keymap-set smartparens-mode-map "M-B" 'sp-backward-symbol)
(keymap-set smartparens-mode-map "C-\"" 'sp-change-inner)
(keymap-set smartparens-mode-map "M-i" 'sp-change-enclosing)
(keymap-set smartparens-mode-map "M-R" 'sp-rewrap-sexp)
(keymap-set smartparens-mode-map "M-(" 'sp-wrap-round)
(keymap-set smartparens-mode-map "M-[" 'sp-wrap-square)
(keymap-set smartparens-mode-map "M-{" 'sp-wrap-curly)
#+end_src
*** expand-region
#+begin_src emacs-lisp
;; (evil-global-set-key 'insert (kbd "C-M-e") #'er/expand-region)
;; (evil-global-set-key 'insert (kbd "C-M-p") #'er/mark-inside-pairs)
;; (evil-global-set-key 'insert (kbd "C-M-f") #'er/mark-method-call)
;; (define-key global-map (kbd "C-=") #'er/expand-region)
;; (keymap-global-set "M-(" #'er/mark-outside-pairs)
;; (keymap-global-set "C-=" 'er/expand-region)
;; (keymap-global-set "C-M-(" #'er/mark-outside-pairs)
(defvar my-text-object-map
(let ((map (make-sparse-keymap)))
(keymap-set map "w" 'er/mark-word)
(keymap-set map "s" 'er/mark-symbol)
(keymap-set map "d" 'er/mark-defun)
(keymap-set map "f" 'er/mark-inside-pairs)
(keymap-set map "p" 'er/mark-outside-pairs)
(keymap-set map "q" 'er/mark-inside-quotes)
(keymap-set map "'" 'er/mark-outside-quotes)
(keymap-set map "e" 'er/expand-region)
(keymap-set map "c" 'er/contract-region)
map)
"Transient keymap for text object selection.")
(defun my-text-object-mode ()
"Activate text object selection transient map."
(interactive)
(message "Text object mode (w=word s=symbol d=defun f=inside-pairs p=outside-pairs q=quotes e=expand c=contract)")
;; (which-key--show-keymap "Expand-Region" my-text-object-map)
(set-transient-map my-text-object-map t))
(global-set-key (kbd "M-e") 'my-text-object-mode)
#+end_src
*** COMMENT Multiple Cursors
#+begin_src emacs-lisp
(require 'multiple-cursors)
#+end_src
*** COMMENT Hydra
#+begin_src emacs-lisp
(require 'hydra)
(defhydra hydra-navigate (global-map "<f2>")
"Window Navigation"
("q" nil "quit")
("d" joe/smooth-scroll-half-page-down "half page down")
("u" joe/smooth-scroll-half-page-up "half page up")
("e" joe/smooth-scroll-short-down "line down")
("y" joe/smooth-scroll-short-up "line up")
("n" next-line "line down")
("p" previous-line "line up")
("M-r" move-to-window-line-top-bottom "Reposition cursor"))
#+end_src
*** COMMENT Meow
#+begin_src emacs-lisp
(elpaca 'meow)
(defun meow-setup ()
(setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
(meow-motion-overwrite-define-key
'("j" . meow-next)
'("k" . meow-prev)
'("<escape>" . ignore))
(meow-leader-define-key
;; SPC j/k will run the original command in MOTION state.
'("j" . "H-j")
'("k" . "H-k")
;; Use SPC (0-9) for digit arguments.
'("1" . meow-digit-argument)
'("2" . meow-digit-argument)
'("3" . meow-digit-argument)
'("4" . meow-digit-argument)
'("5" . meow-digit-argument)
'("6" . meow-digit-argument)
'("7" . meow-digit-argument)
'("8" . meow-digit-argument)
'("9" . meow-digit-argument)
'("0" . meow-digit-argument)
'("/" . meow-keypad-describe-key)
'("?" . meow-cheatsheet))
(meow-normal-define-key
'("0" . meow-expand-0)
'("9" . meow-expand-9)
'("8" . meow-expand-8)
'("7" . meow-expand-7)
'("6" . meow-expand-6)
'("5" . meow-expand-5)
'("4" . meow-expand-4)
'("3" . meow-expand-3)
'("2" . meow-expand-2)
'("1" . meow-expand-1)
'("-" . negative-argument)
'(";" . meow-reverse)
'("," . meow-inner-of-thing)
'("." . meow-bounds-of-thing)
'("[" . meow-beginning-of-thing)
'("]" . meow-end-of-thing)
'("a" . meow-append)
'("A" . meow-open-below)
'("b" . meow-back-word)
'("B" . meow-back-symbol)
'("c" . meow-change)
'("d" . meow-delete)
'("D" . meow-backward-delete)
'("e" . meow-next-word)
'("E" . meow-next-symbol)
'("f" . meow-find)
'("g" . meow-cancel-selection)
'("G" . meow-grab)
'("h" . meow-left)
'("H" . meow-left-expand)
'("i" . meow-insert)
'("I" . meow-open-above)
'("j" . meow-next)
'("J" . meow-next-expand)
'("k" . meow-prev)
'("K" . meow-prev-expand)
'("l" . meow-right)
'("L" . meow-right-expand)
'("m" . meow-join)
'("n" . meow-search)
'("o" . meow-block)
'("O" . meow-to-block)
'("p" . meow-yank)
'("q" . meow-quit)
'("Q" . meow-goto-line)
'("r" . meow-replace)
'("R" . meow-swap-grab)
'("s" . meow-kill)
'("t" . meow-till)
'("u" . meow-undo)
'("U" . meow-undo-in-selection)
'("v" . meow-visit)
'("w" . meow-mark-word)
'("W" . meow-mark-symbol)
'("x" . meow-line)
'("X" . meow-goto-line)
'("y" . meow-save)
'("Y" . meow-sync-grab)
'("z" . meow-pop-selection)
'("'" . repeat)
'("<escape>" . ignore)))
(require 'meow)
(meow-setup)
(meow-global-mode t)
(setq scroll-preserve-screen-position nil)
#+end_src
*** COMMENT Boon
#+begin_src emacs-lisp
(defun joe/psp-scroll-down-half-page ()
(interactive)
(pixel-scroll-precision-scroll-down-page (/ (window-pixel-height) 2)))
(defun joe/psp-scroll-up-half-page ()
(interactive)
(pixel-scroll-precision-scroll-up-page (/ (window-pixel-height) 2)))
(elpaca 'boon
(require 'boon-qwerty)
(boon-mode)
(define-key boon-moves-map "h" 'backward-char)
(define-key boon-moves-map "j" 'next-line)
(define-key boon-moves-map "k" 'previous-line)
(define-key boon-moves-map "l" 'forward-char)
(define-key boon-moves-map "b" 'boon-smarter-backward)
(define-key boon-moves-map "w" 'boon-smarter-forward)
(define-key boon-moves-map "q" '("hop" . avy-goto-char-2))
(define-key boon-command-map (kbd "C-k") #'joe/scroll-down-line)
(define-key boon-command-map (kbd "C-j") #'joe/scroll-up-line)
(define-key boon-command-map (kbd "C-d") #'joe/psp-scroll-down-half-page)
(define-key boon-command-map (kbd "C-u") #'joe/psp-scroll-up-half-page)
(defun joe/scroll-up-line () (interactive) (scroll-up-line 2))
(defun joe/scroll-down-line () (interactive) (scroll-down-line 2))
(define-key boon-moves-map "H" 'backward-paragraph)
(define-key boon-moves-map "L" 'forward-paragraph)
(define-key boon-moves-map "K" 'boon-smarter-upward)
(define-key boon-moves-map "J" 'boon-smarter-downward)
(define-key boon-moves-map "o" 'boon-open-next-line-and-insert)
(define-key boon-moves-map "O" 'boon-open-line-and-insert)
(define-key boon-moves-map "i" 'boon-set-insert-like-state)
(define-key boon-moves-map "r" 'boon-replace-by-character)
(define-key boon-moves-map "y" 'boon-replace-by-character)
(define-key boon-moves-map "p" 'boon-splice)
(define-key boon-moves-map "y" 'boon-treasure-region)
(define-key ctl-x-map "s" 'save-buffer))
#+end_src #+end_src
** Buffers ** Buffers
#+begin_src emacs-lisp #+begin_src emacs-lisp
@ -1940,7 +2106,6 @@ odd looking ~'(t .t)~ is for specifying a default for all other actions.
(add-hook 'after-init-hook #'mu4e-alert-enable-mode-line-display)) (add-hook 'after-init-hook #'mu4e-alert-enable-mode-line-display))
;; (:name "Ferano.io Unread" :query "m:/ferano.io/Inbox AND g:unread" :key ?u))) ;; (:name "Ferano.io Unread" :query "m:/ferano.io/Inbox AND g:unread" :key ?u)))
#+end_src #+end_src
** Avy ** Avy
#+begin_src emacs-lisp #+begin_src emacs-lisp
@ -2108,6 +2273,11 @@ close and remove the hook
(evil-define-key 'insert comint-mode-map (kbd "C-n") 'comint-next-input) (evil-define-key 'insert comint-mode-map (kbd "C-n") 'comint-next-input)
(evil-define-key 'insert comint-mode-map (kbd "C-p") 'comint-previous-input)) (evil-define-key 'insert comint-mode-map (kbd "C-p") 'comint-previous-input))
#+end_src #+end_src
*** dumb-jump
#+begin_src emacs-lisp
(require 'dumb-jump)
(add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
#+end_src
*** Completion *** Completion
#+begin_src emacs-lisp #+begin_src emacs-lisp
;; (evil-global-set-key 'insert (kbd "C-f") #'mono-complete-expand) ;; (evil-global-set-key 'insert (kbd "C-f") #'mono-complete-expand)
@ -2169,6 +2339,8 @@ These help speed eglot up apparently [[https://www.reddit.com/r/emacs/comments/1
*** LSP *** LSP
#+begin_src emacs-lisp #+begin_src emacs-lisp
(setq lsp-keymap-prefix "C-c l") (setq lsp-keymap-prefix "C-c l")
(setq lsp-enable-indentation nil)
(setq lsp-enable-on-type-formatting nil)
(require 'lsp-mode) (require 'lsp-mode)
(setq lsp-enable-completion-at-point nil) (setq lsp-enable-completion-at-point nil)
(setq lsp-enable-indentation nil) (setq lsp-enable-indentation nil)
@ -2194,18 +2366,18 @@ These help speed eglot up apparently [[https://www.reddit.com/r/emacs/comments/1
;; All this changes because we are using eglot now ;; All this changes because we are using eglot now
(when (boundp 'evil-mode) (when (boundp 'evil-mode)
(evil-global-set-key 'normal (kbd "M-d") #'lsp-ui-doc-glance) (evil-global-set-key 'normal (kbd "M-d") #'lsp-ui-doc-glance)
(evil-global-set-key 'normal (kbd "M-D") #'lsp-describe-thing-at-point) (evil-global-set-key 'normal (kbd "M-D") #'lsp-describe-thing-at-point)
(evil-global-set-key 'normal (kbd "M-r") #'lsp-rename) (evil-global-set-key 'normal (kbd "M-r") #'lsp-rename)
(evil-global-set-key 'insert (kbd "M-i") #'lsp-signature-activate) (evil-global-set-key 'insert (kbd "M-i") #'lsp-signature-activate)
(evil-global-set-key 'normal (kbd "gD") #'xref-find-definitions-other-window) (evil-global-set-key 'normal (kbd "gD") #'xref-find-definitions-other-window)
(evil-global-set-key 'normal (kbd "SPC la") #'lsp-execute-code-action) (evil-global-set-key 'normal (kbd "SPC la") #'lsp-execute-code-action)
(evil-global-set-key 'normal (kbd "SPC lt") #'lsp-find-type-definition) (evil-global-set-key 'normal (kbd "SPC lt") #'lsp-find-type-definition)
(evil-global-set-key 'normal (kbd "SPC lr") #'lsp-find-references) (evil-global-set-key 'normal (kbd "SPC lr") #'lsp-find-references)
(evil-global-set-key 'normal (kbd "SPC ld") #'lsp-find-definition) (evil-global-set-key 'normal (kbd "SPC ld") #'lsp-find-definition)
(evil-global-set-key 'normal (kbd "SPC ls") #'consult-lsp-symbols) (evil-global-set-key 'normal (kbd "SPC ls") #'consult-lsp-symbols)
(evil-global-set-key 'normal (kbd "SPC lD") #'consult-lsp-diagnostics) (evil-global-set-key 'normal (kbd "SPC lD") #'consult-lsp-diagnostics)
(evil-global-set-key 'normal (kbd "SPC lf") #'consult-lsp-file-symbols)) (evil-global-set-key 'normal (kbd "SPC lf") #'consult-lsp-file-symbols))
#+end_src #+end_src
@ -2336,6 +2508,7 @@ newly opened buffer belongs to an LSP session and if it does, start lsp
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a RET") #'gptel-ask) (evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a RET") #'gptel-ask)
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a M") #'gptel-mode) (evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a M") #'gptel-mode)
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a c") #'gptel-add) ;; Will delete context at point (evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a c") #'gptel-add) ;; Will delete context at point
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a A") #'gptel-abort)
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a <backspace>") #'joe/gptel-context-remove-all) (evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC a <backspace>") #'joe/gptel-context-remove-all)
(evil-define-key 'visual joe/evil-space-mode-map (kbd "SPC a r") #'gptel-rewrite) (evil-define-key 'visual joe/evil-space-mode-map (kbd "SPC a r") #'gptel-rewrite)
@ -2426,7 +2599,9 @@ This checks if it’s a ts mode then runs their counterparts.
(require 'clojure-mode) (require 'clojure-mode)
(require 'cider) (require 'cider)
(require 'flycheck-clj-kondo) (require 'flycheck-clj-kondo)
(setq cider-use-xref nil) (setq cider-use-xref nil)
(setq clojure-indent-style 'align-arguments)
(defvar joe/cider-last-reported-exception nil (defvar joe/cider-last-reported-exception nil
"The last exception string reported by Cider.") "The last exception string reported by Cider.")
@ -2434,14 +2609,14 @@ This checks if it’s a ts mode then runs their counterparts.
(defun joe/clojure-cider-throw-last-error () (defun joe/clojure-cider-throw-last-error ()
(interactive) (interactive)
(let* ((error-str (nrepl-dict-get (let* ((error-str (nrepl-dict-get
(cider-nrepl-sync-request:eval "@error-reporting/last-exception") (cider-nrepl-sync-request:eval "@editor.error-reporting/last-exception")
"value")) "value"))
(error-buffer (get-buffer "*cider-error*")) (error-buffer (get-buffer "*cider-error*"))
(same-error-p (and error-buffer (same-error-p (and error-buffer
(string= joe/cider-last-reported-exception error-str)))) (string= joe/cider-last-reported-exception error-str))))
(unless same-error-p (unless same-error-p
(setq joe/cider-last-reported-exception error-str) (setq joe/cider-last-reported-exception error-str)
(cider-interactive-eval "(throw @error-reporting/last-exception)")))) (cider-interactive-eval "(throw @editor.error-reporting/last-exception)"))))
(defun joe/cider-repl-preoutput-hook (output) (defun joe/cider-repl-preoutput-hook (output)
(if (string-match "EMACS-CIDER-REPORT-EXCEPTION" output) (if (string-match "EMACS-CIDER-REPORT-EXCEPTION" output)
@ -2454,6 +2629,10 @@ This checks if it’s a ts mode then runs their counterparts.
(defun joe/clojure-mode-hook () (defun joe/clojure-mode-hook ()
(hs-minor-mode +1) (hs-minor-mode +1)
;; (yas-minor-mode +1)
(smartparens-mode +1)
;; (cljr-add-keybindings-with-prefix "C-c C-m")
(keymap-set clojure-mode-map "M-q" #'format-all-region-or-buffer)
(when (lsp-mode-server-exists-p+ 'clojure-mode) (when (lsp-mode-server-exists-p+ 'clojure-mode)
(lsp))) (lsp)))
@ -3157,6 +3336,31 @@ The best git porcelain/client I've ever used. Also kill stray magit buffers left
;; (define-key magit-mode-map "h" 'backward-char) ;; (define-key magit-mode-map "h" 'backward-char)
;; (define-key magit-mode-map "l" 'backward-char) ;; (define-key magit-mode-map "l" 'backward-char)
#+end_src
;; TODO: We need to create a var for a project based base branch
#+begin_src emacs-lisp
(defun joe/magit-diff-branch-changes ()
"Show diff of changes made only in current branch vs base."
(interactive)
(let ((base (completing-read "Base branch: "
(magit-list-branch-names)
nil nil "dev")))
(magit-diff-range (concat base "...HEAD"))))
(defun joe/magit-log-branch-commits ()
"Show commits made only in current branch vs base."
(interactive)
(let ((base (completing-read "Base branch: "
(magit-list-branch-names)
nil nil "origin/dev")))
(magit-log-other (list (concat base "..HEAD")))))
(with-eval-after-load 'magit
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC g b") #'joe/magit-diff-branch-changes)
(evil-define-key 'normal joe/evil-space-mode-map (kbd "SPC g l") #'joe/magit-log-branch-commits))
#+end_src #+end_src
** Restclient ** Restclient