2426 lines
89 KiB
EmacsLisp
2426 lines
89 KiB
EmacsLisp
;;; init.el --- Configuration entry point -*- lexical-binding: t -*-
|
|
;;; Commentary:
|
|
;;; Code:
|
|
|
|
;; Some other config files
|
|
(add-to-list 'load-path "~/.emacs.d/elisp")
|
|
|
|
;; Set package dir to follow no-littering conventions
|
|
(setq package-user-dir "~/.emacs.d/var/elpa")
|
|
|
|
;; Use melpa
|
|
(require 'package)
|
|
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
|
|
(package-initialize)
|
|
|
|
;; Ensure use-package is installed
|
|
(unless (package-installed-p 'use-package)
|
|
(package-refresh-contents)
|
|
(package-install 'use-package))
|
|
|
|
;; use-package
|
|
(eval-when-compile
|
|
(require 'use-package)
|
|
(setq use-package-always-ensure t
|
|
package-user-dir "~/.emacs.d/var/elpa"))
|
|
|
|
;; no-littering
|
|
(use-package no-littering
|
|
:autoload (no-littering-theme-backups
|
|
no-littering-expand-etc-file-name)
|
|
:init
|
|
(no-littering-theme-backups)
|
|
(setq custom-file (no-littering-expand-etc-file-name "custom.el")))
|
|
|
|
;; diminish
|
|
(use-package diminish
|
|
:config
|
|
(diminish 'visual-line-mode)
|
|
(diminish 'abbrev-mode))
|
|
|
|
;; Private config loading
|
|
(require 'private nil t)
|
|
(defun my/get-private (key)
|
|
"Get the private config variable KEY from the private configuration file."
|
|
(alist-get key my/private-config))
|
|
|
|
;; basic stuff
|
|
(use-package emacs
|
|
:hook (;;(emacs-lisp-mode . my/-emacs-lisp-mode-setup-evil-lookup)
|
|
;;(prog-mode . electric-pair-local-mode)
|
|
((text-mode tex-mode prog-mode) . auto-fill-mode)
|
|
((text-mode tex-mode prog-mode) . my/-enable-show-trailing-whitespace))
|
|
:init
|
|
(defun my/-enable-show-trailing-whitespace ()
|
|
(setq-local show-trailing-whitespace t))
|
|
;; (defun my/-emacs-lisp-mode-setup-evil-lookup ()
|
|
;; (setq-local evil-lookup-func
|
|
;; #'my/describe-symbol-at-point))
|
|
(defun my/describe-symbol-at-point ()
|
|
"Calls `describe-symbol' on the return value of `symbol-at-point'."
|
|
(interactive)
|
|
(let ((form (symbol-at-point)))
|
|
(if (consp form)
|
|
(describe-symbol (cadr form))
|
|
(describe-symbol form))))
|
|
|
|
;; Increase responsiveness
|
|
(setq gc-cons-threshold 80000000
|
|
read-process-output-max (* 1024 1024)) ;; 1mb
|
|
(global-so-long-mode 1)
|
|
|
|
;; Terminal mouse support
|
|
(xterm-mouse-mode 1)
|
|
|
|
;; Make cursor more visible
|
|
(global-hl-line-mode 1)
|
|
(blink-cursor-mode -1)
|
|
|
|
;; Enable all disabled stuff
|
|
(setq disabled-command-function nil)
|
|
|
|
;; Stop some annoying stuff
|
|
(setq extended-command-suggest-shorter nil
|
|
suggest-key-bindings nil)
|
|
|
|
;; Better scrolling
|
|
(setq mouse-scroll-delay 0
|
|
scroll-conservatively 10
|
|
scroll-margin 2
|
|
scroll-preserve-screen-position t)
|
|
|
|
;; Make show paren instant
|
|
(setq show-paren-delay 0)
|
|
(show-paren-mode 1)
|
|
|
|
;; Display line numbers
|
|
(global-display-line-numbers-mode 1)
|
|
|
|
;; Allow the frame to be any size
|
|
(setq frame-resize-pixelwise t)
|
|
|
|
;; Don't use a gtk file picker
|
|
(setq use-file-dialog nil)
|
|
|
|
;; Make yes-or-no-p less verbose (and not use windows)
|
|
(setq use-dialog-box nil
|
|
use-short-answers t)
|
|
|
|
;; Disable startup screen
|
|
(setq inhibit-startup-screen t
|
|
server-client-instructions nil)
|
|
|
|
;; show column numbers
|
|
(column-number-mode 1)
|
|
|
|
;; Disable the menu and tool bars
|
|
(menu-bar-mode -1)
|
|
(tool-bar-mode -1)
|
|
|
|
;; No scroll bars
|
|
(scroll-bar-mode -1)
|
|
|
|
;; Visual line mode
|
|
(global-visual-line-mode 1)
|
|
|
|
;; Make some commands easier to enter multiple times
|
|
(repeat-mode 1)
|
|
|
|
;; Easier buffer navigation
|
|
(keymap-global-set "C-c <" #'previous-buffer)
|
|
(keymap-global-set "C-c >" #'next-buffer)
|
|
(keymap-global-set "C-c k" #'previous-buffer)
|
|
(keymap-global-set "C-c j" #'next-buffer)
|
|
|
|
;; Set fonts
|
|
(add-to-list 'default-frame-alist '(font . "FiraCode Nerd Font Mono-12"))
|
|
(add-hook 'server-after-make-frame-hook
|
|
(lambda ()
|
|
(set-fontset-font t 'japanese-jisx0208 "IPAGothic")))
|
|
|
|
;; Enable color in compilation buffers
|
|
(add-hook 'compilation-filter-hook 'ansi-color-compilation-filter)
|
|
|
|
;; Some settings for programming
|
|
(setq-default indent-tabs-mode nil
|
|
tab-width 4
|
|
fill-column 80
|
|
comment-multi-line t
|
|
comment-empty-lines 'eol)
|
|
(add-to-list 'auto-mode-alist '("\\.[cC][nN][fF]\\'" . conf-mode))
|
|
(keymap-set emacs-lisp-mode-map "C-c C-r" #'eval-region)
|
|
(defun my/-fix-emacs-lisp-mode-system-files ()
|
|
(when (string-prefix-p lisp-directory buffer-file-name)
|
|
;; system Emacs files use tab characters and look weird without this.
|
|
(setq-local tab-width 8)))
|
|
(add-hook 'emacs-lisp-mode-hook #'my/-fix-emacs-lisp-mode-system-files)
|
|
|
|
;; Tree sitter download locations
|
|
(setq treesit-language-source-alist
|
|
'((c "https://github.com/tree-sitter/tree-sitter-c")
|
|
(cpp "https://github.com/tree-sitter/tree-sitter-cpp")
|
|
(java "https://github.com/tree-sitter/tree-sitter-java")
|
|
(python "https://github.com/tree-sitter/tree-sitter-python")
|
|
(rust "https://github.com/tree-sitter/tree-sitter-rust")
|
|
(json "https://github.com/tree-sitter/tree-sitter-json")
|
|
(yaml "https://github.com/ikatyang/tree-sitter-yaml")
|
|
(css "https://github.com/tree-sitter/tree-sitter-css")
|
|
(go "https://github.com/tree-sitter/tree-sitter-go")
|
|
(gomod "https://github.com/camdencheek/tree-sitter-go-mod")
|
|
(javascript "https://github.com/tree-sitter/tree-sitter-javascript")
|
|
(bash "https://github.com/tree-sitter/tree-sitter-bash")
|
|
(cmake "https://github.com/uyha/tree-sitter-cmake")
|
|
(blueprint "https://github.com/huanie/tree-sitter-blueprint")
|
|
(kdl "https://github.com/tree-sitter-grammars/tree-sitter-kdl")))
|
|
;; Tree sitter major mode conversions
|
|
(setq major-mode-remap-alist
|
|
'((c-mode . c-ts-mode)
|
|
(c++-mode . c++-ts-mode)
|
|
(c-or-c++-mode . c-or-c++-ts-mode)
|
|
(python-mode . python-ts-mode)
|
|
(java-mode . java-ts-mode)
|
|
(rust-mode . rust-ts-mode)
|
|
(json-mode . json-ts-mode)
|
|
(yaml-mode . yaml-ts-mode)
|
|
(css-mode . css-ts-mode)
|
|
(js-mode . js-ts-mode)
|
|
(cmake-mode . cmake-ts-mode)))
|
|
(defun my/treesit-compile-all (force)
|
|
"Compile all the modules defined in `treesit-language-source-alist'.
|
|
If FORCE, recompile all modules, even ones that are already compiled.
|
|
Interactively, force the recompile if called with a prefix."
|
|
(interactive "P")
|
|
(let ((did-build nil))
|
|
(dolist (lang treesit-language-source-alist)
|
|
(when (or force (not (treesit-language-available-p (car lang))))
|
|
(treesit-install-language-grammar (car lang))
|
|
(setq did-build t)))
|
|
(unless did-build
|
|
(message "All defined parsers installed!")))))
|
|
|
|
(use-package midnight
|
|
:ensure nil
|
|
:config
|
|
(add-to-list 'clean-buffer-list-kill-never-buffer-names
|
|
"*mu4e-main*")
|
|
(add-to-list 'clean-buffer-list-kill-never-buffer-names
|
|
"*Async-native-compile-log*")
|
|
(add-to-list 'clean-buffer-list-kill-never-buffer-names
|
|
"*dashboard*")
|
|
(add-to-list 'clean-buffer-list-kill-never-buffer-names
|
|
"*elfeed-search*")
|
|
(midnight-mode 1))
|
|
|
|
(defvar my/kill-some-buffers-exclude-names
|
|
'("*mu4e-main*" "*Async-native-compile-log*" "*dashboard*" "*elfeed-search*"
|
|
"*Messages*" "*scratch*")
|
|
"List of literal buffer names that `my/kill-some-buffers' should not kill.")
|
|
|
|
(defun my/kill-some-buffers-excluded-buffer-p (buffer)
|
|
"Return non-nil if BUFFER should be excluded from `my/kill-some-buffers'."
|
|
(cl-find (buffer-name buffer) my/kill-some-buffers-exclude-names
|
|
:test 'equal))
|
|
|
|
(defun my/buffer-visible-p (buffer)
|
|
"Return non-nil if BUFFER is visible.
|
|
BUFFER can be a string or a buffer."
|
|
(cond
|
|
((stringp buffer)
|
|
(not (string-prefix-p " " buffer)))
|
|
((bufferp buffer)
|
|
(and (stringp (buffer-name buffer))
|
|
(my/buffer-visible-p (buffer-name buffer))))
|
|
(t
|
|
(signal 'wrong-type-argument `((or bufferp stringp) ,buffer)))))
|
|
|
|
(defvar my/kill-some-buffers-default-pred 'my/buffer-visible-p
|
|
"Default predicate for `my/kill-some-buffers'.")
|
|
|
|
(defun my/kill-some-buffers-prompt-for (buffer)
|
|
"Generate a prompt for BUFFER."
|
|
(let* ((process (get-buffer-process buffer))
|
|
(process-p (and (process-live-p process)
|
|
(not (process-query-on-exit-flag process))))
|
|
(modified-p (and (buffer-file-name buffer)
|
|
(buffer-modified-p buffer))))
|
|
(format "Buffer \"%s\" %s. Kill? "
|
|
(buffer-name buffer)
|
|
(cond
|
|
((and process-p modified-p)
|
|
"HAS BEEN EDITED AND HAS A LIVE PROCESS")
|
|
(modified-p
|
|
"HAS BEEN EDITED")
|
|
(process-p
|
|
"HAS A LIVE PROCESS")
|
|
(t "is unmodified")))))
|
|
|
|
(cl-defun my/kill-some-buffers (&optional auto-unmod pred)
|
|
"Improved version of `kill-some-buffers'.
|
|
Ask the user weather to kill each visible buffer whose name is not in
|
|
`my/kill-some-buffers-exclude-names'.
|
|
|
|
When AUTO-UNMOD is non-nil, as it is with a prefix argument, automatically kill
|
|
unmodified buffers, and then ask about the rest.
|
|
|
|
When PRED is non-nil, it is a function that will be run in each buffer (not just
|
|
visible ones). If it returns t, that buffer will be considered for killing. If
|
|
PRED is nil, the value of `my/kill-some-buffers-default-pred' is used."
|
|
(interactive "P")
|
|
;; we already ask, no need to do it again
|
|
(let ((kill-buffer-query-functions nil)
|
|
(all-action (when auto-unmod 'unmod))
|
|
(ask-again-buffers))
|
|
(cl-flet ((ask-about (buffer allow-unmod)
|
|
(unless all-action
|
|
(read-answer
|
|
(my/kill-some-buffers-prompt-for buffer)
|
|
`(("yes" ?y "save and kill this buffer")
|
|
("no" ?n "skip this buffer")
|
|
("all" ?! "save and kill all remaining buffers")
|
|
("nosave" ?l "kill this buffer without saving")
|
|
,@(when allow-unmod
|
|
'(("unmod" ?a
|
|
"kill unmodified buffers, ask about the rest")))
|
|
("quit" ?q "exit")))))
|
|
(act-on (ans buffer allow-unmod)
|
|
(when (equal ans "all")
|
|
(setq all-action 'all))
|
|
(when (and allow-unmod
|
|
(equal ans "unmod"))
|
|
(setq all-action 'unmod))
|
|
(cond
|
|
((and (eq all-action 'unmod)
|
|
(buffer-file-name buffer)
|
|
(buffer-modified-p buffer))
|
|
(push buffer ask-again-buffers))
|
|
((or (eq all-action 'all)
|
|
(eq all-action 'unmod)
|
|
(equal ans "yes"))
|
|
(when (buffer-file-name buffer)
|
|
(with-current-buffer buffer
|
|
(save-buffer)))
|
|
(kill-buffer buffer))
|
|
((equal ans "nosave")
|
|
(with-current-buffer buffer
|
|
(set-buffer-modified-p nil))
|
|
(kill-buffer buffer))
|
|
;; Skip buffer
|
|
;; ((equal ans "no"))
|
|
((equal ans "quit")
|
|
(cl-return-from my/kill-some-buffers)))))
|
|
(dolist (buffer (buffer-list))
|
|
(when (and (not (my/kill-some-buffers-excluded-buffer-p buffer))
|
|
(funcall (or pred my/kill-some-buffers-default-pred) buffer))
|
|
(act-on (ask-about buffer t) buffer t)))
|
|
(setq all-action nil)
|
|
(dolist (buffer ask-again-buffers)
|
|
(act-on (ask-about buffer nil) buffer nil)))))
|
|
(keymap-global-set "C-x K" 'my/kill-some-buffers)
|
|
|
|
(use-package tab-bar
|
|
:ensure nil
|
|
:init
|
|
(setq tab-bar-show 1
|
|
tab-bar-tab-hints t
|
|
icon-preference '(symbol text image emoji))
|
|
(tab-bar-mode 1))
|
|
|
|
;; jinx (better flyspell)
|
|
(use-package jinx
|
|
:hook (emacs-startup . global-jinx-mode)
|
|
:config
|
|
(evil-define-key 'normal 'global
|
|
"z=" #'jinx-correct))
|
|
|
|
;; recentf
|
|
(use-package recentf
|
|
:init
|
|
(setq recentf-exclude `("^/tmp/.*"
|
|
"^~/.mail/[^/]/Drafts/.*"
|
|
,(format "^%svar/elpa/.*" user-emacs-directory)
|
|
,(format "^%svar/elfeed/.*" user-emacs-directory)
|
|
,(format "^%svar/gnus/.*" user-emacs-directory)
|
|
,(format "^%svar/ellama-sessions/.*" user-emacs-directory)
|
|
,(format "^%setc/gnus/.*" user-emacs-directory)
|
|
,(format "^%svar/bookmark-default.el" user-emacs-directory)))
|
|
:bind ("C-c r" . recentf)
|
|
:config
|
|
(recentf-mode 1))
|
|
|
|
;; bookmarks
|
|
(use-package bookmark
|
|
:ensure nil
|
|
:bind ("C-c b" . my/bookmark-find-file)
|
|
:config
|
|
(defun my/bookmark-find-file (&optional name)
|
|
"Run `find-file' in or on bookmark NAME.
|
|
If NAME points to a directory, run `find-file' with `default-directory' in that
|
|
directory. Otherwise, run `find-file' on that file."
|
|
(interactive (list (bookmark-completing-read
|
|
"Find file in" bookmark-current-bookmark)))
|
|
(unless name
|
|
(error "No bookmark specified"))
|
|
(bookmark-maybe-historicize-string name)
|
|
(when-let ((file (bookmark-get-filename name)))
|
|
(if (file-directory-p file)
|
|
(let ((default-directory (file-name-as-directory file)))
|
|
(call-interactively 'find-file))
|
|
(find-file file)))))
|
|
|
|
;; kitty keyboard protocol
|
|
(use-package kkp
|
|
:config
|
|
(global-kkp-mode 1)
|
|
(defun my/-kkp-after-terminal-setup (&rest _)
|
|
;; Make tab and backtab work properly
|
|
(define-key input-decode-map [(control ?i)] [tab])
|
|
(define-key input-decode-map [(control ?I)] [backtab]))
|
|
(defun my/-kkp-after-terminal-teardown (&rest _)
|
|
(define-key input-decode-map [(control ?i)] nil t)
|
|
(define-key input-decode-map [(control ?I)] nil t))
|
|
(advice-add 'kkp--terminal-setup :after 'my/-kkp-after-terminal-setup)
|
|
(advice-add 'kkp--terminal-teardown :after 'my/-kkp-after-terminal-teardown)
|
|
(defun my/quoted-insert (arg)
|
|
"Insert the next character using read-key, not read-char."
|
|
(interactive "*p")
|
|
;; Source: https://github.com/benjaminor/kkp/issues/11
|
|
(let ((char (read-key)))
|
|
;; Ensure char is treated as a character code for insertion
|
|
(unless (characterp char)
|
|
(user-error "%s is not a valid character"
|
|
(key-description (vector char))))
|
|
(when (numberp char)
|
|
(while (> arg 0)
|
|
(insert-and-inherit char)
|
|
(setq arg (1- arg))))))
|
|
(keymap-global-set "C-q" #'my/quoted-insert)
|
|
(defun my/-kkp-fix-save-some-buffers (oldfun &optional arg pred)
|
|
"Fix `save-some-buffers' when used in a terminal with kkp enabled."
|
|
(let ((status (kkp--terminal-has-active-kkp-p)))
|
|
(unwind-protect
|
|
(progn
|
|
(when status (kkp--terminal-teardown (kkp--selected-terminal)))
|
|
(funcall oldfun arg pred))
|
|
(when (and status (not (kkp--terminal-has-active-kkp-p)))
|
|
;; this does async stuff that will make kitty send characters after
|
|
;; Emacs exists. We prevent that by not re-enabling if this frame (or
|
|
;; Emacs) is about to die
|
|
(let ((will-die-p))
|
|
(mapbacktrace
|
|
(lambda (_evald func _args _flags)
|
|
(when (or (eq func 'save-buffers-kill-emacs)
|
|
(eq func 'server-save-buffers-kill-terminal))
|
|
(setq will-die-p t))))
|
|
(unless will-die-p
|
|
(kkp-enable-in-terminal)))))))
|
|
(advice-add #'save-some-buffers :around
|
|
#'my/-kkp-fix-save-some-buffers))
|
|
|
|
;; mozc
|
|
(require 'mozc nil t)
|
|
(setq default-input-method "japanese-mozc")
|
|
|
|
;; undo-tree
|
|
(use-package undo-tree
|
|
:defer nil
|
|
:hook (undo-tree-visualizer-mode . my/-undo-tree-visualizer-mode-setup)
|
|
:config
|
|
(defun my/-undo-tree-visualizer-mode-setup ()
|
|
(visual-line-mode -1)
|
|
(setq truncate-lines t))
|
|
(global-undo-tree-mode))
|
|
|
|
;; evil
|
|
(use-package evil
|
|
:init
|
|
(setq evil-want-integration t
|
|
evil-want-C-d-scroll nil
|
|
evil-want-keybinding nil
|
|
evil-undo-system 'undo-tree
|
|
evil-search-module 'isearch
|
|
evil-respect-visual-line-mode t)
|
|
:config
|
|
(evil-mode 1)
|
|
(evil-define-key '(normal visual motion) proced-mode-map
|
|
"u" #'proced-unmark)
|
|
(evil-define-key '(normal visual motion) dired-mode-map
|
|
"u" #'dired-unmark)
|
|
(evil-define-key '(normal visual motion) profiler-report-mode-map
|
|
(kbd "TAB") #'profiler-report-toggle-entry)
|
|
(eldoc-add-command 'evil-insert
|
|
'evil-append
|
|
'evil-insert-line
|
|
'evil-append-line))
|
|
(use-package evil-collection
|
|
:after evil
|
|
:diminish evil-collection-unimpaired-mode
|
|
:config
|
|
(evil-collection-init))
|
|
(use-package evil-surround
|
|
:after evil
|
|
:config
|
|
(evil-define-key 'operator evil-surround-mode-map
|
|
"z" #'evil-surround-edit
|
|
"Z" #'evil-Surround-edit)
|
|
(evil-define-key 'visual evil-surround-mode-map
|
|
"gz" #'evil-surround-region
|
|
"gZ" #'evil-Surround-region)
|
|
(global-evil-surround-mode 1))
|
|
(use-package evil-terminal-cursor-changer
|
|
:after evil
|
|
:config
|
|
(evil-terminal-cursor-changer-activate))
|
|
(use-package evil-numbers
|
|
:after evil
|
|
:bind (("C-c =" . evil-numbers/inc-at-pt)
|
|
("C-c +" . evil-numbers/inc-at-pt)
|
|
("C-c -" . evil-numbers/dec-at-pt)
|
|
("C-c C-=" . evil-numbers/inc-at-pt-incremental)
|
|
("C-c C-+" . evil-numbers/inc-at-pt-incremental)
|
|
("C-c C--" . evil-numbers/dec-at-pt-incremental)))
|
|
(use-package evil-cleverparens
|
|
:hook ((prog-mode . my/-enable-evil-cleverparens)
|
|
(evil-cleverparens-mode . paredit-mode))
|
|
:bind (:map paredit-mode-map
|
|
("C-<return>" . paredit-RET)
|
|
("C-RET" . paredit-RET)
|
|
:map evil-cleverparens-mode-map
|
|
("C-c o" . evil-cp-open-below-form))
|
|
:custom
|
|
(evil-cleverparens-use-s-and-S nil)
|
|
:config
|
|
(eldoc-add-command 'paredit-RET
|
|
'paredit-open-round
|
|
'paredit-open-angled
|
|
'paredit-open-bracket
|
|
'paredit-open-angled
|
|
'paredit-open-parenthesis
|
|
'delete-indentation
|
|
'evil-cp-insert
|
|
'evil-cp-append
|
|
'evil-cp-insert-at-beginning-of-form
|
|
'evil-cp-insert-at-end-of-form)
|
|
(keymap-unset evil-cleverparens-mode-map "<normal-state> M-o" t)
|
|
(defun my/-enable-evil-cleverparens ()
|
|
(if (member major-mode '(lisp-mode emacs-lisp-mode
|
|
lisp-interaction-mode))
|
|
(evil-cleverparens-mode 1)
|
|
(electric-pair-local-mode 1)))
|
|
(cl-defun my/range-inside-thing-p (thing beg end &optional no-edge)
|
|
"Return non-nil if BEG and END fall inside the bounds of THING.
|
|
With NO-EDGE, return nil if beg or end fall on the edge of the range."
|
|
(save-excursion
|
|
;; this fixes that fact that `thing-at-point-bounds-of-string-at-point'
|
|
;; errors if called at the end of the buffer
|
|
(condition-case _
|
|
(let ((sb (progn (goto-char beg) (bounds-of-thing-at-point thing)))
|
|
(eb (progn (goto-char end) (bounds-of-thing-at-point thing))))
|
|
(and sb eb (equal sb eb)
|
|
(or (not no-edge)
|
|
(and (/= beg (car sb))
|
|
(< beg (cdr sb))
|
|
(/= end (car sb))
|
|
(< end (cdr sb))))))
|
|
;; if the error happens, we aren't in a string
|
|
(wrong-type-argument nil))))
|
|
(defun my/-evil-cp-region-ok-p-no-string (oldfun beg end)
|
|
(or
|
|
(and (sp-point-in-comment beg)
|
|
(sp-point-in-comment end))
|
|
(and (sp-point-in-string beg)
|
|
(sp-point-in-string end)
|
|
(my/range-inside-thing-p 'string beg end t))
|
|
(funcall oldfun beg end)))
|
|
(defun my/column-num-at-pos (pos)
|
|
"Return the column number at POS."
|
|
(save-excursion
|
|
(goto-char pos)
|
|
(current-column)))
|
|
(defun my/-evil-cp-block-ok-p-no-string (oldfun beg end)
|
|
(when (> beg end) (cl-rotatef beg end))
|
|
(or
|
|
(save-excursion
|
|
(goto-char beg)
|
|
(let ((start-off (current-column))
|
|
(end-off (my/column-num-at-pos end)))
|
|
(cl-block nil
|
|
(dotimes (_ (count-lines beg end) t)
|
|
(let ((bol (pos-bol)))
|
|
(unless (sp-region-ok-p (+ bol start-off)
|
|
(+ bol end-off))
|
|
(cl-return))
|
|
(forward-line))))))
|
|
(funcall oldfun beg end)))
|
|
(advice-add 'sp-region-ok-p :around 'my/-evil-cp-region-ok-p-no-string)
|
|
(advice-add 'evil-cp--balanced-block-p :around 'my/-evil-cp-block-ok-p-no-string))
|
|
|
|
;; make lisp editing nicer
|
|
(use-package aggressive-indent
|
|
:hook (prog-mode . aggressive-indent-mode)
|
|
:config
|
|
(add-to-list 'aggressive-indent-protected-commands
|
|
#'evil-undo))
|
|
|
|
;; and nicer
|
|
(use-package adjust-parens
|
|
:hook (prog-mode . adjust-parens-mode)
|
|
:config
|
|
(defun my/lisp-indent-adjust-parens ()
|
|
"Like `lisp-indent-adjust-parens', but got to first char on line first.
|
|
Also, this works even if the region is active (it indents every line in the
|
|
region)."
|
|
(interactive)
|
|
(save-mark-and-excursion
|
|
(let ((end (mark t))
|
|
(line-count 1)
|
|
(indent-cols))
|
|
(when (and (region-active-p) end)
|
|
(setq mark-active nil
|
|
line-count (count-lines (point) end))
|
|
(when (> (point) end)
|
|
(let ((start (point)))
|
|
(goto-char end)
|
|
(setq end start))))
|
|
;; find the indentation column of each line
|
|
(save-excursion
|
|
(dotimes (_ line-count)
|
|
(back-to-indentation)
|
|
(push (- (point) (pos-bol)) indent-cols)
|
|
(forward-line))
|
|
(cl-callf nreverse indent-cols))
|
|
(cl-loop repeat line-count
|
|
for indent-col in indent-cols
|
|
for bol = (pos-bol)
|
|
do (back-to-indentation)
|
|
;; skip this line if the indentation has changed
|
|
when (= (- (point) bol) indent-col) do
|
|
(lisp-indent-adjust-parens)
|
|
;; if the indent failed, stop
|
|
(when (= (- (point) bol) indent-col)
|
|
(cl-return))
|
|
do (forward-line)))))
|
|
(defun my/lisp-dedent-adjust-parens ()
|
|
"Like `lisp-dedent-adjust-parens', but got to first char on line first.
|
|
Also, this works even if the region is active (it just jumps to the first line
|
|
in the region and indents once)."
|
|
(interactive)
|
|
(save-mark-and-excursion
|
|
(let ((end (mark t)))
|
|
(when (and (region-active-p) end)
|
|
(setq mark-active nil)
|
|
(when (> (point) end)
|
|
(goto-char end))))
|
|
(back-to-indentation)
|
|
(lisp-dedent-adjust-parens)))
|
|
(eldoc-add-command 'my/lisp-indent-adjust-parens
|
|
'my/lisp-dedent-adjust-parens
|
|
'lisp-indent-adjust-parens
|
|
'lisp-dedent-adjust-parens)
|
|
(evil-define-key '(normal visual) adjust-parens-mode-map
|
|
(kbd "<tab>") #'my/lisp-indent-adjust-parens
|
|
(kbd "<backtab>") #'my/lisp-dedent-adjust-parens))
|
|
|
|
;; for when the files are just too large
|
|
(use-package vlf
|
|
:demand t
|
|
:config
|
|
(require 'vlf-setup))
|
|
|
|
;; allow copy from terminal
|
|
(use-package xclip
|
|
:config
|
|
(xclip-mode 1))
|
|
|
|
;; which-key
|
|
(use-package which-key
|
|
:diminish which-key-mode
|
|
:config
|
|
(which-key-mode 1))
|
|
|
|
;; avy
|
|
(use-package avy
|
|
:bind (("C-c C-j" . avy-resume)
|
|
("M-s s" . evil-avy-goto-char-2)
|
|
("M-s S" . evil-avy-goto-line))
|
|
:init
|
|
(define-minor-mode my/evil-avy-mode
|
|
"A minor mode for binding avy commands to s and S in evil's normal and
|
|
visual states."
|
|
:keymap (make-sparse-keymap))
|
|
(evil-define-key '(normal visual operator motion) my/evil-avy-mode-map
|
|
"s" #'evil-avy-goto-char-2
|
|
"S" #'evil-avy-goto-line)
|
|
(define-globalized-minor-mode my/evil-avy-global-mode my/evil-avy-mode
|
|
(lambda () (my/evil-avy-mode 1))
|
|
:predicate '((not magit-mode dired-mode
|
|
proced-mode mu4e-main-mode
|
|
mu4e-view-mode mu4e-headers-mode
|
|
ibuffer-mode calc-mode calc-trail-mode
|
|
gnus-group-mode) t))
|
|
(my/evil-avy-global-mode 1)
|
|
:config
|
|
(avy-setup-default))
|
|
|
|
;; ace-window
|
|
(use-package ace-window
|
|
:diminish ace-window-mode
|
|
:bind ("M-o" . ace-window)
|
|
:init
|
|
(setq aw-scope 'frame
|
|
aw-minibuffer-flag t))
|
|
|
|
;; savehist
|
|
(use-package savehist
|
|
:config
|
|
(savehist-mode 1))
|
|
|
|
;; vertico
|
|
(use-package vertico
|
|
:bind (:map vertico-map
|
|
("C-RET" . vertico-exit-input)
|
|
("C-<return>" . vertico-exit-input)
|
|
("C-S-k" . kill-line)
|
|
("C-k" . vertico-previous)
|
|
("C-j" . vertico-next)
|
|
("RET" . vertico-directory-enter)
|
|
("DEL" . vertico-directory-delete-char)
|
|
("M-DEL" . vertico-directory-delete-word))
|
|
:hook (minibuffer-setup . cursor-intangible-mode)
|
|
:init
|
|
(defun my/crm-indicator (args)
|
|
(cons (format "[CRM%s] %s"
|
|
(replace-regexp-in-string
|
|
"\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
|
|
crm-separator)
|
|
(car args))
|
|
(cdr args)))
|
|
(advice-add #'completing-read-multiple :filter-args #'my/crm-indicator)
|
|
(setq vertico-cycle t
|
|
enable-recursive-minibuffers t
|
|
;; read-extended-command-predicate #'command-completion-default-include-p
|
|
read-extended-command-predicate nil
|
|
minibuffer-prompt-properties '(read-only t ;; noindent 3
|
|
cursor-intangible t
|
|
face minibuffer-prompt))
|
|
(vertico-mode 1)
|
|
;; for jinx
|
|
(require 'vertico-multiform)
|
|
(add-to-list 'vertico-multiform-categories
|
|
'(jinx grid (vertico-grid-annotate . 20)))
|
|
(vertico-multiform-mode 1))
|
|
|
|
;; orderless
|
|
(use-package orderless
|
|
:autoload orderless-define-completion-style
|
|
:hook (text-mode . my/-setup-text-mode-completion-styles)
|
|
:init
|
|
(defun my/-setup-text-mode-completion-styles ()
|
|
(setq-local completion-styles '(basic)))
|
|
(orderless-define-completion-style my/orderless-with-initialism
|
|
(orderless-matching-styles '(orderless-initialism
|
|
orderless-regexp)))
|
|
(setq orderless-matching-styles '(orderless-regexp)
|
|
completion-styles '(orderless basic)
|
|
completion-category-defaults nil
|
|
completion-category-overrides '((file
|
|
(styles basic partial-completion))
|
|
(command
|
|
(styles my/orderless-with-initialism basic)))))
|
|
|
|
;; marginalia
|
|
(use-package marginalia
|
|
:bind (:map minibuffer-local-map
|
|
("M-a" . marginalia-cycle))
|
|
:init
|
|
(marginalia-mode 1))
|
|
|
|
;; embark
|
|
(use-package embark
|
|
:bind (("C-," . embark-act)
|
|
("C-;" . embark-dwim)
|
|
:map help-map
|
|
("B" . embark-bindings)
|
|
:map embark-symbol-map
|
|
("h" . helpful-symbol)
|
|
:map embark-become-file+buffer-map
|
|
("b" . consult-buffer)
|
|
("B" . switch-to-buffer))
|
|
:init
|
|
(setq embark-quit-after-action nil
|
|
embark-indicators '(embark-minimal-indicator
|
|
embark-isearch-highlight-indicator
|
|
embark-highlight-indicator))
|
|
:config
|
|
(defvar-keymap my/embark-string-map
|
|
:doc "Keymap for Embark string actions."
|
|
:parent embark-expression-map
|
|
"R" 'repunctuate-sentences)
|
|
(defun my/embark-target-string ()
|
|
"Target the string at point."
|
|
(if-let (((not (eobp))) ; prevent next line from causing errors
|
|
(bounds (bounds-of-thing-at-point 'string)))
|
|
(append (list 'string (buffer-substring-no-properties (car bounds)
|
|
(cdr bounds)))
|
|
bounds)))
|
|
(add-to-list 'embark-around-action-hooks
|
|
'(repunctuate-sentences embark--mark-target))
|
|
(add-to-list 'embark-keymap-alist
|
|
'(string my/embark-string-map))
|
|
(add-to-list 'embark-target-finders 'my/embark-target-string)
|
|
(add-to-list 'display-buffer-alist
|
|
'("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
|
|
nil
|
|
(window-parameters (mode-line-format . none))))
|
|
(evil-define-key '(normal motion) org-mode-map
|
|
(kbd "C-,") #'embark-act))
|
|
|
|
;; consult
|
|
(use-package consult
|
|
:bind (("C-s" . consult-line)
|
|
("C-x b" . consult-buffer)
|
|
("C-S-s" . consult-ripgrep)
|
|
("C-x C-S-f" . consult-fd)
|
|
("C-x c k" . consult-keep-lines)
|
|
("C-x c f" . consult-focus-lines)
|
|
("C-x c r" . consult-recent-file)
|
|
("C-x c b" . consult-bookmark)
|
|
("C-x c d" . consult-fd)
|
|
("C-x c g" . consult-ripgrep)
|
|
("C-x c y" . consult-yank-from-kill-ring)
|
|
("M-g i" . consult-imenu)
|
|
("M-g I" . consult-imenu-multi)
|
|
("M-g r" . consult-imenu-multi)
|
|
:map help-map
|
|
("TAB". consult-info)
|
|
("C-m" . consult-man))
|
|
:hook (minibuffer-setup . my/consult-setup-minibuffer-completion)
|
|
:init
|
|
(defun my/consult-setup-minibuffer-completion ()
|
|
(setq-local completion-in-region-function #'consult-completion-in-region))
|
|
(evil-declare-motion #'consult-line))
|
|
(use-package consult-eglot
|
|
:commands consult-eglot-symbols)
|
|
|
|
;; wgrep
|
|
(use-package wgrep)
|
|
|
|
;; integration for embark and consult
|
|
(use-package embark-consult
|
|
:hook (embark-collect-mode . consult-preview-at-point-mode))
|
|
|
|
;; corfu (autocomplete)
|
|
(use-package corfu
|
|
:bind (("M-<tab>" . completion-at-point)
|
|
:map corfu-map
|
|
("C-j" . corfu-next)
|
|
("C-k" . corfu-previous)
|
|
("M-SPC" . corfu-insert-separator)
|
|
("M-m" . my/corfu-move-to-minibuffer))
|
|
:init
|
|
(defun my/corfu-move-to-minibuffer ()
|
|
(interactive)
|
|
(when completion-in-region--data
|
|
(let ((completion-extra-properties corfu--extra)
|
|
(completion-cycle-threshold completion-cycling))
|
|
(apply #'consult-completion-in-region completion-in-region--data))))
|
|
(setq corfu-cycle t
|
|
corfu-auto t
|
|
corfu-on-exact-match nil
|
|
corfu-popupinfo-delay '(1.0 . 0.5)
|
|
completion-cycle-threshold nil
|
|
global-corfu-minibuffer
|
|
;; only enable corfu in the minibuffer in graphical frames
|
|
(lambda ()
|
|
(and (display-graphic-p)
|
|
(not (eq (current-local-map)
|
|
read-passwd-map)))))
|
|
(global-corfu-mode 1)
|
|
(corfu-popupinfo-mode 1)
|
|
:config
|
|
(add-to-list 'corfu-continue-commands #'my/corfu-move-to-minibuffer)
|
|
(defun my/help-buffer-exists-p ()
|
|
"Return if the buffer that `help-buffer' would, or nil if it doesn't exist."
|
|
(or (and help-xref-following (derived-mode-p 'help-mode))
|
|
(get-buffer "*Help*")))
|
|
(defun my/-corfu-popupinfo-close-help-buffer (oldfun &rest args)
|
|
(if (derived-mode-p 'emacs-lisp-mode)
|
|
(let ((help-buf (my/help-buffer-exists-p)))
|
|
(prog1
|
|
(apply oldfun args)
|
|
(when-let (((not help-buf))
|
|
(buf (help-buffer)))
|
|
;; Ensure that, even if `help-buffer' returns nil in the future, we
|
|
;; don't kill the current buffer
|
|
(kill-buffer buf))))
|
|
(apply oldfun args)))
|
|
(advice-add 'corfu-popupinfo--get-documentation :around
|
|
'my/-corfu-popupinfo-close-help-buffer))
|
|
(use-package corfu-terminal
|
|
:init
|
|
(corfu-terminal-mode 1)
|
|
:config
|
|
(require 'corfu-terminal-popupinfo)
|
|
(corfu-terminal-popupinfo-mode 1))
|
|
|
|
(use-package dabbrev
|
|
:ensure nil
|
|
:config
|
|
(add-to-list 'dabbrev-ignored-buffer-regexps "\\` ")
|
|
(add-to-list 'dabbrev-ignored-buffer-modes 'doc-view-mode)
|
|
(add-to-list 'dabbrev-ignored-buffer-modes 'pdf-view-mode)
|
|
(add-to-list 'dabbrev-ignored-buffer-modes 'tags-table-mode))
|
|
|
|
;; cape (a bunch of capfs!)
|
|
(use-package cape
|
|
:bind (("C-c p" . cape-dabbrev)
|
|
([remap dabbrev-expand] . cape-dabbrev)
|
|
("C-c P" . cape-line)
|
|
("C-c f" . cape-file))
|
|
:hook (text-mode . my/-cape-setup-text-mode)
|
|
:init
|
|
(defun my/-cape-setup-text-mode ()
|
|
;; Only run this if we are not in `TeX-mode'
|
|
(unless (bound-and-true-p TeX-mode-p)
|
|
(setq-local completion-at-point-functions
|
|
(append completion-at-point-functions (list 'cape-dict
|
|
'cape-dabbrev))
|
|
corfu-auto nil))))
|
|
|
|
;; xref
|
|
(use-package xref
|
|
:init
|
|
(evil-define-key '(normal motion) 'global
|
|
"gr" #'xref-find-references)
|
|
(setq xref-show-xrefs-function #'consult-xref
|
|
xref-show-definitions-function #'consult-xref))
|
|
|
|
;; popup.el
|
|
(use-package popup)
|
|
|
|
;; posframe
|
|
(use-package posframe
|
|
:init
|
|
(defun my/posframe-tip (name msg)
|
|
"Like `popup-tip', but with a posframe.
|
|
NAME should be the buffer name to pass to `posframe-show'. MSG is the message to
|
|
display."
|
|
(unwind-protect
|
|
(progn
|
|
(posframe-show name
|
|
:string msg
|
|
:position (point)
|
|
:max-width 80
|
|
:border-width 2
|
|
:border-color "white")
|
|
(clear-this-command-keys)
|
|
(push (read-event) unread-command-events)
|
|
(posframe-hide name))
|
|
(posframe-hide name))))
|
|
|
|
(defun my/floating-tooltip (name msg)
|
|
"If `display-graphic-p', call `my/posframe-tip', otherwise `popup-tip'.
|
|
MSG is the message to show in the popup. NAME is the name of the buffer to pass
|
|
to `posframe-show' if the display is graphical."
|
|
(if (display-graphic-p)
|
|
(my/posframe-tip name msg)
|
|
(popup-tip msg)))
|
|
|
|
;; flymake
|
|
(use-package flymake
|
|
:config
|
|
(require 'consult-flymake))
|
|
|
|
;; flycheck
|
|
(use-package flycheck
|
|
:hook ((sh-mode emacs-lisp-mode) . flycheck-mode)
|
|
:custom
|
|
(flycheck-indication-mode 'left-margin)
|
|
:init
|
|
(setq flycheck-display-errors-function nil))
|
|
(use-package consult-flycheck)
|
|
|
|
(defun my/diagnostic-at-point ()
|
|
"Show the diagnostics under point."
|
|
(interactive)
|
|
(let ((message))
|
|
(when-let ((flymake-mode)
|
|
(diag (get-char-property (point) 'flymake-diagnostic)))
|
|
(cl-callf nconc message (string-split (flymake--diag-text diag) "\n" t)))
|
|
(when flycheck-mode
|
|
(cl-callf nconc message
|
|
(mapcar 'flycheck-error-message (flycheck-overlay-errors-at (point)))))
|
|
;; jinx
|
|
(when-let ((jinx-msg (jinx--get-overlays (point) (1+ (point)))))
|
|
(push "misspelled word" message))
|
|
(when message
|
|
(my/floating-tooltip " *my-diagnostic-posframe*"
|
|
(mapconcat (lambda (msg)
|
|
(concat "•" msg))
|
|
message "\n")))))
|
|
|
|
(defconst my/consult-flymake-flycheck-narrow
|
|
'((?e . "Error")
|
|
(?w . "Warning")
|
|
(?i . "Info")
|
|
(?n . "Info")))
|
|
|
|
(defun my/-consult-replace-flymake-error-level (candidates)
|
|
"Return CANDIDATES with the flymake error level note replaced with info."
|
|
(cl-loop for cand in candidates
|
|
collect
|
|
(cl-loop
|
|
with start = nil
|
|
for i below (length cand)
|
|
for props = (text-properties-at i cand)
|
|
for face = (plist-get props 'face)
|
|
when (eq face 'compilation-info) do
|
|
(setq start (or start i))
|
|
else when start do
|
|
(setf (substring cand start i)
|
|
(propertize (string-pad "info" (- i start))
|
|
'face (flycheck-error-level-error-list-face
|
|
'info)))
|
|
(cl-return cand)
|
|
finally return cand)))
|
|
|
|
(defun my/consult-flymake-flycheck-candidates (&optional project)
|
|
"Return combined candidate list for flymake and flycheck.
|
|
With PROJECT, return the candiadeets for that project."
|
|
(let ((had-errors))
|
|
(prog1
|
|
(seq-uniq
|
|
(append
|
|
(when-let (((bound-and-true-p flymake-mode))
|
|
(diags (if project (flymake--project-diagnostics
|
|
project)
|
|
(flymake-diagnostics))))
|
|
(setq had-errors t)
|
|
(my/-consult-replace-flymake-error-level
|
|
(consult-flymake--candidates diags)))
|
|
(when (boundp 'flycheck-mode)
|
|
(if project
|
|
(cl-loop for buf in (project-buffers project)
|
|
append
|
|
(with-current-buffer buf
|
|
(when (and flycheck-mode flycheck-current-errors)
|
|
(setq had-errors t)
|
|
(consult-flycheck--candidates))))
|
|
(when (and flycheck-mode flycheck-current-errors)
|
|
(setq had-errors t)
|
|
(consult-flycheck--candidates))))))
|
|
(unless had-errors
|
|
(user-error "No errors (Flymake: %s | Flycheck: %s)"
|
|
(cond
|
|
((not (bound-and-true-p flymake-mode))
|
|
"not running")
|
|
((seq-difference (flymake-running-backends)
|
|
(flymake-reporting-backends))
|
|
"running")
|
|
(t "finished"))
|
|
(if (boundp 'flycheck-last-status-change)
|
|
flycheck-last-status-change
|
|
"not running"))))))
|
|
|
|
(defun my/consult-flymake-flycheck (&optional project)
|
|
"Jump to flymake or flycheck error.
|
|
With PROJECT, give diagnostics for all buffers in the current project."
|
|
(interactive "P")
|
|
(consult--read
|
|
(consult--with-increased-gc
|
|
(my/consult-flymake-flycheck-candidates
|
|
(and project (project-current))))
|
|
:prompt "Error: "
|
|
:category 'flymake-flycheck-error
|
|
:history t
|
|
:require-match t
|
|
:sort nil
|
|
:narrow (consult--type-narrow my/consult-flymake-flycheck-narrow)
|
|
:group (consult--type-group my/consult-flymake-flycheck-narrow)
|
|
:lookup #'consult--lookup-candidate
|
|
:state (consult--jump-state)))
|
|
(with-eval-after-load 'flymake
|
|
(keymap-set flymake-mode-map "C-c e" 'my/diagnostic-at-point)
|
|
(keymap-set flymake-mode-map "C-c E" 'my/consult-flymake-flycheck))
|
|
(with-eval-after-load 'flycheck
|
|
(keymap-set flycheck-mode-map "C-c e" 'my/diagnostic-at-point)
|
|
(keymap-set flycheck-mode-map "C-c E" 'my/consult-flymake-flycheck))
|
|
(with-eval-after-load 'jinx
|
|
(keymap-set jinx-mode-map "C-c e" 'my/diagnostic-at-point))
|
|
|
|
;; eldoc
|
|
(use-package eldoc
|
|
:diminish eldoc-mode
|
|
:init
|
|
(setq-default eldoc-echo-area-use-multiline-p nil))
|
|
|
|
;; eglot
|
|
(use-package eglot
|
|
:demand t
|
|
:pin gnu ;; try to force Elpa version to fix warnings
|
|
:hook ((eglot-managed-mode . my/-eglot-setup))
|
|
:init
|
|
;; (defun my/eglot-in-text-mode-only ()
|
|
;; (when (eq major-mode 'text-mode)
|
|
;; (eglot-ensure)))
|
|
(defvar my/-eglot-documentation-buffer nil
|
|
"Buffer for showing documentation for `my/eglot-documentation-at-point'.")
|
|
(defun my/eglot-documentation-at-point ()
|
|
"Show documentation for a symbol at point."
|
|
(interactive)
|
|
(if-let (server (eglot-current-server))
|
|
(progn
|
|
(if-let* (((not (buffer-live-p my/-eglot-documentation-buffer)))
|
|
(name (generate-new-buffer-name "*eglot documentation*")))
|
|
(setq my/-eglot-documentation-buffer (generate-new-buffer name)))
|
|
(eglot-hover-eldoc-function
|
|
(lambda (info _ _)
|
|
(if-let (((not (seq-empty-p info)))
|
|
(buff (current-buffer)))
|
|
(with-current-buffer my/-eglot-documentation-buffer
|
|
(read-only-mode -1)
|
|
(erase-buffer)
|
|
(insert info)
|
|
(goto-char (point-min))
|
|
(special-mode)
|
|
(read-only-mode 1)
|
|
(when (not (get-buffer-window my/-eglot-documentation-buffer nil))
|
|
(switch-to-buffer-other-window my/-eglot-documentation-buffer t)
|
|
(switch-to-buffer-other-window buff t)))))))))
|
|
(defun my/-eglot-cleanup-doc-buffer (_server &optional _interactive _timeout
|
|
preserve-buffers)
|
|
(when (and (not preserve-buffers)
|
|
(buffer-live-p my/-eglot-documentation-buffer)
|
|
(cl-every (lambda (buffer)
|
|
(with-current-buffer buffer
|
|
(let ((server (eglot-current-server)))
|
|
(or (not (eglot-lsp-server-p server))
|
|
(eglot--shutdown-requested server)))))
|
|
(buffer-list)))
|
|
(kill-buffer my/-eglot-documentation-buffer)))
|
|
(advice-add 'eglot-shutdown :after 'my/-eglot-cleanup-doc-buffer)
|
|
(defun my/-eglot-setup ()
|
|
"Setup eldoc variables for `eglot-managed-mode-hook'."
|
|
(setq-local evil-lookup-func #'my/eglot-documentation-at-point)
|
|
(evil-define-key '(normal motion) 'local
|
|
"K" #'evil-lookup
|
|
"gR" #'eglot-rename
|
|
"gA" #'eglot-code-actions
|
|
"gs" #'consult-eglot-symbols)
|
|
(eglot-inlay-hints-mode -1))
|
|
(setq eglot-autoshutdown t)
|
|
:config
|
|
(add-to-list 'eglot-server-programs
|
|
(cons '(c-mode c-ts-mode c++-mode c++-ts-mode objc-mode)
|
|
'("clangd" "--all-scopes-completion" "--background-index"
|
|
"--clang-tidy" "--completion-style=detailed"
|
|
"--header-insertion=never" "--pch-storage=memory"
|
|
"--function-arg-placeholders"))))
|
|
|
|
;; LTeX (languagetool)
|
|
(require 'ltex-eglot)
|
|
|
|
;; gud
|
|
(use-package gud
|
|
:demand t
|
|
:ensure nil
|
|
:after (project evil)
|
|
:bind (:map project-prefix-map
|
|
("U" . my/project-gdb))
|
|
:config
|
|
(setq gdb-debuginfod-enable-setting t)
|
|
(defvar my/project-gdb-command nil
|
|
"Command to use in `my/project-gdb'.")
|
|
(put 'my/project-gdb-command 'safe-local-variable (lambda (val)
|
|
(stringp val)))
|
|
(defun my/project-gdb (project command-line)
|
|
"Run gdb in the project root"
|
|
(interactive (let* ((project (project-current t))
|
|
(default-directory (project-root project)))
|
|
(list project (gud-query-cmdline 'gdb))))
|
|
(let ((default-directory (project-root project)))
|
|
(gdb command-line)))
|
|
(evil-set-initial-state 'gdb-locals-mode 'motion)
|
|
(evil-collection-inhibit-insert-state 'gdb-locals-mode-map)
|
|
(evil-define-key '(normal motion visual) gdb-locals-mode-map
|
|
(kbd "TAB") (keymap-lookup gdb-locals-mode-map "TAB")
|
|
(kbd "RET") #'gdb-edit-locals-value
|
|
(kbd "<mouse-1>") #'gdb-edit-locals-value
|
|
"q" #'kill-current-buffer)
|
|
(evil-set-initial-state 'gdb-registers-mode 'motion)
|
|
(evil-collection-inhibit-insert-state 'gdb-registers-mode-map)
|
|
(evil-define-key '(normal motion visual) gdb-registers-mode-map
|
|
(kbd "TAB") (keymap-lookup gdb-registers-mode-map "TAB")
|
|
(kbd "RET") #'gdb-edit-register-value
|
|
(kbd "<mouse-1>") #'gdb-edit-register-value
|
|
"q" #'kill-current-buffer
|
|
(kbd "C-c f") #'gdb-registers-toggle-filter
|
|
(kbd "C-c F") (lambda ()
|
|
"Customize the filter for the registers buffer."
|
|
(interactive)
|
|
(customize-option-other-window
|
|
'gdb-registers-filter-pattern-list)))
|
|
(evil-set-initial-state 'gdb-frames-mode 'motion)
|
|
(evil-collection-inhibit-insert-state 'gdb-frames-mode-map)
|
|
(evil-define-key '(normal motion visual) gdb-frames-mode-map
|
|
"q" #'kill-current-buffer
|
|
(kbd "RET") #'gdb-select-frame)
|
|
(evil-set-initial-state 'gdb-breakpoints-mode 'motion)
|
|
(evil-collection-inhibit-insert-state 'gdb-breakpoints-mode-map)
|
|
(evil-define-key '(normal motion visual) gdb-breakpoints-mode-map
|
|
(kbd "TAB") (keymap-lookup gdb-breakpoints-mode-map "TAB")
|
|
"q" #'gdb-delete-frame-or-window
|
|
"D" #'gdb-delete-breakpoint
|
|
(kbd "RET") #'gdb-goto-breakpoint
|
|
(kbd "<mouse-1>") #'gdb-goto-breakpoint
|
|
(kbd "SPC") #'gdb-toggle-breakpoint)
|
|
(evil-set-initial-state 'gdb-threads-mode 'motion)
|
|
(evil-collection-inhibit-insert-state 'gdb-threads-mode-map)
|
|
(evil-define-key '(normal motion visual) gdb-threads-mode-map
|
|
(kbd "TAB") (keymap-lookup gdb-threads-mode-map "TAB")
|
|
"q" #'gdb-delete-frame-or-window
|
|
"D" #'gdb-frame-disassembly-for-thread
|
|
(kbd "C-c f") #'gdb-display-stack-for-thread
|
|
(kbd "C-c i") #'gdb-interrupt-thread
|
|
(kbd "C-c l") #'gdb-display-locals-for-thread
|
|
(kbd "C-c r") #'gdb-display-registers-for-thread
|
|
(kbd "C-c c") #'gdb-continue-thread
|
|
(kbd "C-c d") #'gdb-display-disassembly-for-thread
|
|
(kbd "C-c s") #'gdb-step-thread
|
|
(kbd "C-c F") #'gdb-frame-stack-for-thread
|
|
(kbd "C-c L") #'gdb-frame-locals-for-thread
|
|
(kbd "C-c R") #'gdb-frame-registers-for-thread
|
|
(kbd "RET") #'gdb-select-thread
|
|
(kbd "<mouse-2>") #'gdb-select-thread))
|
|
|
|
;; dape
|
|
(use-package dape
|
|
:hook ((after-init . dape-breakpoint-load)
|
|
(kill-emacs . dape-breakpoint-save)
|
|
(dape-start . save-some-buffers)
|
|
(dape-display-source . pulse-momentary-highlight-one-line))
|
|
:bind (:map dape-info-parent-mode-map
|
|
("<tab>" . dape--info-buffer-tab))
|
|
:init
|
|
(setopt dape-default-breakpoints-file (no-littering-expand-var-file-name
|
|
"dape-breakpoints"))
|
|
:config
|
|
(setopt dape-buffer-window-arrangement 'right)
|
|
(dape-breakpoint-global-mode 1))
|
|
|
|
;; dumb-jump
|
|
(use-package dumb-jump
|
|
:init
|
|
(add-hook 'xref-backend-functions #'dumb-jump-xref-activate))
|
|
|
|
;; yasnippet
|
|
(use-package yasnippet
|
|
:demand t
|
|
:bind ("C-c s" . yas-expand)
|
|
:config
|
|
(yas-global-mode 1))
|
|
|
|
;; project.el
|
|
(use-package project
|
|
:bind (("C-c v" . my/project-eshell-or-default)
|
|
([remap project-compile] . my/project-compile-or-default)
|
|
:map project-prefix-map
|
|
("s" . my/project-eshell)
|
|
("u" . my/project-run))
|
|
:init
|
|
(defvar eshell-buffer-name)
|
|
(defun my/project-eshell (prompt &optional arg)
|
|
"Switch to or create an eshell buffer in the current projects root."
|
|
(interactive (list t current-prefix-arg))
|
|
(if-let ((proj (project-current prompt))
|
|
(default-directory (project-root proj))
|
|
(eshell-buffer-name
|
|
(concat "*eshell for project " default-directory "*")))
|
|
(eshell arg)))
|
|
(defun my/project-eshell-or-default (&optional arg)
|
|
"Open an eshell for the current project, otherwise, open a normal eshell."
|
|
(interactive "P")
|
|
(unless (my/project-eshell nil arg)
|
|
(eshell arg)))
|
|
(defun my/project-compile-or-default ()
|
|
"If in a project, run `project-compile', otherwise run `compile'."
|
|
(interactive)
|
|
(if (project-current)
|
|
(call-interactively 'project-compile)
|
|
(call-interactively 'compile)))
|
|
(defvar my/project-run-command nil
|
|
"Command to run with `my/project-run'.")
|
|
(put 'my/project-run-command 'safe-local-variable (lambda (val)
|
|
(stringp val)))
|
|
(defvar my/project-run-dir nil
|
|
"Directory to run project in with `my/project-run'.")
|
|
(put 'my/project-run-dir 'safe-local-variable (lambda (val)
|
|
(stringp val)))
|
|
(defvar my/-project-run-history '()
|
|
"Commands previously run with `my/project-run'")
|
|
(defvar my/project-root-marker ".project-root"
|
|
"Marker file to look for in non-vc backed projects.")
|
|
(defun my/project-get-root-dir ()
|
|
"Get the root dir for the current project"
|
|
(let* ((proj (project-current nil))
|
|
(default-directory (if proj
|
|
(project-root proj)
|
|
default-directory)))
|
|
(if my/project-run-dir
|
|
(expand-file-name my/project-run-dir)
|
|
default-directory)))
|
|
(defun my/project-run (command comint)
|
|
"Like `project-compile', but for running a project.
|
|
COMMAND and COMINT are like `compile'."
|
|
(interactive
|
|
(list
|
|
(let ((default-directory (my/project-get-root-dir)))
|
|
(read-shell-command "Run Command: "
|
|
(or (car my/-project-run-history)
|
|
my/project-run-command)
|
|
(if (and my/project-run-command
|
|
(equal my/project-run-command
|
|
(car-safe my/-project-run-history)))
|
|
'(my/-project-run-history . 1)
|
|
'my/-project-run-history)))
|
|
(consp current-prefix-arg)))
|
|
(let* ((default-directory (my/project-get-root-dir))
|
|
(compilation-buffer-name-function (lambda (_)
|
|
(progn "*run project*")))
|
|
(compilation-directory default-directory)
|
|
(compile-history nil)
|
|
(compile-command nil))
|
|
(compile command comint)
|
|
(when (not my/project-run-command)
|
|
(setq my/project-run-command command))))
|
|
:config
|
|
(defun my/project-try-dotfile (dir)
|
|
(if-let (root (locate-dominating-file dir my/project-root-marker))
|
|
(list 'vc nil root)))
|
|
(add-hook 'project-find-functions #'my/project-try-dotfile))
|
|
|
|
;; nxml
|
|
(use-package nxml-mode
|
|
:ensure nil
|
|
:hook (nxml-mode . my/-nxml-setup)
|
|
:init
|
|
(defun my/-nxml-setup ()
|
|
"Setup `nxml-mode'."
|
|
(sgml-electric-tag-pair-mode 1)
|
|
(setq-local completion-at-point-functions
|
|
'(rng-completion-at-point cape-file)))
|
|
(add-to-list 'auto-mode-alist
|
|
`(,(concat
|
|
(regexp-opt '("gschema" "gresource" "ui")) "\\'")
|
|
. nxml-mode)))
|
|
|
|
;; Bibtex (built in)
|
|
(require 'bibtex)
|
|
(defun my/bibtex-in-entry-p (&optional exclude-braces)
|
|
"Return t is point is inside a BibTeX entry.
|
|
When EXCLUDE-BRACES is non-nil, don't count the first and last brace of the
|
|
entry as in the entry. That is, if the point is on the first { or last } of the
|
|
entry, return nil."
|
|
(save-excursion
|
|
(when (and exclude-braces (eq ?\} (char-after)))
|
|
(forward-char))
|
|
;; go to top level and check if the character at point is {
|
|
(let ((start-pos (point))
|
|
(last-valid (point)))
|
|
(condition-case _
|
|
(while t
|
|
(backward-up-list 1 t t)
|
|
(setq last-valid (point)))
|
|
(error
|
|
(and
|
|
(eq ?\{ (char-after last-valid))
|
|
(or (not exclude-braces)
|
|
(not (= start-pos last-valid)))))))))
|
|
(defvar my/bibtex-indent-width 4
|
|
"Width to indent for `my/bibtex-calculate-indentation'.")
|
|
(defun my/bibtex-calculate-indentation ()
|
|
"Calculate the column to indent to on the current line."
|
|
(save-excursion
|
|
(back-to-indentation)
|
|
(if (my/bibtex-in-entry-p t)
|
|
my/bibtex-indent-width
|
|
0)))
|
|
(defun my/bibtex-empty-line-p ()
|
|
"Return t if the current line is only blank characters."
|
|
(save-excursion
|
|
(beginning-of-line)
|
|
(looking-at (rx (* blank) eol))))
|
|
(defun my/bibtex-indent-line ()
|
|
"Indent the current line."
|
|
(interactive)
|
|
(save-excursion
|
|
(beginning-of-line)
|
|
(when (looking-at (rx (+ blank)))
|
|
(delete-region (point) (match-end 0)))
|
|
(indent-to (my/bibtex-calculate-indentation)))
|
|
(when (looking-at (rx (+ blank) eol))
|
|
(end-of-line)))
|
|
(defun my/bibtex-indent-or-find-text ()
|
|
"Either indent the current line or jump to the current fields text.
|
|
If the current line is only whitespace call `my/bibtex-calculate-indentation',
|
|
otherwise, call `bibtex-find-text'."
|
|
(interactive)
|
|
(if (my/bibtex-empty-line-p)
|
|
(my/bibtex-indent-line)
|
|
(bibtex-find-text)))
|
|
(defun my/bibtex-indent-or-find-text-and-insert ()
|
|
"Like `my/bibtex-indent-or-find-text', but enter insert mode after."
|
|
(interactive)
|
|
(my/bibtex-indent-or-find-text)
|
|
(if (my/bibtex-empty-line-p)
|
|
(evil-append 1)
|
|
(evil-insert 1)))
|
|
(defun my/-bibtex-setup-indent ()
|
|
"Set up `bibtex-mode' indentation stuff."
|
|
(setq-local indent-line-function 'my/bibtex-indent-line
|
|
electric-indent-chars '(?\n ?\{ ?\} ?,)))
|
|
(defun my/-bibtex-fix-fill-prefix ()
|
|
"`bivtex-mode' has a bad habbit of messing up `fill-prefix'."
|
|
(when (eq major-mode 'bibtex-mode)
|
|
(setq-local fill-prefix nil)))
|
|
(advice-add 'bibtex-mode :after 'my/-bibtex-fix-fill-prefix)
|
|
(add-hook 'bibtex-mode-hook 'my/-bibtex-setup-indent)
|
|
(keymap-set bibtex-mode-map "RET" 'newline-and-indent)
|
|
(keymap-set bibtex-mode-map "TAB" 'my/bibtex-indent-or-find-text)
|
|
(evil-define-key 'normal bibtex-mode-map
|
|
(kbd "TAB") 'my/bibtex-indent-or-find-text-and-insert)
|
|
|
|
;; Latex help (from elisp file)
|
|
(require 'latex-help)
|
|
|
|
;; AUCTeX
|
|
(use-package auctex
|
|
:hook ((LaTeX-mode . turn-on-reftex)
|
|
(LaTeX-mode . LaTeX-math-mode)
|
|
(LaTeX-mode . my/-setup-LaTeX-mode)
|
|
(LaTeX-mode . flycheck-mode))
|
|
:bind (:map TeX-mode-map
|
|
("C-c ?" . latex-help))
|
|
:init
|
|
(add-to-list 'major-mode-remap-alist '(plain-tex-mode . plain-TeX-mode))
|
|
(add-to-list 'major-mode-remap-alist '(latex-mode . LaTeX-mode))
|
|
(add-to-list 'major-mode-remap-alist '(ams-tex-mode . AmSTeX-mode))
|
|
(add-to-list 'major-mode-remap-alist '(context-mode . ConTeXt-mode))
|
|
(add-to-list 'major-mode-remap-alist '(texinfo-mode . Texinfo-mode))
|
|
(add-to-list 'major-mode-remap-alist '(doctex-mode . docTeX-mode))
|
|
(add-to-list 'auto-mode-alist '("/\\.latexmkrc\\'" . perl-mode))
|
|
(add-to-list 'auto-mode-alist '("\\.[tT]e[xX]\\'" . LaTeX-mode))
|
|
:config
|
|
(defun my/-auctex-texdoc-setup-env (oldfun &rest args)
|
|
(let ((process-environment process-environment)
|
|
(emacs-cmd (concat "emacsclient" (and (not (display-graphic-p)) " -nw"))))
|
|
(setenv "PDFVIEWER_texdoc" "evince")
|
|
(setenv "MDVIEWER_texdoc" emacs-cmd)
|
|
(setenv "PAGER_texdoc" emacs-cmd)
|
|
(apply oldfun args)))
|
|
(advice-add 'TeX-documentation-texdoc :around 'my/-auctex-texdoc-setup-env)
|
|
(defun my/-setup-LaTeX-mode ()
|
|
(setq evil-lookup-func 'latex-help-at-point))
|
|
(setq TeX-auto-save t
|
|
TeX-parse-self t
|
|
reftex-plug-into-AUCTeX t)
|
|
(evil-define-operator my/evil-LaTeX-fill (beg end)
|
|
"Like `evil-fill', but using auctex."
|
|
;; The code here came straight from `evil-fill'
|
|
:move-point nil
|
|
:type line
|
|
(save-excursion
|
|
(ignore-errors (LaTeX-fill-region beg end))))
|
|
(evil-define-operator my/evil-LaTeX-fill-and-move (beg end)
|
|
"Like `evil-fill-and-move', but using auctex."
|
|
;; The code here came straight from `evil-fill-and-move'
|
|
:move-point nil
|
|
:type line
|
|
(let ((marker (make-marker)))
|
|
(move-marker marker (1- end))
|
|
(ignore-errors
|
|
(LaTeX-fill-region beg end)
|
|
(goto-char marker)
|
|
(evil-first-non-blank))))
|
|
(evil-define-key 'normal TeX-mode-map
|
|
"gq" 'my/evil-LaTeX-fill-and-move
|
|
"gw" 'my/evil-LaTeX-fill)
|
|
(setq-default TeX-master nil)
|
|
(require 'tex)
|
|
(TeX-global-PDF-mode 1)
|
|
(add-to-list 'TeX-command-list
|
|
`("LuaLaTeX"
|
|
,(concat "lualatex %(file-line-error) %`%(extraopts) "
|
|
"%S%(PDFout)%(mode)%' %(output-dir) %t")
|
|
TeX-run-TeX nil (LaTeX-mode)
|
|
:help "Run LuaLaTeX")))
|
|
|
|
;; blueprint
|
|
(use-package blueprint-ts-mode
|
|
:hook (blueprint-ts-mode . eglot-ensure)
|
|
:after eglot)
|
|
|
|
;; python-ts-mode
|
|
(use-package python-ts-mode
|
|
:ensure nil
|
|
:hook (python-ts-mode . eglot-ensure))
|
|
|
|
;; java-ts-mode
|
|
(use-package java-ts-mode
|
|
:hook (java-ts-mode . eglot-ensure))
|
|
|
|
;; c-ts-mode
|
|
(use-package c-ts-mode
|
|
:after evil
|
|
:hook ((c-ts-mode c++-ts-mode) . eglot-ensure)
|
|
:init
|
|
(setq-default c-ts-mode-indent-offset 4)
|
|
:config
|
|
(evil-define-key 'normal 'c-ts-mode-map
|
|
"go" #'ff-find-other-file
|
|
"gO" #'ff-find-other-file-other-window)
|
|
(evil-define-key 'normal 'c++-ts-mode-map
|
|
"go" #'ff-find-other-file
|
|
"gO" #'ff-find-other-file-other-window)
|
|
(evil-define-key 'normal 'objc-mode-map
|
|
"go" #'ff-find-other-file
|
|
"gO" #'ff-find-other-file-other-window))
|
|
|
|
;; php-mode
|
|
(use-package php-mode
|
|
:hook (php-mode . eglot-ensure))
|
|
|
|
;; web-mode
|
|
(use-package web-mode
|
|
:hook (web-mode . eglot-ensure)
|
|
:init
|
|
(add-to-list 'eglot-server-programs
|
|
'(web-mode . ("vscode-html-language-server" "--stdio"))))
|
|
|
|
;; Polymode
|
|
(use-package polymode
|
|
:config
|
|
(define-hostmode my/poly-web-hostmode
|
|
:mode 'web-mode)
|
|
(define-innermode my/poly-php-innermode
|
|
:mode 'php-mode
|
|
:head-matcher "\<\?php"
|
|
:tail-matcher "\?\>"
|
|
:head-mode 'body
|
|
:tail-mode 'body)
|
|
(define-polymode my/poly-web-mode
|
|
:hostmode 'my/poly-web-hostmode
|
|
:innermodes '(my/poly-php-innermode))
|
|
(add-to-list 'auto-mode-alist '("\\.php\\|\\.phtml\\'" . my/poly-web-mode)))
|
|
|
|
;; shell-mode
|
|
(use-package sh-script
|
|
:ensure nil
|
|
:hook (sh-mode . my/-setup-sh-mode)
|
|
:init
|
|
(defun my/-setup-sh-mode ()
|
|
(add-to-list 'completion-at-point-functions #'cape-file)))
|
|
|
|
;; go mode
|
|
(use-package go-mode
|
|
:defer nil
|
|
:hook (go-mode . eglot-ensure))
|
|
(use-package go-ts-mode
|
|
:ensure nil
|
|
:hook (go-ts-mode . eglot-ensure))
|
|
|
|
;; rust
|
|
(use-package rust-mode)
|
|
(use-package rust-ts-mode
|
|
:ensure nil
|
|
:hook (rust-ts-mode . eglot-ensure))
|
|
|
|
;; zig
|
|
(use-package zig-mode
|
|
:hook (zig-mode . eglot-ensure))
|
|
|
|
;; lua
|
|
(use-package lua-mode
|
|
:hook (lua-mode . eglot-ensure))
|
|
|
|
;; markdown
|
|
(use-package markdown-mode
|
|
:hook (markdown-mode . auto-fill-mode))
|
|
|
|
;; groovy
|
|
(use-package groovy-mode)
|
|
|
|
;; cmake
|
|
(require 'cmake-mode)
|
|
(with-eval-after-load 'cmake-mode
|
|
(defun my/setup-cmake-ts-mode ()
|
|
"Setup `cmake-ts-mode' buffers."
|
|
(setq-local indent-line-function #'cmake-indent))
|
|
(add-hook 'cmake-ts-mode-hook #'my/setup-cmake-ts-mode))
|
|
|
|
;; kdl
|
|
(require 'kdl-ts-mode)
|
|
|
|
;; json
|
|
(use-package json-ts-mode
|
|
:hook (json-ts-mode . eglot-ensure))
|
|
(use-package json-mode)
|
|
|
|
;; csv
|
|
(use-package csv-mode)
|
|
|
|
;; firejail
|
|
(require 'firejail-mode)
|
|
|
|
;; yaml
|
|
(use-package yaml-ts-mode
|
|
:hook ((yaml-ts-mode . eglot-ensure)
|
|
(yaml-ts-mode . my/-setup-yaml-ts-mode))
|
|
:init
|
|
(defun my/-setup-yaml-ts-mode ()
|
|
(setq indent-line-function #'yaml-indent-line)))
|
|
(use-package yaml-mode)
|
|
|
|
;; yuck (config language for eww)
|
|
(use-package yuck-mode)
|
|
|
|
;; Some Elisp indentation stuff
|
|
;; Source: https://github.com/magit/emacsql
|
|
;; emacsql.el line 394
|
|
(defun my/lisp-inside-plist-p ()
|
|
"Return t if point is inside a plist."
|
|
(save-excursion
|
|
(let ((start (point)))
|
|
(beginning-of-defun)
|
|
(when-let ((sexp (nth 1 (parse-partial-sexp (point) start))))
|
|
(goto-char sexp)
|
|
(looking-at (rx "(" (* (syntax whitespace)) ":"))))))
|
|
|
|
(defun my/-calculate-indent-fix-plists (oldfun &rest args)
|
|
"This function is meant to advise `calculate-lisp-indent'.
|
|
It calls OLDFUN with ARGS in such an environment as to prevent the default
|
|
indentation of plists."
|
|
(if (and (eq major-mode 'emacs-lisp-mode)
|
|
(save-excursion
|
|
(beginning-of-line)
|
|
(my/lisp-inside-plist-p)))
|
|
(let ((lisp-indent-offset 1))
|
|
(apply oldfun args))
|
|
(apply oldfun args)))
|
|
|
|
(advice-add 'calculate-lisp-indent :around
|
|
'my/-calculate-indent-fix-plists)
|
|
|
|
(defvar my/max-lisp-noindent-comment-search-lines 30
|
|
"Max lines to search for the noindent comment.")
|
|
|
|
(defun my/-calculate-lisp-indent-noindent-comment (oldfun &rest args)
|
|
"This function is meant to advise `calculate-lisp-indent'.
|
|
It calls OLDFUN with ARGS, unless the line ends with the comment
|
|
; noindent [LINES]
|
|
In this case, it just returns the current amount of indentation. LINES is the
|
|
number of lines that this comment affects. This is limited by
|
|
`my/max-lisp-noindent-comment-search-lines'.
|
|
|
|
This only works if its on the first or second form in a block. I think this is
|
|
because the indentation code only checks those and then assumes the same
|
|
indentation for every following line in the same block. This is probably OK as
|
|
I can't imagine too many instances where you need to randomly change the indent
|
|
midway through a block, and in those cases you can just stick this on the first
|
|
line in the block and manually deal with indentation."
|
|
(if (and (save-excursion
|
|
(end-of-line)
|
|
(re-search-backward
|
|
(rx (+ ";") (syntax whitespace) "noindent"
|
|
(? (syntax whitespace) (group (+ num)))
|
|
line-end)
|
|
(pos-bol (- my/max-lisp-noindent-comment-search-lines))
|
|
t))
|
|
(save-excursion
|
|
;; if we are on a blank line, move forward a line
|
|
(when (zerop (length (buffer-substring-no-properties
|
|
(pos-bol) (pos-eol))))
|
|
(beginning-of-line 2))
|
|
(<= (count-lines (match-beginning 0) (pos-eol))
|
|
(if-let ((match (match-string 1)))
|
|
(string-to-number match)
|
|
1))))
|
|
(save-excursion
|
|
(beginning-of-line)
|
|
(looking-at (rx (* blank)))
|
|
(length (match-string 0)))
|
|
(apply oldfun args)))
|
|
|
|
(advice-add 'calculate-lisp-indent :around
|
|
'my/-calculate-lisp-indent-noindent-comment)
|
|
|
|
;; sly
|
|
(use-package sly
|
|
;; :hook (lisp-mode . my/-lisp-mode-autoconnect-sly)
|
|
:bind (:map sly-mode-map
|
|
("C-c e" . my/sly-show-notes-at-point))
|
|
:autoload sly-connected-p
|
|
:init
|
|
(defun my/-lisp-mode-autoconnect-sly ()
|
|
(unless (sly-connected-p)
|
|
(sly)))
|
|
(defun my/sly-notes-at-point (pos &optional buffer)
|
|
"Returns the sly notes at POS in BUFFER.
|
|
If BUFFER is nil, the current buffer is used."
|
|
(with-current-buffer (or buffer (current-buffer))
|
|
(cl-loop for overlay in (overlays-at pos)
|
|
for note = (overlay-get overlay 'sly-note)
|
|
when note
|
|
collect note)))
|
|
(defun my/sly-show-notes-at-point ()
|
|
"Show all sly notes at point in a floating window."
|
|
(interactive)
|
|
(my/floating-tooltip " *sly-note-posframe*"
|
|
(with-output-to-string
|
|
(dolist (note (my/sly-notes-at-point (point)))
|
|
(when-let (msg (plist-get note :message))
|
|
(princ "·")
|
|
(princ msg)
|
|
(terpri))))))
|
|
(setq inferior-lisp-program "/usr/bin/sbcl")
|
|
:config
|
|
(sly-symbol-completion-mode -1))
|
|
|
|
;; pdf-tools
|
|
(use-package pdf-tools
|
|
:hook (pdf-view-mode . my/setup-pdf-view-mode)
|
|
:init
|
|
(setq pdf-misc-print-program-executable "lp")
|
|
(defun my/setup-pdf-view-mode ()
|
|
(display-line-numbers-mode -1)
|
|
(evil-define-key '(motion normal visual) 'local
|
|
(kbd "C-s") #'isearch-forward
|
|
(kbd "C-r") #'isearch-backward)
|
|
(setq-local cursor-type nil))
|
|
(pdf-tools-install))
|
|
|
|
;; doc view
|
|
(use-package doc-view
|
|
:ensure nil
|
|
:hook (doc-view-mode . my/-setup-doc-view-mode)
|
|
:init
|
|
(defun my/-setup-doc-view-mode ()
|
|
(display-line-numbers-mode -1)
|
|
(evil-define-key '(motion normal visual) 'local
|
|
(kbd "C-s") #'isearch-forward
|
|
(kbd "C-r") #'isearch-backward)))
|
|
|
|
;; calc
|
|
(use-package calc
|
|
:ensure nil
|
|
:bind (("C-c m" . quick-calc)
|
|
:map calc-mode-map
|
|
("M-<tab>" . calc-roll-up)
|
|
("M-TAB" . calc-roll-up))
|
|
:hook ((calc-mode calc-trail-mode) . my/setup-calc-calc-trail-mode)
|
|
:init
|
|
(defun my/setup-calc-calc-trail-mode ()
|
|
(setq-local doom-modeline-percent-position '()
|
|
truncate-partial-width-windows nil)
|
|
(visual-line-mode -1)
|
|
(display-line-numbers-mode -1)
|
|
(toggle-truncate-lines 1))
|
|
:config
|
|
(evil-define-key '(normal visual motion) calc-edit-mode-map
|
|
(kbd "RET") 'calc-edit-return
|
|
(kbd "<return>") 'calc-edit-return)
|
|
(defun my/-calc-float-mode-string ()
|
|
(cl-destructuring-bind (mode prec) calc-float-format
|
|
(concat
|
|
(upcase-initials (symbol-name mode))
|
|
(unless (zerop prec)
|
|
(concat ": " (number-to-string prec))))))
|
|
(doom-modeline-def-segment calc
|
|
"Display calculator icons and info."
|
|
(concat
|
|
(doom-modeline-spc)
|
|
(when-let ((icon (doom-modeline-icon 'faicon "nf-fa-calculator" "🖩" "")))
|
|
(concat
|
|
(doom-modeline-display-icon icon)
|
|
(doom-modeline-vspc)))
|
|
(doom-modeline--buffer-simple-name)
|
|
(when (eq major-mode 'calc-mode)
|
|
(concat
|
|
(doom-modeline-spc)
|
|
(number-to-string calc-internal-prec)
|
|
(doom-modeline-spc)
|
|
(upcase-initials (symbol-name calc-angle-mode))
|
|
(doom-modeline-spc)
|
|
(my/-calc-float-mode-string)
|
|
(when calc-prefer-frac
|
|
(concat
|
|
(doom-modeline-spc)
|
|
"Frac"))
|
|
(cond
|
|
(calc-algebraic-mode
|
|
(concat
|
|
(doom-modeline-spc)
|
|
"Alg"))
|
|
(calc-incomplete-algebraic-mode
|
|
(concat
|
|
(doom-modeline-spc)
|
|
"IAlg"))))))))
|
|
|
|
;; sage (for when calc is not enough)
|
|
(use-package sage-shell-mode
|
|
:demand
|
|
:bind ("C-c g" . my/run-sage)
|
|
:hook (sage-shell-mode . my/-setup-sage-shell-mode)
|
|
:init
|
|
(defun my/-setup-sage-shell-mode ()
|
|
(setq-local comint-dynamic-complete-functions
|
|
'(comint-c-a-p-replace-by-expanded-history)))
|
|
:config
|
|
(defun my/run-sage (p)
|
|
"Like `sage-shell:run-sage', but does not ask anything without a prefix
|
|
argument."
|
|
(interactive "P")
|
|
(let ((sage-shell:ask-command-options p))
|
|
(funcall-interactively #'sage-shell:run-sage
|
|
(sage-shell:read-command)))))
|
|
|
|
;; fricas (because I like calculators)
|
|
(add-to-list 'load-path "/usr/lib/fricas/emacs/")
|
|
(use-package fricas
|
|
:ensure nil
|
|
:custom
|
|
(fricas-run-command "fricas -nosman")
|
|
:init
|
|
;; Fix `fricas-mode' messing up `completion-at-point-functions'
|
|
(advice-add #'fricas-mode :around
|
|
#'(lambda (oldfun &rest r)
|
|
(let ((temp-capfs))
|
|
(let ((completion-at-point-functions '(t)))
|
|
(apply oldfun r)
|
|
(setq temp-capfs completion-at-point-functions))
|
|
(setq-local completion-at-point-functions temp-capfs)))
|
|
'((name . "my/-fricas-fix-capfs")))
|
|
:config
|
|
(face-spec-set 'fricas-type-time '((t (:foreground unspecified
|
|
:background unspecified
|
|
:inherit font-lock-type-face))))
|
|
(face-spec-set 'fricas-message '((t (:foreground unspecified
|
|
:background unspecified
|
|
:inherit error))))
|
|
(face-spec-set 'fricas-undefined '((t (:foreground unspecified
|
|
:background unspecified
|
|
:inherit nerd-icons-lblue))))
|
|
(face-spec-set 'fricas-algebra '((t (:foreground unspecified
|
|
:background unspecified
|
|
:weight bold
|
|
:inherit fricas-prompt))))
|
|
(face-spec-set 'fricas-TeX '((t (:foreground "black"
|
|
:background "white"
|
|
:inherit fricas-prompt)))))
|
|
|
|
;; gnuplot (mostly for org-plot)
|
|
(use-package gnuplot)
|
|
|
|
;; eat
|
|
(use-package eat
|
|
:bind (("C-c V" . my/project-eat-or-default)
|
|
:map eat-mode-map
|
|
("M-o" . ace-window)
|
|
:map eat-semi-char-mode-map
|
|
("M-o" . ace-window)
|
|
:map eat-eshell-emacs-mode-map
|
|
("M-o" . ace-window)
|
|
:map eat-eshell-semi-char-mode-map
|
|
("M-o" . ace-window))
|
|
:config
|
|
(defvar my/project-eat-hash-table (make-hash-table :test 'equal)
|
|
"Hash table that maps project root dirs to eat buffers.")
|
|
(defun my/project-eat (prompt)
|
|
"Switch to or create a eat buffer in the current projects root."
|
|
(interactive (list t))
|
|
(if-let ((proj (project-current prompt))
|
|
(default-directory (project-root proj)))
|
|
(if-let ((eat-buff (gethash default-directory
|
|
my/project-eat-hash-table))
|
|
((buffer-live-p eat-buff)))
|
|
(switch-to-buffer eat-buff)
|
|
(let ((eat-buffer-name (concat "*eat for project " default-directory
|
|
"*"))
|
|
(eat-term-name (if (file-remote-p default-directory)
|
|
"xterm-256color"
|
|
eat-term-name)))
|
|
(puthash default-directory
|
|
(eat)
|
|
my/project-eat-hash-table)))))
|
|
(defun my/project-eat-or-default ()
|
|
"Open an eat for the current project, otherwise, open a normal eat."
|
|
(interactive)
|
|
(unless (my/project-eat nil)
|
|
(if-let ((eat-buff (gethash nil my/project-eat-hash-table))
|
|
((buffer-live-p eat-buff)))
|
|
(switch-to-buffer eat-buff)
|
|
(puthash nil (let ((eat-term-name (if (file-remote-p default-directory)
|
|
"xterm-256color"
|
|
eat-term-name)))
|
|
(eat))
|
|
my/project-eat-hash-table)))))
|
|
|
|
;; eshell stuff
|
|
(use-package eshell
|
|
:ensure nil
|
|
:defer nil
|
|
:hook ((eshell-load . eat-eshell-visual-command-mode)
|
|
(eshell-load . eat-eshell-mode)
|
|
(eshell-mode . my/-eshell-mode-setup))
|
|
:bind (:map eshell-mode-map
|
|
("TAB" . completion-at-point)
|
|
("<tab>" . completion-at-point))
|
|
:init
|
|
(defun my/-eshell-mode-setup ()
|
|
"Setup function run from `eshell-mode-hook'"
|
|
(setq-local corfu-auto nil))
|
|
(setq-default eshell-command-aliases-list
|
|
'(("clear" "clear t")
|
|
("e" "find-file $1")
|
|
("n" "find-file $1")
|
|
("emacs" "find-file $1")
|
|
("nvim" "find-file $1")
|
|
("ls" "eza --git -F $*")
|
|
("la" "ls -a $*")
|
|
("l" "ls -l $*")
|
|
("ll" "la -l $*")
|
|
("gt" "git status $*")
|
|
("gp" "git push $*")
|
|
("gu" "git pull $*")
|
|
("gf" "git fetch $*")
|
|
("ga" "git add $*")
|
|
("gcm" "git commit -m ${string-join $* \" \"}")
|
|
("ldg" "ledger -f \"$HOME/docs/finance/finances.ledger\" $*")
|
|
("tp" "trash-put $*")
|
|
("trr" "trash-restore $*")
|
|
("tre" "trash-empty $*")
|
|
("tre" "trash-empty $*")
|
|
("trm" "trash-rm $*")
|
|
("rm" "echo 'rm: I''m unsafe! Don''t use me.'; false")
|
|
("\\rm" "eshell/rm")))
|
|
(defvar my/eshell-bm-auto-ls t
|
|
"Weather or not to run ls after `eshell/bm'")
|
|
(defun eshell/bm (&optional name)
|
|
"Change to directory of bookmark NAME.
|
|
If no name is given, list all bookmarks instead."
|
|
(if name
|
|
(progn
|
|
(eshell/cd (bookmark-get-filename name))
|
|
(when my/eshell-bm-auto-ls
|
|
(eshell/ls)))
|
|
(eshell-print (string-join (bookmark-all-names) " ")))))
|
|
(use-package esh-help
|
|
:hook (eshell-mode . my/-setup-eshell-help-func)
|
|
:init
|
|
(defun my/-setup-eshell-help-func ()
|
|
(eldoc-mode 1)
|
|
(setq-local evil-lookup-func #'esh-help-run-help))
|
|
(setup-esh-help-eldoc))
|
|
(use-package eshell-syntax-highlighting
|
|
:init
|
|
(eshell-syntax-highlighting-global-mode 1))
|
|
(use-package eshell-starship
|
|
:ensure nil
|
|
:demand t
|
|
:hook (eshell-prompt-mode . eshell-starship-prompt-mode))
|
|
|
|
;; proced
|
|
(use-package proced
|
|
:bind ("C-x j" . proced)
|
|
:init
|
|
(setq proced-auto-update-flag t
|
|
proced-auto-update-interval 1)
|
|
(defun my/-setup-proced-mode ()
|
|
(visual-line-mode -1)
|
|
(setq-local truncate-lines t))
|
|
(add-hook 'proced-mode-hook 'my/-setup-proced-mode))
|
|
|
|
;; dired
|
|
(use-package dired
|
|
:ensure nil
|
|
:init
|
|
(setq-default dired-kill-when-opening-new-dired-buffer t)
|
|
(setq delete-by-moving-to-trash t
|
|
dired-recursive-copies 'always
|
|
dired-recursive-deletes 'always
|
|
dired-dwim-target t
|
|
dired-create-destination-dirs 'ask
|
|
dired-create-destination-dirs-on-trailing-dirsep t
|
|
dired-isearch-filenames 'dwim
|
|
dired-do-revert-buffer (lambda (dir)
|
|
(not (file-remote-p dir)))
|
|
dired-clean-up-buffers-too t
|
|
dired-clean-confirm-killing-deleted-buffers t)
|
|
(evil-define-key '(normal visual motion) dired-mode-map
|
|
"u" #'dired-unmark
|
|
"U" #'dired-unmark-all-marks))
|
|
|
|
;; ibuffer
|
|
(use-package ibuffer
|
|
:bind ("C-x C-b" . ibuffer))
|
|
|
|
;; magit
|
|
(use-package magit
|
|
:init
|
|
(evil-define-key '(normal visual motion) magit-mode-map
|
|
"s" #'magit-stage-file
|
|
"S" #'magit-stage-modified))
|
|
|
|
;; org-mode
|
|
(use-package org
|
|
:pin gnu
|
|
:bind (("C-c c" . org-capture)
|
|
("C-c a" . org-agenda)
|
|
("C-c l" . org-store-link)
|
|
:map org-mode-map
|
|
("C-c t" . org-table-create))
|
|
:hook (org-mode . org-table-header-line-mode)
|
|
:init
|
|
(font-lock-add-keywords 'org-mode
|
|
`((,(rx bol (* " ") (group "-") " ")
|
|
(0 (prog1 nil
|
|
(compose-region (match-beginning 1)
|
|
(match-end 1) "•"))))))
|
|
(setq org-directory "~/org"
|
|
org-agenda-files '("~/org/")
|
|
org-log-into-drawer t
|
|
org-log-done 'time
|
|
org-log-redeadline 'time
|
|
org-log-reschedule 'time
|
|
org-preview-latex-default-process 'dvisvgm
|
|
org-highlight-latex-and-related '(native entities)
|
|
org-startup-with-inline-images t
|
|
org-adapt-indentation t
|
|
org-hide-leading-stars t
|
|
org-html-with-latex 'dvisvgm
|
|
org-preview-latex-process-alist
|
|
'((dvisvgm
|
|
:image-input-type "dvi"
|
|
:image-output-type "svg"
|
|
:image-size-adjust (1.7 . 1.5)
|
|
:latex-compiler ("pdflatex -interaction nonstopmode -output-format=dvi -output-directory=%o %f")
|
|
:image-converter ("dvisvgm %o%b.dvi --no-fonts --exact-bbox --scale=%S --output=%O"))))
|
|
(defun my/-org-allow-in-derived-mode (oldfun &rest r)
|
|
"Allow OLDFUN to run, even if `major-mode' is only derived from `org-mode'.
|
|
R is rest of the arguments to OLDFUN."
|
|
(let ((major-mode (if (derived-mode-p 'org-mode)
|
|
'org-mode
|
|
major-mode)))
|
|
(apply oldfun r)))
|
|
(advice-add 'org-element-at-point :around 'my/-org-allow-in-derived-mode)
|
|
(advice-add 'org-table-header-line-mode :around 'my/-org-allow-in-derived-mode))
|
|
(use-package evil-org
|
|
:after org
|
|
:hook (org-mode . evil-org-mode)
|
|
:init
|
|
(require 'evil-org-agenda)
|
|
(evil-org-agenda-set-keys))
|
|
|
|
;; ledger
|
|
(use-package ledger-mode)
|
|
(use-package flycheck-ledger
|
|
:hook (ledger-mode . flycheck-mode))
|
|
|
|
;; khard contacts
|
|
(require 'khard)
|
|
|
|
;; This is also in khard (see above), it's just also here so that if I remove
|
|
;; that file ever, other things will not break.
|
|
(defun my/message-in-header-p (name &optional testfn)
|
|
"If in field NAME, return the start of the header, otherwise, return nil.
|
|
The name is compared with the field name using TESTFN (defaults to `equal')."
|
|
(save-excursion
|
|
(when (and (message-point-in-header-p)
|
|
(message-beginning-of-header t))
|
|
(beginning-of-line)
|
|
(when (and (looking-at (rx bol (group (+? any)) ":" (? " ")))
|
|
(funcall (or testfn 'equal) (match-string 1) name))
|
|
(match-end 0)))))
|
|
|
|
;; mu4e
|
|
(use-package mu4e
|
|
:ensure nil
|
|
:defer nil
|
|
:hook ((mu4e-index-updated . my/-mu4e-enable-index-messages)
|
|
(mu4e-main-mode . my/-mu4e-setup-main-mode)
|
|
(mu4e-view-mode . my/-mu4e-setup-view-mode)
|
|
(mu4e-compose-mode . my/-mu4e-setup-compose-mode))
|
|
:bind (("C-x C-m" . mu4e)
|
|
:map message-mode-map
|
|
("C-c k" . khard-insert-email-contact)
|
|
:map mu4e-headers-mode-map
|
|
([remap mu4e-headers-mark-for-trash] .
|
|
my/mu4e-headers-mark-for-trash)
|
|
:map mu4e-view-mode-map
|
|
([remap mu4e-view-mark-for-trash] .
|
|
my/mu4e-view-mark-for-trash))
|
|
:init
|
|
(require 'mu4e)
|
|
(evil-define-key '(normal motion) mu4e-main-mode-map "q" #'bury-buffer)
|
|
(evil-define-key '(normal motion) mu4e-view-mode-map "gy" #'mu4e-view-save-url)
|
|
(defun my/-mu4e-setup-view-mode ()
|
|
(setq-local global-hl-line-mode nil))
|
|
(defun my/-mu4e-setup-main-mode ()
|
|
(setq-local default-directory "~/"))
|
|
(defun my/-mu4e-enable-index-messages ()
|
|
(setq mu4e-hide-index-messages nil))
|
|
(defun my/mu4e-update-mail-and-index-silent ()
|
|
"Run `mu4e-update-mail-and-index' without any messages in the background."
|
|
(setq mu4e-hide-index-messages t)
|
|
(mu4e-update-mail-and-index t))
|
|
(defun my/mu4e-headers-mark-for-trash ()
|
|
"Move the message a point to the trash without marking it was deleted
|
|
(trashed)."
|
|
(interactive)
|
|
(when (mu4e-thread-message-folded-p)
|
|
(mu4e-warn "Cannot mark folded messages"))
|
|
(mu4e-mark-at-point 'move mu4e-trash-folder)
|
|
(when mu4e-headers-advance-after-mark
|
|
(mu4e-headers-next)))
|
|
(defun my/mu4e-view-mark-for-trash ()
|
|
"Like `my/mu4e-headers-mark-for-trash', but for `mu4e-view-mode'."
|
|
(interactive)
|
|
(mu4e--view-in-headers-context
|
|
(my/mu4e-headers-mark-for-trash)))
|
|
(defun my/-mu4e-enable-autocomplete-in-header ()
|
|
;; corfu auto must be t (not the integer returned by
|
|
;; `my/message-in-header-p'
|
|
(setq-local corfu-auto (and (not (window-minibuffer-p))
|
|
(my/message-in-header-p "To")
|
|
t)))
|
|
(defun my/-mu4e-setup-compose-mode ()
|
|
(add-hook 'post-command-hook 'my/-mu4e-enable-autocomplete-in-header
|
|
nil t)
|
|
(add-to-list
|
|
(make-local-variable 'completion-at-point-functions)
|
|
(cape-capf-super #'mu4e-complete-contact #'khard-message-mode-capf)))
|
|
(defun my/-mu4e-fix-cycle-threshold ()
|
|
(setq-local completion-cycle-threshold nil))
|
|
(advice-add 'mu4e--compose-setup-completion :after
|
|
'my/-mu4e-fix-cycle-threshold)
|
|
(defvar my/mu4e-interesting-mail-query
|
|
(concat "flag:unread AND NOT flag:trashed AND NOT "
|
|
"maildir:/protonmail/Trash AND NOT maildir:/protonmail/Spam")
|
|
"Flag for mail which will appear as \"unread\" and will be notified.")
|
|
(setq message-kill-buffer-on-exit t
|
|
message-confirm-send t
|
|
message-send-mail-function 'sendmail-send-it
|
|
mu4e-change-filenames-when-moving t
|
|
mu4e-context-policy 'pick-first
|
|
mu4e-attachment-dir "~/downloads/"
|
|
mu4e-last-update-buffer " *mu4e-last-update*"
|
|
mu4e-index-update-error-warning nil
|
|
mu4e-get-mail-command "mbsync protonmail"
|
|
mu4e-completing-read-function #'completing-read-default
|
|
mu4e-compose-context-policy 'ask-if-none
|
|
mu4e-contexts
|
|
(list (make-mu4e-context
|
|
:name "Personal"
|
|
:match-func (lambda (msg)
|
|
(when msg
|
|
(string-match-p "^/protonmail/"
|
|
(mu4e-message-field msg
|
|
:maildir))))
|
|
:vars `((user-mail-address . ,(my/get-private 'mu4e-email))
|
|
(user-full-name . ,(my/get-private 'mu4e-name))
|
|
(message-signature . nil)
|
|
(mu4e-refile-folder . "/protonmail/Archive")
|
|
(mu4e-sent-folder . "/protonmail/Sent")
|
|
(mu4e-drafts-folder . "/protonmail/Drafts")
|
|
(mu4e-trash-folder . "/protonmail/Trash")
|
|
(mu4e-bookmarks
|
|
. ((:name "Inbox"
|
|
:query "maildir:/protonmail/Inbox"
|
|
:key ?i)
|
|
(:name "Unread"
|
|
:query ,my/mu4e-interesting-mail-query
|
|
:key ?u))))))))
|
|
(use-package mu4e-alert
|
|
:after mu4e
|
|
:hook (after-init . mu4e-alert-enable-notifications)
|
|
:init
|
|
(setq mu4e-alert-set-window-urgency nil
|
|
mu4e-alert-interesting-mail-query my/mu4e-interesting-mail-query)
|
|
:config
|
|
(mu4e-alert-set-default-style 'libnotify))
|
|
(mu4e t)
|
|
(mu4e-context-switch nil "Personal")
|
|
|
|
;; mu4e compose HTML messages
|
|
(use-package org-mime)
|
|
(require 'org-mu4e-compose)
|
|
(setq mail-user-agent 'org-mu4e-user-agent
|
|
org-mime-org-html-with-latex-default 'dvisvgm
|
|
org-mime-export-options '(:with-latex dvisvgm :with-footnotes t))
|
|
(evil-define-key '(normal visual) org-mu4e-compose-mode-map
|
|
"G" #'mu4e-compose-goto-bottom
|
|
"gg" #'mu4e-compose-goto-top)
|
|
(evil-define-key 'normal org-mu4e-compose-mode-map
|
|
"ZZ" #'message-send-and-exit
|
|
"ZD" #'message-dont-send
|
|
"ZQ" #'message-kill-buffer
|
|
"ZF" #'mml-attach-file)
|
|
(evil-define-key 'normal mu4e-view-mode-map
|
|
"R" 'org-mu4e-compose-reply
|
|
"cr" 'org-mu4e-compose-reply)
|
|
(evil-define-key 'normal mu4e-headers-mode-map
|
|
"R" 'org-mu4e-compose-reply
|
|
"cr" 'org-mu4e-compose-reply)
|
|
(defun my/-setup-org-mu4e-compose-mode ()
|
|
"Setup up stuff in `org-mu4e-compose' buffers."
|
|
(setq-local ltex-eglot-variable-save-method 'file)
|
|
;; this should come last so it can pick up the above
|
|
;; (eglot-ensure)
|
|
)
|
|
(add-hook 'org-mu4e-compose-mode-hook #'my/-setup-org-mu4e-compose-mode)
|
|
|
|
;; elfeed
|
|
(use-package elfeed
|
|
:bind (("C-c d" . elfeed))
|
|
:custom
|
|
(elfeed-feeds
|
|
'(("https://archlinux.org/feeds/news/" linux arch)
|
|
("https://9to5linux.com/feed/atom" linux news)))
|
|
:config
|
|
(setq elfeed-log-buffer-name " *elfeed-log*")
|
|
(evil-define-key '(normal motion) elfeed-search-mode-map
|
|
"r" #'elfeed-search-fetch)
|
|
(elfeed-db-load))
|
|
|
|
;; helpful
|
|
(use-package helpful
|
|
:hook ((emacs-lisp-mode . my/-helpful-setup-emacs-lisp-mode)
|
|
(helpful-mode . my/-setup-helpful-mode))
|
|
:bind (:map help-map
|
|
("f" . helpful-callable)
|
|
("v" . helpful-variable)
|
|
("k" . helpful-key)
|
|
("o" . helpful-symbol)
|
|
("x" . helpful-command)
|
|
("F" . helpful-function)
|
|
:map helpful-mode-map
|
|
("<mouse-8>" . my/helpful-history-back)
|
|
("<mouse-9>" . my/helpful-history-forward)
|
|
("<normal-state><" . my/helpful-history-back)
|
|
("<normal-state>>" . my/helpful-history-forward))
|
|
:init
|
|
(defun my/-helpful-setup-emacs-lisp-mode ()
|
|
(setq-local evil-lookup-func #'helpful-at-point))
|
|
(defun my/-setup-helpful-mode ()
|
|
(setq-local evil-lookup-func #'helpful-at-point
|
|
tab-width 8))
|
|
(defvar my/helpful-symbol-history-size 50
|
|
"Max size of `my/helpful-symbol-history'.")
|
|
(defvar my/helpful-symbol-history '()
|
|
"History of helpful symbols.")
|
|
(defvar my/-helpful-inhibit-history nil
|
|
"If non-nil, don't add symbols to `my/helpful-symbol-history'.")
|
|
(defvar my/-helpful-last-entry nil
|
|
"Last entry looked up with helpful.")
|
|
(defun my/helpful-history-back (count)
|
|
"Go back COUNT symbols in `my/helpful-symbol-history'. If called
|
|
interactively, COUNT defaults to 1."
|
|
(interactive "p")
|
|
(my/helpful-history-forward (- count)))
|
|
(defun my/helpful-history-forward (count)
|
|
"Move COUNT symbols in `my/helpful-symbol-history'. If COUNT is negative,
|
|
move back. If COUNT is larger than the history, go to the newest entry. Go to
|
|
the oldest entry if -COUNT is larger than the history."
|
|
(interactive "p")
|
|
(when helpful--sym
|
|
(let* ((hist-len (length my/helpful-symbol-history))
|
|
(current-pos (seq-position my/helpful-symbol-history
|
|
(cons helpful--sym
|
|
helpful--callable-p)
|
|
'equal))
|
|
(new-pos (- current-pos count)))
|
|
(cond
|
|
;; if already at the newest element, signal an error
|
|
((and (> count 0) (= current-pos 0))
|
|
(message "%s" "No newer symbol!"))
|
|
;; if already at the oldest element, signal an error
|
|
((and (< count 0) (= (1+ current-pos) hist-len))
|
|
(message "%s" "No older symbol!"))
|
|
(t
|
|
(let ((my/-helpful-inhibit-history t)
|
|
(entry (cond
|
|
((<= new-pos 0)
|
|
(seq-first my/helpful-symbol-history))
|
|
((>= new-pos hist-len)
|
|
(car (last my/helpful-symbol-history)))
|
|
(t
|
|
(nth new-pos my/helpful-symbol-history)))))
|
|
(if (cdr entry)
|
|
(helpful-callable (car entry))
|
|
(helpful-variable (car entry)))))))))
|
|
(defun my/-helpful-switch-buffer-function (helpful-buf)
|
|
"Like `pop-to-buffer', but kill previous helpful buffers and save the new
|
|
buffers `helpful--sym' to `my/helpful-symbol-history'."
|
|
(cl-loop with window = nil
|
|
for buf in (buffer-list)
|
|
when (and
|
|
(not (eq buf helpful-buf))
|
|
(eq (buffer-local-value 'major-mode buf) 'helpful-mode))
|
|
do
|
|
(when-let (cur-window (get-buffer-window buf nil))
|
|
(setq window cur-window))
|
|
(kill-buffer buf)
|
|
finally
|
|
(let ((entry (cons (buffer-local-value 'helpful--sym helpful-buf)
|
|
(buffer-local-value 'helpful--callable-p
|
|
helpful-buf))))
|
|
(unless my/-helpful-inhibit-history
|
|
(when-let (from-current-hist
|
|
(member my/-helpful-last-entry
|
|
my/helpful-symbol-history))
|
|
(setq my/helpful-symbol-history from-current-hist))
|
|
(cl-pushnew entry my/helpful-symbol-history :test 'equal)
|
|
(setq my/helpful-symbol-history
|
|
(seq-take my/helpful-symbol-history
|
|
my/helpful-symbol-history-size)))
|
|
(setq my/-helpful-last-entry entry))
|
|
(if window
|
|
(window--display-buffer helpful-buf window 'reuse)
|
|
(pop-to-buffer helpful-buf))))
|
|
(setq helpful-switch-buffer-function 'my/-helpful-switch-buffer-function
|
|
helpful-max-buffers 2))
|
|
|
|
(defun my/greyify-color (color percent &optional frame)
|
|
"Make COLOR closer to black by PERCENT on FRAME.
|
|
Color can be any color which can be passed to `color-values'."
|
|
(cl-destructuring-bind (&optional r g b)
|
|
(color-name-to-rgb color frame)
|
|
(when (and r g b)
|
|
(let ((scale (- 1.0 (/ percent 100.0))))
|
|
(color-rgb-to-hex (* r scale)
|
|
(* g scale)
|
|
(* b scale))))))
|
|
|
|
;; rainbow-delimiters
|
|
(use-package rainbow-delimiters
|
|
:hook (prog-mode . rainbow-delimiters-mode)
|
|
:config
|
|
;; generate dark version of the rainbow delimiters faces
|
|
(defun my/-rainbow-delimiters-recalc-dark-faces (&optional frame)
|
|
(unless frame (setq frame (selected-frame)))
|
|
(dotimes (i 9)
|
|
(when-let ((old-face (intern-soft
|
|
(format "rainbow-delimiters-depth-%d-face"
|
|
(1+ i))))
|
|
(new-face
|
|
(intern
|
|
(format "my/rainbow-delimiters-depth-%d-dark-face"
|
|
(1+ i))))
|
|
(old-color (face-attribute old-face :foreground frame))
|
|
(new-color (my/greyify-color old-color 50 frame)))
|
|
(set-face-attribute new-face frame :foreground new-color))))
|
|
(add-hook 'after-make-frame-functions
|
|
#'my/-rainbow-delimiters-recalc-dark-faces)
|
|
(add-hook 'server-after-make-frame-hook
|
|
#'my/-rainbow-delimiters-recalc-dark-faces)
|
|
(defun my/rainbow-delimiters-parinfer-pick-face (depth match loc)
|
|
"Version of `rainbow-delimiters-default-pick-face' that colors closing
|
|
parenthesis darker than opening ones. This function defers to
|
|
`rainbow-delimiters-default-pick-face' and just changes the output if it returns
|
|
one of the normal rainbow-delimiters-depth-N-face faces."
|
|
(save-match-data
|
|
(let* ((base-face (rainbow-delimiters-default-pick-face depth match loc))
|
|
(base-name (symbol-name base-face)))
|
|
(if (and evil-cleverparens-mode
|
|
(eq ?\) (char-syntax
|
|
(elt (buffer-substring-no-properties loc (1+ loc)) 0)))
|
|
(string-match (rx string-start "rainbow-delimiters-depth-"
|
|
(group (+ num))
|
|
"-face" string-end)
|
|
base-name))
|
|
(or (intern-soft (format "my/rainbow-delimiters-depth-%s-dark-face"
|
|
(match-string 1 base-name)))
|
|
base-face)
|
|
base-face))))
|
|
(setopt rainbow-delimiters-pick-face-function
|
|
'my/rainbow-delimiters-parinfer-pick-face))
|
|
|
|
;; auto-highlight-symbol
|
|
(use-package auto-highlight-symbol
|
|
:hook (lisp-data-mode . auto-highlight-symbol-mode)
|
|
:init
|
|
(setq ahs-face 'bold
|
|
ahs-face-unfocused 'bold
|
|
ahs-definition-face 'bold
|
|
ahs-definition-face-unfocused 'bold
|
|
ahs-plugin-default-face 'bold
|
|
ahs-plugin-default-face-unfocused 'bold))
|
|
|
|
;; Theme (doom-themes)
|
|
(use-package doom-themes
|
|
:config
|
|
(load-theme 'doom-molokai t)
|
|
(doom-themes-org-config))
|
|
|
|
;; solaire-mode
|
|
(use-package solaire-mode
|
|
:config
|
|
(solaire-global-mode 1))
|
|
|
|
;; Highlight todos
|
|
(use-package hl-todo
|
|
:config
|
|
(global-hl-todo-mode 1))
|
|
(use-package magit-todos
|
|
:after (hl-todo magit)
|
|
:config
|
|
(magit-todos-mode 1))
|
|
|
|
;; icons
|
|
(use-package nerd-icons)
|
|
(use-package nerd-icons-completion
|
|
:config
|
|
(nerd-icons-completion-mode))
|
|
(use-package nerd-icons-dired
|
|
:hook (dired-mode . nerd-icons-dired-mode))
|
|
(use-package kind-icon
|
|
:after corfu
|
|
:init
|
|
(setq kind-icon-default-face 'corfu-default
|
|
kind-icon-default-style
|
|
'(:padding -1 :stroke 0 :margin 0 :radius 0 :height 0.5 :scale 1))
|
|
:config
|
|
(add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))
|
|
|
|
;; modeline (doom-modeline)
|
|
(use-package doom-modeline
|
|
:init
|
|
(setq doom-modeline-support-imenu t)
|
|
(doom-modeline-mode 1))
|
|
|
|
;; dashboard.el
|
|
(use-package dashboard
|
|
:config
|
|
(dashboard-setup-startup-hook)
|
|
(setq initial-buffer-choice (lambda () (get-buffer-create "*dashboard*"))
|
|
dashboard-force-refresh t
|
|
dashboard-display-icons-p t
|
|
dashboard-icon-type 'nerd-icons
|
|
dashboard-set-file-icons t
|
|
dashboard-projects-backend 'project-el
|
|
dashboard-items '((recents . 5)
|
|
(projects . 5)
|
|
(bookmarks . 5))))
|
|
|
|
;; page break lines
|
|
(use-package page-break-lines
|
|
:config
|
|
(global-page-break-lines-mode 1)
|
|
(add-to-list 'page-break-lines-modes 'prog-mode)
|
|
(add-to-list 'page-break-lines-modes 'text-mode)
|
|
(add-to-list 'page-break-lines-modes 'helpful-mode))
|
|
|
|
;; fun!
|
|
(use-package mines)
|
|
|
|
;;; init.el ends here
|