maciej/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use elpaca for longer
All checks were successful
/ Test config on 20 (push) Successful in 29s
Details

Browse source
This commit is contained in:
Maciej 2024-10-30 08:18:17 +02:00
parent 1fe168ccc6
commit f21f3dcc77
Signed by: maciej
GPG key ID: 41D62D42D3B0D765
25 changed files with 883 additions and 984 deletions
Download patch file Download diff file Expand all files Collapse all files

1169
elpaca.lock
View file

File diff suppressed because it is too large Load diff

8
lisp/icejam-avy.el
View file

@ -11,11 +11,11 @@
;;; Code: ;;; Code:
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
(use-package avy :ensure t) (use-package avy :ensure t :defer t
(with-eval-after-load 'avy :custom (avy-timeout-seconds 1 "Wait for 1 second for candidates")
(setq avy-timeout-seconds 1) :bind (:map icejam-keys-mode-map
;; Jump to text in sight with CMD-j ;; Jump to text in sight with CMD-j
(define-key icejam-keys-mode-map [(hyper j)] 'avy-goto-char-timer)) ([(hyper j)] . avy-goto-char-timer)))
(provide 'icejam-avy) (provide 'icejam-avy)
;;; icejam-avy.el ends here ;;; icejam-avy.el ends here

60
lisp/icejam-base.el
View file

@ -9,6 +9,7 @@
;; pkg/base defines basic packages and environment. ;; pkg/base defines basic packages and environment.
;;; Code: ;;; Code:
(require 'icejam-keys-mode)
;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;; ;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;;
;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;; ;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
@ -40,20 +41,19 @@
(global-set-key (kbd "RET") 'newline) (global-set-key (kbd "RET") 'newline)
;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;; ;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;;
(use-package easy-kill :ensure t) (use-package easy-kill :ensure t
(with-eval-after-load 'easy-kill :bind ([remap kill-ring-save] . easy-kill))
(global-set-key [remap kill-ring-save] 'easy-kill))
;; Move buffers around with buffer keys ;; Move buffers around with buffer keys
(use-package buffer-move :ensure t :defer t) (use-package buffer-move :ensure t :defer t)
;; Garbage collection magic hack ;; Garbage collection magic hack
(use-package gcmh :ensure t) (use-package gcmh :ensure t
(with-eval-after-load 'gcmh :custom ((gcmh-verbose nil "Do not log GC messages.")
(gcmh-mode 1) (gcmh-idle-delay 'auto "Compute GC delay based on gcmh-auto-idle-delay-factor")
(setq gcmh-verbose nil (gcmh-auto-idle-delay-factor 10 "Original value was 10"))
gcmh-idle-delay 'auto :config
gcmh-auto-idle-delay-factor 10)) (gcmh-mode t))
;; #====================== Backup config #============================== ;; #====================== Backup config #==============================
(setq backup-directory-alist (setq backup-directory-alist
@ -97,16 +97,16 @@
;; Allow to execute path from shell ;; Allow to execute path from shell
(use-package exec-path-from-shell (use-package exec-path-from-shell
:if (memq window-system '(x mac ns)) :if (memq window-system '(x mac ns))
:ensure t) :ensure t
:config
(with-eval-after-load 'exec-path-from-shell
(add-to-list 'exec-path "/usr/local/bin") (add-to-list 'exec-path "/usr/local/bin")
(dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE")) (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
(add-to-list 'exec-path-from-shell-variables var)) (add-to-list 'exec-path-from-shell-variables var))
(exec-path-from-shell-initialize)) (exec-path-from-shell-initialize))
(use-package direnv :ensure t) (use-package direnv :ensure t
(with-eval-after-load 'direnv :config
(declare-function direnv-mode "direnv")
(direnv-mode t)) (direnv-mode t))
;; Draw underline lower ;; Draw underline lower
@ -119,30 +119,34 @@
indicate-empty-lines nil) indicate-empty-lines nil)
;;;;;;;;;;;;;;;;; Treemacs ;;;;;;;;;;;;;;;;; Treemacs
(use-package treemacs :ensure t) (use-package treemacs :ensure t
(with-eval-after-load 'treemacs :commands (treemacs-follow-mode treemacs-project-follow-mode treemacs)
:bind (:map icejam-keys-mode-map
([(hyper b)] . treemacs))
:config
(treemacs-follow-mode t) (treemacs-follow-mode t)
(treemacs-project-follow-mode t) (treemacs-project-follow-mode t))
(define-key icejam-keys-mode-map [(hyper b)] 'treemacs))
(use-package treemacs-all-the-icons :ensure t :requires (treemacs)) (use-package treemacs-all-the-icons :ensure t :defer t
(with-eval-after-load 'treemacs-all-the-icons :requires (treemacs)
(treemacs-load-theme "all-the-icons")) :commands (treemacs-load-theme)
:config (treemacs-load-theme "all-the-icons"))
;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
(use-package keyfreq :ensure t) (use-package keyfreq :ensure t
(with-eval-after-load 'keyfreq :config
(declare-function keyfreq-mode "keyfreq")
(declare-function keyfreq-autosave-mode "keyfreq")
(keyfreq-mode t) (keyfreq-mode t)
(keyfreq-autosave-mode t)) (keyfreq-autosave-mode t))
;;;;;;;;;;;;;;;;; Show hints about key combinations ;;;;;;;;;;;;;;;;; Show hints about key combinations
(use-package which-key :ensure t) (use-package which-key :ensure t
(with-eval-after-load 'which-key :custom (which-key-idle-delay 0.5)
(setq which-key-idle-delay 0.5) :config (which-key-mode t))
(which-key-mode t))
;;;;;;;;;;;;;;;;; Use C-n to create a new line ;;;;;;;;;;;;;;;;; Use C-n to create a new line
(setq next-line-add-newlines t) (setopt next-line-add-newlines t)
;;;;;;;;;;;;;;;;; Speed up long line display by disabling bidirectional text ;;;;;;;;;;;;;;;;; Speed up long line display by disabling bidirectional text
(setq-default bidi-paragraph-direction 'left-to-right (setq-default bidi-paragraph-direction 'left-to-right

21
lisp/icejam-blocking.el Normal file
View file

@ -0,0 +1,21 @@
;;; icejam-blocking.el --- summary
;; Author: Maciej Szlosarczyk
;; Maintainer: Maciej Szlosarczyk
;; Version: 0.1-snapshot
;;; Commentary:
;; These packages are foundational dependency and possibly can be blocking.
;;; Code:
(use-package transient :ensure (:wait t))
(use-package diminish :ensure (:wait t))
(use-package company :ensure (:wait t))
;; https://emacs-lsp.github.io/lsp-mode/page/performance/#use-plists-for-deserialization
;; This supposedly makes it faster.
(setenv "LSP_USE_PLISTS" "true")
(use-package lsp-mode :ensure (:wait t))
(provide 'icejam-blocking)
;;; icejam-blocking.el ends here

15
lisp/icejam-company-yasnippet.el
View file

@ -2,18 +2,19 @@
;;; Commentary: ;;; Commentary:
;;; Company completion framework configuration ;;; Company completion framework configuration
;;; Code: ;;; Code:
(require 'icejam-blocking)
(use-package yasnippet :ensure t) (use-package yasnippet :ensure t
(use-package yasnippet-snippets :ensure t :requires (yasnippet)) :config
(use-package company :ensure t :requires (yasnippet yasnippet-snippets))
(use-package company-box :ensure t :requires (company))
(with-eval-after-load 'yasnippet
(yas-global-mode t) (yas-global-mode t)
(unbind-key "C-c & C-n" yas-minor-mode-map) (unbind-key "C-c & C-n" yas-minor-mode-map)
(unbind-key "C-c & C-s" yas-minor-mode-map) (unbind-key "C-c & C-s" yas-minor-mode-map)
(unbind-key "C-c & C-v" yas-minor-mode-map)) (unbind-key "C-c & C-v" yas-minor-mode-map))
(use-package yasnippet-snippets :ensure t :after (yasnippet))
(use-package company-box :ensure t :after (company)
:hook (company-mode . company-box-mode))
(with-eval-after-load 'company (with-eval-after-load 'company
(global-company-mode t) (global-company-mode t)
@ -85,7 +86,5 @@
(define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete) (define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
(define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common)) (define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common))
(with-eval-after-load 'company-box (add-hook 'company-mode-hook #'company-box-mode))
(provide 'icejam-company-yasnippet) (provide 'icejam-company-yasnippet)
;;; icejam-company-yasnippet.el ends here ;;; icejam-company-yasnippet.el ends here

55
lisp/icejam-completing-read.el
View file

@ -1,6 +1,9 @@
;;; icejam-completing-read -- Functions related to completing-read -*- lexical-binding: t; -*- ;;; icejam-completing-read -- Functions related to completing-read -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; ;;;
;;; completing-read is the way of completing things in minibuffer. This module
;;; provides all of that functionality, everything related to minbuffer being helpful.
;;;
;;; Code: ;;; Code:
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
@ -27,36 +30,30 @@
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode) (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
;; Actual orderless ;; Actual orderless
(use-package vertico :ensure t) (use-package vertico :ensure t
(use-package orderless :ensure t) :custom ((vertico-scroll-margin 1 "Scroll on N-1")
(use-package marginalia :ensure t) (vertico-count 15 "Show 5 more candidates")
(use-package consult :ensure t) (vertico-resize t "Grow and shrink the vertico minibufffer")
(vertico-cycle t "Cycle completion"))
:config
(vertico-mode t))
(use-package orderless :ensure t
:custom ((completion-styles '(orderless partial-completion basic)
"Fallback to basic if orderless does not work.")
(completion-category-defaults nil)
(completion-category-overrides
'((file (styles partial-completion))))))
(use-package marginalia :ensure t
:config (marginalia-mode t))
(use-package consult :ensure t
:bind (:map icejam-keys-mode-map
("C-c t" . find-file)
("M-g" . consult-goto-line)
("C-c a" . consult-ripgrep)))
(use-package helpful :ensure t) (use-package helpful :ensure t)
(with-eval-after-load 'vertico
(setq
vertico-scroll-margin 0 ;; Different scroll margin
vertico-count 15 ;; Show more candidates
vertico-resize t ;; Grow and shrink the Vertico minibuffer
vertico-cycle t ;; Enable cycling for `vertico-next/previous'
)
(vertico-mode))
(with-eval-after-load 'orderless
(setq
;; Configure a custom style dispatcher (see the Consult wiki)
;; (orderless-style-dispatchers '(+orderless-consult-dispatch orderless-affix-dispatch))
;; (orderless-component-separator #'orderless-escapable-split-on-space)
completion-styles '(orderless basic) ;; Fallback to basic
completion-category-defaults nil
completion-category-overrides '((file (styles partial-completion)))))
(with-eval-after-load 'marginalia
(marginalia-mode t))
(with-eval-after-load 'consult
(define-key icejam-keys-mode-map (kbd "C-c a") 'consult-ripgrep)
(define-key icejam-keys-mode-map (kbd "C-c t") 'find-file))
(provide 'icejam-completing-read) (provide 'icejam-completing-read)
;;; icejam-completing-read.el ends here ;;; icejam-completing-read.el ends here

38
lisp/icejam-copilot.el
View file

@ -9,14 +9,14 @@
;;; Copilot and other GPT stuff ;;; Copilot and other GPT stuff
;;; Code: ;;; Code:
(use-package copilot (use-package copilot :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
:ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))) :defer t
;; It sort of sucks so let's disable it.
(with-eval-after-load 'copilot ;; :hook ((prog-mode . copilot-mode))
;; Do not enable copilot by default because it sorta sucks? :bind (:map copilot-completion-map
;; (add-hook 'prog-mode-hook 'copilot-mode) ([tab] . copilot-accept-completion))
(define-key copilot-completion-map (kbd "<tab>") 'copilot-accept-completion) :config
(define-key copilot-completion-map (kbd "TAB") 'copilot-accept-completion)) (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode . 2)))
;; Enable Anthropic Claude LLM support for chat (it also sucks) ;; Enable Anthropic Claude LLM support for chat (it also sucks)
(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key." (defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
@ -24,26 +24,22 @@
:group 'icejam :group 'icejam
:initialize 'custom-initialize-set) :initialize 'custom-initialize-set)
(use-package gptel :ensure t) (use-package gptel :ensure t :defer t
(with-eval-after-load 'gptel :config
(setq (setq
gptel-model "claude-3-5-sonnet-20241022" gptel-model 'claude-3-5-sonnet-20241022
gptel-backend (gptel-make-anthropic "Claude" gptel-backend (gptel-make-anthropic "Claude"
:stream t :key (lambda () anthropic-api-key)))) :stream t :key (lambda () anthropic-api-key))))
;; Pretend to be 'AI editor'. ;; Pretend to be 'AI editor'.
(use-package elysium :ensure t) (use-package elysium :ensure t :defer t
(with-eval-after-load 'elysium :custom
(setq ((elysium-window-size 0.33 "The elysium buffer will be 1/3 your screen")
;; The elysium buffer will be 1/3 your screen (elysium-window-style 'vertical "Elysium buffer will be vertical")))
elysium-window-size 0.33
;; Elysium buffer will be vertical
elysium-window-style 'vertical))
;; Merging with SMerge ;; Merging with SMerge
(use-package smerge-mode :ensure nil) (use-package smerge-mode :ensure nil
(with-eval-after-load 'smerge-mode :hook ((prog-mode . smerge-mode)))
(add-hook 'prog-mode-hook #'smerge-mode))
(provide 'icejam-copilot) (provide 'icejam-copilot)
;;; icejam-copilot.el ends here ;;; icejam-copilot.el ends here

7
lisp/icejam-custom-init.el
View file

@ -14,6 +14,9 @@
(setq gc-cons-threshold 500000000) (setq gc-cons-threshold 500000000)
(setq gc-cons-percentage 0.6) (setq gc-cons-percentage 0.6)
;; Allow for deeper stacktraces / recursion
(setq max-lisp-eval-depth 10000)
;;; Use elpaca for package management. ;;; Use elpaca for package management.
(defvar elpaca-installer-version 0.7) (defvar elpaca-installer-version 0.7)
(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory)) (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
@ -54,11 +57,12 @@
(add-hook 'after-init-hook #'elpaca-process-queues) (add-hook 'after-init-hook #'elpaca-process-queues)
(elpaca `(,@elpaca-order)) (elpaca `(,@elpaca-order))
(setq use-package-verbose t)
(setq use-package-compute-statistics t)
(elpaca elpaca-use-package (elpaca elpaca-use-package
;; Enable use-package :ensure support for Elpaca. ;; Enable use-package :ensure support for Elpaca.
(elpaca-use-package-mode)) (elpaca-use-package-mode))
(defun icejam-elpaca-write-lock () (defun icejam-elpaca-write-lock ()
"Write elpaca lock file." "Write elpaca lock file."
(interactive) (interactive)
@ -73,6 +77,7 @@
;; General configuration files. ;; General configuration files.
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
(require 'icejam-blocking)
(require 'icejam-base) (require 'icejam-base)
(require 'icejam-sys-specific) (require 'icejam-sys-specific)
(require 'icejam-tree-sitter) (require 'icejam-tree-sitter)

20
lisp/icejam-dashboard.el
View file

@ -10,21 +10,19 @@
;;; Code: ;;; Code:
(use-package dashboard (use-package dashboard :ensure t :demand t
:ensure (:wait t) :commands dashboard-setup-startup-hook
:config :hook
(dashboard-setup-startup-hook) ((elpaca-after-init . dashboard-open))
:custom
(setq dashboard-footer-messages ((dashboard-footer-messages '("Happy coding!" "I showed you my source code, pls respond"))
'("Happy coding!" "I showed you my source code, pls respond")) (dashboard-startup-banner 'logo)
(dashboard-items '((recents . 5)
(setq dashboard-startup-banner 'logo)
(setq dashboard-items '((recents . 5)
;; (bookmarks . 5) ;; (bookmarks . 5)
;; (agenda . 5) ;; (agenda . 5)
;; (registers . 5) ;; (registers . 5)
(projects . 5)))) (projects . 5))))
:config (dashboard-setup-startup-hook))
(provide 'icejam-dashboard) (provide 'icejam-dashboard)
;;; icejam-dashboard.el ends here ;;; icejam-dashboard.el ends here

20
lisp/icejam-deft.el
View file

@ -6,16 +6,12 @@
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
(require 'icejam-transient) (require 'icejam-transient)
(use-package deft (use-package deft :ensure t
:ensure t :custom
:defer t ((deft-directory (substitute-in-file-name "$DEFT_PATH"))
:config (setq (deft-default-extension "md")
deft-directory (substitute-in-file-name "$DEFT_PATH") (deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$")
deft-default-extension "md" (deft-strip-summary-regexp (concat "\\("
;; NB! deft returns absolute paths as filenames, so
;; ignore works slightly differently.
deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$"
deft-strip-summary-regexp (concat "\\("
"[\n\t]" ;; blank "[\n\t]" ;; blank
"\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
"\\|^Title:.*$" ;; Title string "\\|^Title:.*$" ;; Title string
@ -23,8 +19,8 @@
"\\|^\\[\\[file:.*$" ;; org-mode inline-images "\\|^\\[\\[file:.*$" ;; org-mode inline-images
;; org-mode properties ;; org-mode properties
;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;; ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
"\\)") "\\)"))
deft-auto-save-interval 30.0)) (deft-auto-save-interval 30.0)))
(provide 'icejam-deft) (provide 'icejam-deft)
;;; icejam-deft.el ends here ;;; icejam-deft.el ends here

30
lisp/icejam-diminish.el
View file

@ -9,20 +9,24 @@
;; diminish minor modes ;; diminish minor modes
;;; Code: ;;; Code:
(use-package diminish :ensure (:wait t)) (require 'icejam-blocking)
;; (use-package diminish :ensure t)
(eval-after-load 'flyspell '(diminish 'flyspell-mode)) (with-eval-after-load 'diminish
(eval-after-load 'flycheck '(diminish 'flycheck-mode)) (with-eval-after-load 'flyspell (diminish 'flyspell-mode))
(eval-after-load 'rainbow-mode '(diminish 'rainbow-mode)) (with-eval-after-load 'flycheck (diminish 'flycheck-mode))
(eval-after-load 'undo-tree '(diminish 'undo-tree-mode)) (with-eval-after-load 'rainbow-mode (diminish 'rainbow-mode))
(eval-after-load 'company '(diminish 'company-mode)) (with-eval-after-load 'undo-tree (diminish 'undo-tree-mode))
(eval-after-load 'which-key '(diminish 'which-key-mode)) (with-eval-after-load 'company (diminish 'company-mode))
(eval-after-load 'eldoc '(diminish 'eldoc-mode)) (with-eval-after-load 'which-key (diminish 'which-key-mode))
(eval-after-load 'yasnippet '(diminish 'yas-minor-mode)) (with-eval-after-load 'eldoc (diminish 'eldoc-mode))
(eval-after-load 'whitespace '(diminish 'whitespace-mode)) (with-eval-after-load 'yasnippet (diminish 'yas-minor-mode))
(eval-after-load 'autorevert '(diminish 'auto-revert-mode)) (with-eval-after-load 'whitespace (diminish 'whitespace-mode))
(eval-after-load 'ivy '(diminish 'ivy-mode)) (with-eval-after-load 'autorevert (diminish 'auto-revert-mode))
(eval-after-load 'gcmh '(diminish 'gcmh-mode)) (with-eval-after-load 'ivy (diminish 'ivy-mode))
(with-eval-after-load 'company-box (diminish 'company-box-mode))
(with-eval-after-load 'smerge-mode (diminish 'smerge-mode))
(with-eval-after-load 'gcmh (diminish 'gcmh-mode)))
(provide 'icejam-diminish) (provide 'icejam-diminish)
;;; icejam-diminish.el ends here ;;; icejam-diminish.el ends here

5
lisp/icejam-flycheck.el
View file

@ -3,8 +3,9 @@
;;; Code: ;;; Code:
;; Use flycheck globally to check syntax and compile languages ;; Use flycheck globally to check syntax and compile languages
(use-package flycheck :ensure t) (use-package flycheck :ensure t
(with-eval-after-load 'flycheck :custom ((flycheck-emacs-lisp-load-path 'inherit))
:config
(global-flycheck-mode t) (global-flycheck-mode t)
(setq flycheck-emacs-lisp-load-path 'inherit) (setq flycheck-emacs-lisp-load-path 'inherit)
(unbind-key "C-c ! C-c" flycheck-mode-map) (unbind-key "C-c ! C-c" flycheck-mode-map)

25
lisp/icejam-ispell.el
View file

@ -3,23 +3,24 @@
;;; Highlight misspelled words ;;; Highlight misspelled words
;;; Code: ;;; Code:
(use-package ispell :ensure nil)
(use-package flyspell-correct :ensure t :after flyspell :defer t)
(use-package flyspell-correct-ivy :ensure t :after flyspell-correct :defer t)
(with-eval-after-load 'ispell
(setq (use-package ispell :ensure nil
ispell-program-name "aspell" :custom
ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")) ((ispell-program-name "aspell")
(add-hook 'prog-mode-hook #'flyspell-mode) (ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2"))))
(add-hook 'text-mode-hook #'flyspell-mode)
(add-hook 'markdown-mode-hook #'flyspell-mode) (use-package flyspell :ensure nil
(add-hook 'flyspell-mode-hook (lambda () :hook ((prog-mode . flyspell-mode)
(text-mode . flyspell-mode)
(markdown-mode . flyspell-mode))
:config
(unbind-key "C-," flyspell-mode-map) (unbind-key "C-," flyspell-mode-map)
(unbind-key "C-." flyspell-mode-map) (unbind-key "C-." flyspell-mode-map)
(unbind-key "C-;" flyspell-mode-map) (unbind-key "C-;" flyspell-mode-map)
(unbind-key "C-c $" flyspell-mode-map) (unbind-key "C-c $" flyspell-mode-map)
(unbind-key "C-M-i" flyspell-mode-map)))) (unbind-key "C-M-i" flyspell-mode-map))
(use-package flyspell-correct :ensure t :after flyspell :defer t)
(provide 'icejam-ispell) (provide 'icejam-ispell)
;;; icejam-ispell.el ends here ;;; icejam-ispell.el ends here

25
lisp/icejam-lsp.el
View file

@ -3,14 +3,8 @@
;;; Global Language Server Protocol Config ;;; Global Language Server Protocol Config
;;; Code: ;;; Code:
;; https://emacs-lsp.github.io/lsp-mode/page/performance/#use-plists-for-deserialization ;; (use-package lsp-mode :ensure (:depth 5) :requires (company))
;; This supposedly makes it faster. (with-eval-after-load 'lsp-mode
(setenv "LSP_USE_PLISTS" "true")
(use-package lsp-mode
:ensure (:depth 5)
:requires (company)
:config
(setq-default lsp-file-watch-threshold 10000 (setq-default lsp-file-watch-threshold 10000
lsp-restart 'auto-restart lsp-restart 'auto-restart
lsp-prefer-capf t lsp-prefer-capf t
@ -65,14 +59,10 @@
(unbind-key "s-l s d" lsp-mode-map) (unbind-key "s-l s d" lsp-mode-map)
(unbind-key "s-l s q" lsp-mode-map) (unbind-key "s-l s q" lsp-mode-map)
(unbind-key "s-l s r" lsp-mode-map) (unbind-key "s-l s r" lsp-mode-map)
(unbind-key "s-l s s" lsp-mode-map) (unbind-key "s-l s s" lsp-mode-map))
:hook ((typescript-mode . lsp-deferred)))
(use-package lsp-ui (use-package lsp-ui :ensure t :after (lsp-mode))
:ensure t (with-eval-after-load 'lsp-ui
:requires (lsp-mode)
:defer t
:config
(setq lsp-ui-doc-enable t (setq lsp-ui-doc-enable t
lsp-ui-header t lsp-ui-header t
lsp-ui-delay 0.5 ;; Wait half a second to display documentation lsp-ui-delay 0.5 ;; Wait half a second to display documentation
@ -80,10 +70,7 @@
lsp-ui-doc-include-signature t)) lsp-ui-doc-include-signature t))
;; Lsp debugger mode ;; Lsp debugger mode
(use-package dap-mode (use-package dap-mode :ensure t :after (lsp-mode lsp-ui))
:ensure t
:defer t
:requires (lsp-mode lsp-ui))
(provide 'icejam-lsp) (provide 'icejam-lsp)
;;; icejam-lsp.el ends here ;;; icejam-lsp.el ends here

55
lisp/icejam-prog-mode.el
View file

@ -12,40 +12,33 @@
(global-eldoc-mode t) (global-eldoc-mode t)
;; Revert tag tables without asking ;; Revert tag tables without asking
(use-package etags :ensure nil) (use-package etags :ensure nil
(with-eval-after-load 'etags :custom (tags-revert-without-query t "Revert tag tables without asking"))
(setq tags-revert-without-query t))
;;; Show trailing whitespace and remove whitespace on save ;;; Show trailing whitespace and remove whitespace on save
(use-package whitespace :ensure nil) (use-package whitespace :ensure nil
:custom ((whitespace-style #'(face trailing empty) "New whitespace style.")
(with-eval-after-load 'whitespace (require-final-newline 't "Insert newline on save"))
(setq :hook ((prog-mode . whitespace-mode)
;; Change whitespace style (text-mode . whitespace-mode)
whitespace-style #'(face trailing empty) (conf-mode . whitespace-mode)
;; Insert newline on save (before-save . whitespace-cleanup)))
require-final-newline 't)
(add-hook 'prog-mode-hook #'whitespace-mode)
(add-hook 'text-mode-hook #'whitespace-mode)
(add-hook 'conf-mode-hook #'whitespace-mode)
(add-hook 'before-save-hook #'whitespace-cleanup))
(setq-default indent-tabs-mode nil) (setq-default indent-tabs-mode nil)
;; Use colorful, matching parens ;; Use colorful, matching parens
(use-package rainbow-delimiters :ensure t) ;; Rework the code below to enumerate each hook separately:
(with-eval-after-load 'rainbow-delimiters (use-package rainbow-delimiters :ensure t
:hook ((prog-mode . rainbow-delimiters-mode)
(text-mode . rainbow-delimiters-mode))
:config
(electric-pair-mode t) (electric-pair-mode t)
(show-paren-mode t) (show-paren-mode t))
(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
(add-hook 'text-mode-hook #'rainbow-delimiters-mode))
;;; Show hex (#aaa) colors as colors ;;; Show hex (#aaa) colors as colors
(use-package rainbow-mode :ensure t) (use-package rainbow-mode :ensure t
(with-eval-after-load 'rainbow-mode :hook ((prog-mode . rainbow-mode)
(add-hook 'prog-mode-hook #'rainbow-mode) (text-mode . rainbow-mode)))
(add-hook 'text-mode-hook #'rainbow-mode))
;; Dash integration ;; Dash integration
(use-package dash-at-point :ensure t) (use-package dash-at-point :ensure t)
@ -64,17 +57,17 @@
(setq-local tab-width step) (setq-local tab-width step)
(setq-local tab-stop-list (number-sequence step 200 step))) (setq-local tab-stop-list (number-sequence step 200 step)))
(use-package column-enforce-mode :ensure t) (use-package column-enforce-mode :ensure t
(with-eval-after-load 'column-enforce-mode :config
(declare-function global-column-enforce-mode "column-enforce-mode")
(global-column-enforce-mode t)) (global-column-enforce-mode t))
;; PCRE to emacs regex translations ;; PCRE to Emacs regex translations
(use-package pcre2el :ensure t) (use-package pcre2el :ensure t)
;; Visual regexp ;; Visual regexp
(use-package visual-regexp-steroids :ensure t :requires (pcre2el)) (use-package visual-regexp-steroids :ensure t :requires (pcre2el)
(with-eval-after-load 'visual-regexp-steroids :custom (vr/engine 'pcre2el "Use pcre2el for regexes"))
(setq vr/engine 'pcre2el))
(provide 'icejam-prog-mode) (provide 'icejam-prog-mode)
;;; icejam-prog-mode.el ends here ;;; icejam-prog-mode.el ends here

4
lisp/icejam-speed-type.el
View file

@ -10,9 +10,7 @@
;;; Code: ;;; Code:
(use-package speed-type (use-package speed-type :ensure t :defer t)
:ensure t
:defer t)
(provide 'icejam-speed-type) (provide 'icejam-speed-type)
;;; icejam-speed-type.el ends here ;;; icejam-speed-type.el ends here

94
lisp/icejam-themes.el
View file

@ -2,56 +2,52 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; Code:
(use-package spaceline :ensure t :defer t) (use-package spaceline :ensure t
:hook ((elpaca-after-init . spaceline-emacs-theme)))
(use-package base16-theme :ensure t (use-package base16-theme :ensure t
:init ;; :config
(load-theme 'base16-atelier-forest-light t t) ;; (load-theme 'base16-atelier-forest-light t t)
(load-theme 'base16-harmonic16-light t t) ;; (load-theme 'base16-harmonic16-light t t)
(load-theme 'base16-horizon-light t t) ;; (load-theme 'base16-horizon-light t t)
(load-theme 'base16-humanoid-light t t) ;; (load-theme 'base16-humanoid-light t t)
(load-theme 'base16-zenburn t) ;; (load-theme 'base16-zenburn t)
(load-theme 'base16-tomorrow-night-eighties t t) ;; (load-theme 'base16-tomorrow-night-eighties t t)
(load-theme 'base16-darcula t t) ;; (load-theme 'base16-darcula t t)
(load-theme 'base16-solarflare t t) ;; (load-theme 'base16-solarflare t t)
(load-theme 'base16-snazzy t t) ;; (load-theme 'base16-snazzy t t)
(load-theme 'base16-onedark t t) ;; (load-theme 'base16-onedark t t)
(load-theme 'base16-gruvbox-dark-hard t t) ;; (load-theme 'base16-gruvbox-dark-hard t t)
(load-theme 'modus-vivendi t t) ;; (load-theme 'modus-vivendi t t)
(load-theme 'base16-zenbones t t) ;; (load-theme 'base16-zenbones t t)
:config )
;; Set themes for terminal mode
(setq base16-theme-256-color-source "colors"))
(use-package apropospriate-theme :ensure t ;; (use-package apropospriate-theme :ensure t
:init (load-theme 'apropospriate-light t t)) ;; :config (load-theme 'apropospriate-light t t))
(use-package leuven-theme :ensure t ;; (use-package leuven-theme :ensure t
:init ;; :config
(load-theme 'leuven t t)) ;; (load-theme 'leuven t t))
(use-package modus-themes :ensure t) ;; (use-package modus-themes :ensure t )
(use-package darktooth-theme :ensure t ;; (use-package darktooth-theme :ensure t
:init ;; :config
(load-theme 'darktooth t t)) ;; (load-theme 'darktooth t t))
(use-package cyberpunk-theme :ensure t ;; (use-package color-theme-sanityinc-tomorrow :ensure t
:init ;; :config
(load-theme 'cyberpunk t t)) ;; ;; Dark themes
;; (load-theme 'sanityinc-tomorrow-eighties t t)
(use-package color-theme-sanityinc-tomorrow :ensure t ;; (load-theme 'sanityinc-tomorrow-night t t)
:init ;; ;; Light theme
;; Dark themes ;; (load-theme 'sanityinc-tomorrow-day t t))
(load-theme 'sanityinc-tomorrow-eighties t t)
(load-theme 'sanityinc-tomorrow-night t t)
;; Light theme
(load-theme 'sanityinc-tomorrow-day t t))
(use-package zenburn-theme :ensure t
:init
(load-theme 'zenburn t t))
(use-package catppuccin-theme :ensure t
:init (load-theme 'catppuccin t t)
:config (setq catppuccin-flavor 'frappe))
;; (use-package zenburn-theme :ensure t
;; :config
;; (load-theme 'zenburn t t))
;; (use-package catppuccin-theme :ensure t
;; :custom
;; ((catpuccin-flavor 'frappe))
;; :config
;; (load-theme 'catppuccin t t))
;; Disable cursor blinking ;; Disable cursor blinking
(blink-cursor-mode 0) (blink-cursor-mode 0)
@ -61,12 +57,10 @@
(setq base16-theme-256-color-source "colors") (setq base16-theme-256-color-source "colors")
(require 'icejam-base16-zenburn) (require 'icejam-base16-zenburn)
(require 'icejam-base16-harmonic-light) (require 'icejam-base16-harmonic-light)
(enable-theme 'icejam-base16-zenburn))
;; This is spacemacs modeline but I have disabled it for now. (if (memq window-system '(x mac ns))
;; It doesn't seem like I need it for anything. (enable-theme 'icejam-base16-zenburn)
;; (spaceline-emacs-theme) (enable-theme 'icejam-base16-zenburn)))
(declare-function spaceline-emacs-theme nil)
(provide 'icejam-themes) (provide 'icejam-themes)
;;; icejam-themes.el ends here ;;; icejam-themes.el ends here

12
lisp/icejam-transient.el
View file

@ -5,7 +5,8 @@
(require 'icejam-avy) (require 'icejam-avy)
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
(use-package transient :ensure (:wait t)) (require 'icejam-blocking)
;; (use-package transient :ensure (:wait t) :demand t)
(defun icejam-mark-and-indent-whole-buffer () (defun icejam-mark-and-indent-whole-buffer ()
"Mark and indent whole buffer." "Mark and indent whole buffer."
@ -41,12 +42,12 @@
["Manipulate" ["Manipulate"
("c" "Toggle Comment" comment-line) ("c" "Toggle Comment" comment-line)
("r" "Replace" vr/replace) ("r" "Replace" vr/replace)
("i" "Indent" indent-region) ("i" "Indent" indent-region)]
("a" "Align" align-regexp)]
["Complete" ["Complete"
("y" "Snippet" company-yasnippet) ("y" "Snippet" company-yasnippet)
("m" "Any (Company)" company-complete) ("m" "Any (Company)" company-complete)
("g" "Ask GPT" gptel-menu)] ("g" "Ask GPT" gptel-menu)
("e" "Refactor (Elysium)" elysium-query)]
["Find" ["Find"
("s" "Swiper" consult-line) ("s" "Swiper" consult-line)
("u" "Vundo" vundo) ("u" "Vundo" vundo)
@ -103,8 +104,7 @@
"Font Commands." "Font Commands."
["" [""
["Everywhere" ["Everywhere"
("R" "Reset to default" set-font-to-screen) ("s" "Adjust font size" global-text-scale-adjust)]
("s" "Set size" set-font-size)]
["In this buffer" ["In this buffer"
("i" "Bigger" (lambda () (interactive) (text-scale-increase 1))) ("i" "Bigger" (lambda () (interactive) (text-scale-increase 1)))
("d" "Smaller" (lambda () (interactive) (text-scale-decrease 1))) ("d" "Smaller" (lambda () (interactive) (text-scale-decrease 1)))

23
lisp/icejam-tree-sitter.el
View file

@ -6,11 +6,20 @@
;;; Commentary: ;;; Commentary:
;; Load treesitter grammars automatically ;; Load treesitter grammars automatically, based on the grammars provided by the
;; community.
;;; Code: ;;; Code:
(use-package tree-sitter-langs :ensure t
:config
(declare-function tree-sitter-langs--bin-dir "tree-sitter-langs")
(add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))
(defun icejam-tree-sitter-symlink-grammar-objects () (defun icejam-tree-sitter-symlink-grammar-objects ()
"Tree-sitter-langs-build releases grammars as LANG.so, but treesit needs libtree-sitter-LANG.so." "Create symlinks for treesitter grammars.
Tree-sitter-langs-build releases grammars as LANG.so. Treesit needs
libtree-sitter-LANG.so"
(interactive) (interactive)
(dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full (dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
(concat "\\" (car tree-sitter-load-suffixes) "$"))) (concat "\\" (car tree-sitter-load-suffixes) "$")))
@ -20,15 +29,7 @@
(file-name-nondirectory file)))) (file-name-nondirectory file))))
(if (memq system-type '(ms-dos windows-nt cygwin)) (if (memq system-type '(ms-dos windows-nt cygwin))
(copy-file file target) (copy-file file target)
(make-symbolic-link file target))))) (make-symbolic-link file target))))))
;;;;;;;;;;;;;;;;;;;;;; Tree sitter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package tree-sitter-langs :ensure t)
(with-eval-after-load 'tree-sitter-langs
(add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir)))
;; (use-package tree-sitter-indent :ensure t)
(add-hook 'tree-sitter-after-on-hook 'tree-sitter-hl-mode)
(provide 'icejam-tree-sitter) (provide 'icejam-tree-sitter)
;;; icejam-tree-sitter.el ends here ;;; icejam-tree-sitter.el ends here

9
lisp/langs/icejam-lang-elisp.el
View file

@ -5,7 +5,7 @@
(require 'icejam-prog-mode) (require 'icejam-prog-mode)
(require 'icejam-transient) (require 'icejam-transient)
(use-package lispy :ensure (:wait t) :defer t) (use-package lispy :ensure t)
(declare-function column-enforce-n "column-enforce-mode" (number)) (declare-function column-enforce-n "column-enforce-mode" (number))
(add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode)) (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
@ -24,18 +24,21 @@
(add-to-list (add-to-list
'icejam-language-transient-alist '(emacs-lisp-mode . icejam-elisp-lang-menu)) 'icejam-language-transient-alist '(emacs-lisp-mode . icejam-elisp-lang-menu))
(with-eval-after-load 'lispy
(declare-function lispy-mode "lispy")
(defun icejam-activate-emacs-lisp-mode () (defun icejam-activate-emacs-lisp-mode ()
"Goodies for editing Emacs files." "Goodies for editing Emacs files."
(icejam-set-indent 2) ;; Default indentation of 2 characters (icejam-set-indent 2) ;; Default indentation of 2 characters
(column-enforce-n 80) (column-enforce-n 80)
(lispy-mode)
(lispy-mode t)
(setq-default indent-tabs-mode nil) (setq-default indent-tabs-mode nil)
;; Company list override ;; Company list override
(add-to-list (make-local-variable 'company-backends) (add-to-list (make-local-variable 'company-backends)
'(company-yasnippet company-capf))) '(company-yasnippet company-capf)))
(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode) (add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode))
(provide 'icejam-lang-elisp) (provide 'icejam-lang-elisp)
;;; icejam-lang-elisp.el ends here ;;; icejam-lang-elisp.el ends here

11
lisp/langs/icejam-lang-elixir.el
View file

@ -9,13 +9,12 @@
(declare-function lsp "lsp-mode" nil) (declare-function lsp "lsp-mode" nil)
(declare-function column-enforce-n "column-enforce-mode" (number)) (declare-function column-enforce-n "column-enforce-mode" (number))
(use-package elixir-mode :defer t :ensure t) (use-package elixir-mode :ensure t)
(use-package elixir-ts-mode :ensure t :requires (elixir-mode lsp-mode lsp-ui))
(use-package elixir-ts-mode :ensure t (with-eval-after-load 'elixir-ts-mode
:requires (elixir-mode lsp-mode lsp-ui) (add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-ts-mode))
:mode (add-to-list 'auto-mode-alist '("\\.ex\\'" . elixir-ts-mode)))
("\\.exs\\'" . elixir-ts-mode)
("\\.ex\\'" . elixir-ts-mode))
(transient-define-prefix icejam-elixir-lang-menu () (transient-define-prefix icejam-elixir-lang-menu ()
"Elixir Buffer Commands." "Elixir Buffer Commands."

32
lisp/langs/icejam-lang-erlang.el
View file

@ -11,7 +11,7 @@
(use-package erlang (use-package erlang
:defer t :defer t
:ensure (:depth 1) :ensure (:depth 1)
:requires (lsp-mode lsp-ui)) :after (lsp lsp-ui))
(cl-defun icejam-erlang-emacs-path (erlang-version) (cl-defun icejam-erlang-emacs-path (erlang-version)
"Find path to Emacs tooling for ERLANG-VERSION." "Find path to Emacs tooling for ERLANG-VERSION."
@ -54,17 +54,6 @@
"Create plist from current Erlang version." "Create plist from current Erlang version."
(seq-find 'icejam-erlang-current-version--plistp icejam-erlang-available-versions)) (seq-find 'icejam-erlang-current-version--plistp icejam-erlang-available-versions))
;; Flycheck checker for Erlang
(flycheck-define-checker erlang-otp
"An Erlang syntax checker using the Erlang interpreter."
:command ("erlc" "-o" temporary-directory "-Wall"
"-I" "../include" "-I" "../../include"
"-I" "../../../include" source)
:error-patterns
((warning line-start (file-name) ":" line ": Warning:" (message) line-end)
(error line-start (file-name) ":" line ": " (message) line-end))
:modes (my-erlang-mode))
(defun icejam-activate-erlang-mode () (defun icejam-activate-erlang-mode ()
"All things for all Erlang, including header files." "All things for all Erlang, including header files."
(when (featurep 'erlang-start) (unload-feature 'erlang-start)) (when (featurep 'erlang-start) (unload-feature 'erlang-start))
@ -86,25 +75,12 @@
(icejam-set-indent 4) (icejam-set-indent 4)
(column-enforce-n 80) (column-enforce-n 80)
;; Add include path so that Erlang does not complain about ;; Start LSP
;; missing header files. (lsp)
(setq-local flycheck-erlang-include-path
(list (format "%sdeps" (project-root (project-current)))
(format "%s_build/default/lib" (project-root (project-current)))
(format "%sinclude" (project-root (project-current)))
(format "%sapps" (project-root (project-current)))))
(setq-local flycheck-erlang-library-path
(list (format "%sdeps" (project-root (project-current)))
(format "%s_build/default/lib" (project-root (project-current)))
(format "%sapps" (project-root (project-current)))))
;; Company list override ;; Company list override
(add-to-list (make-local-variable 'company-backends) (add-to-list (make-local-variable 'company-backends)
'(company-capf company-yasnippet)) '(company-capf company-yasnippet)))
;; Start LSP server
(lsp))
(add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode) (add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)

10
lisp/langs/icejam-lang-markdown.el
View file

@ -3,12 +3,12 @@
;;; Code: ;;; Code:
(require 'icejam-prog-mode) (require 'icejam-prog-mode)
(declare-function elpaca-installed-p "elpacs")
(unless (elpaca-installed-p 'markdown-mode) (unless (elpaca-installed-p 'markdown-mode)
(use-package markdown-mode (use-package markdown-mode :ensure t))
:ensure t
:defer t (with-eval-after-load 'markdown-mode
:init (setq-default markdown-command "pandoc"))) (setq-default markdown-command "pandoc"))
(defun icejam-lang-activate-markdown-mode () (defun icejam-lang-activate-markdown-mode ()
"Reconfigure markdown mode for your own purposes." "Reconfigure markdown mode for your own purposes."

10
lisp/langs/icejam-lang-ocaml.el
View file

@ -7,12 +7,12 @@
(declare-function lsp "lsp-mode" nil) (declare-function lsp "lsp-mode" nil)
(use-package merlin :defer t :ensure t) (use-package merlin :defer t :ensure t)
(use-package opam-switch-mode :ensure t :defer t) (use-package opam-switch-mode :defer t :ensure t)
(use-package dune :defer t :ensure t) (use-package dune :defer t :ensure t)
(use-package tuareg (use-package tuareg :defer t :ensure t)
:defer t
:ensure t (with-eval-after-load 'tuareg
:config (add-hook 'tuareg-mode-hook 'merlin-mode)) (add-hook 'tuareg-mode-hook 'merlin-mode))
(transient-define-prefix icejam-ocaml-lang-menu () (transient-define-prefix icejam-ocaml-lang-menu ()
"Ocaml Actions." "Ocaml Actions."

9
lisp/langs/icejam-lang-other.el
View file

@ -31,17 +31,12 @@
(defun icejam-lang-activate-yaml-mode () (defun icejam-lang-activate-yaml-mode ()
"Activate yaml-mode." "Activate yaml-mode."
(lsp)) (lsp))
(add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode)) (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))
;; Other text files ;; Other text files
(use-package json-mode :ensure t :defer t) (use-package json-mode :ensure t :defer t)
(use-package git-modes (use-package git-modes :ensure t :defer t
:ensure t :hook (gitignore . whitespace-mode-hook))
:defer t
:hook ((gitignore-mode . whitespace-mode)
(before-save . whitespace-cleanup)))
(provide 'icejam-lang-other) (provide 'icejam-lang-other)
;;; icejam-lang-other.el ends here ;;; icejam-lang-other.el ends here