.forgejo/workflows/demo.yml

@@ -20,7 +20,7 @@ jobs:
         run: npm install -g @emacs-eask/cli
 
       - name: Run tests
-        run: eask test buttercup
+        run: emacs --init-directory . --debug-init --eval "(kill-emacs 0)"
 
       - name: Uninstall eask
         run: npm uninstall -g @emacs-eask/cli

.gitignore

@@ -25,8 +25,6 @@ ac-comphist.dat
 /speed-type
 /tutorial
 /tree-sitter
-emacs.keyfreq
-ielm-history.eld
 
 # Ignore actual init as it can contain private data
 init.el

README.MD

@@ -1,8 +1,14 @@
-# Emacs configuration
+# My emacs config
 
-This is the repository of my emacs configuration that I use on both MacOS and Linux. There are some additional configuration properties to use with BSD when I was testing it, but it is best treated as abandoned.
+Contains config I use for the following languages/modes:
 
-I predominantly write Elixir, so that part is the most polished bit of the configuration but it also works for Ruby, Rust, Go, Javascript/Typescript and Kotlin. I use emacs for programming, so there is no org-mode, GTD, email or RSS here. I use deft to keep some programming notes here and there.
+* Elixir
+* Ruby
+* Rust
+* Markdown
+* HTML and compatibile (ERB)
+
+As of current iteration, I avoid usage of Evil modes, instead focusing of usage of Emacs functionality.
 
 ## Installation
 
@@ -13,5 +19,6 @@ git clone git@github.com:maciej-szlosarczyk/emacs.git ~/.emacs.d
 And then put the following lines into init.el
 
 ```emacs
+(add-to-list 'load-path (concat user-emacs-directory "lisp"))
 (require 'icejam-custom-init)
 ```

early-init.el

@@ -17,17 +17,4 @@
 ;; Log garbage collection.
 (setq garbage-collection-messages nil)
 
-;; Monitor startup time
-(add-hook 'emacs-startup-hook
-          (lambda ()
-            (message "Emacs ready in %s with %d garbage collections."
-                     (format "%.2f seconds"
-                             (float-time
-                              (time-subtract after-init-time before-init-time)))
-                     gcs-done)))
-
-;; set path for native compilation to work
-(setenv "PATH" "/Users/maciej/.local/share/zinit/polaris/bin:/Users/maciej/.asdf/shims:/Users/maciej/.local/bin:/Users/maciej/.opam/default/bin:/Users/maciej/.go/bin:/Users/maciej/.elan/bin:/opt/homebrew/opt/postgresql@17/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/Library/Apple/usr/bin:/usr/local/MacGPG2/bin:/usr/local/share/dotnet:/Users/maciej/.dotnet/tools:/Applications/Postgres.app/Contents/Versions/latest/bin:/Applications/kitty.app/Contents/MacOS")
-(setq exec-path (split-string (getenv "PATH") path-separator))
-
 ;;; early-init.el ends here

lisp/icejam-aider.el

@@ -1,81 +0,0 @@
-;;; icejam-aider.el --- summary -*- lexical-binding: t; -*-
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Commentary:
-
-;;; Copilot and other GPT stuff
-
-;;; Code:
-(use-package copilot :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
-  :defer t
-  ;; It sort of sucks so let's disable it.
-  ;; :hook ((prog-mode . copilot-mode))
-  :bind (:map copilot-completion-map
-              ([tab] . copilot-accept-completion))
-  :config
-  (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode . 2)))
-
-;; Enable Anthropic Claude LLM support for chat (it also sucks)
-(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
-  :type 'string
-  :group 'icejam
-  :initialize 'custom-initialize-set)
-
-(use-package gptel :ensure t :defer t
-  :config
-  (declare-function gptel-make-anthropic "gptel")
-  (declare-function gptel-make-ollama "gptel")
-  (gptel-make-ollama "Ollama@Linux"
-    :host "192.168.88.110:11434"
-    :stream t
-    :models '(qwen2.5-coder:7b qwen2.5-coder:14b deepseek-r1:14b deepseek-r1:32b))
-  (setq
-   gptel-model 'claude-3-5-sonnet-20241022
-   gptel-backend (gptel-make-anthropic "Claude"
-                   :stream t :key (lambda () anthropic-api-key))))
-
-;; Pretend to be 'AI editor' vol 1. Before usage make sure aider is installed:
-;; $ pip install aider-install
-;; $ aider install
-;; (use-package aider :ensure (:host github :repo "tninja/aider.el")
-;;   :defer t
-;;   :config
-;;   ;; (setenv "OLLAMA_API_BASE" "http://127.0.0.1:11434")
-;;   (setenv "OLLAMA_API_BASE" "http://192.168.88.110:11434")
-;;   (setopt aider-args (list "--model"
-;;                            "ollama_chat/deepseek-r1:32b"
-;;                            "--no-auto-commits"
-;;                            "--no-analytics"
-;;                            "--no-gitignore")))
-
-(use-package aidermacs :ensure (:host github :repo "MatthewZMD/aidermacs")
-  :defer t
-  :config
-  ;; (setenv "OLLAMA_API_BASE" "http://127.0.0.1:11434")
-  (setenv "OLLAMA_API_BASE" "http://192.168.88.13:11434")
-  (setopt aidermacs-default-chat-mode 'architect)
-  (setopt aidermacs-default-model "ollama_chat/qwen3-coder:30b")
-  (setopt aider-extra-args (list "--model"
-                                 "ollama_chat/qwen3-coder:30b"
-                                 "--no-auto-commits"
-                                 "--no-analytics"
-                                 "--no-gitignore")))
-
-;; Pretend to be 'AI editor' vol 2.
-(use-package elysium :ensure t :defer t
-  :config
-  (setopt
-   ;; The elysium buffer will be 1/3 your screen
-   elysium-window-size 0.33
-   ;; Elysium buffer will be vertical
-   elysium-window-style 'vertical))
-
-;; Merging with SMerge
-(use-package smerge-mode :ensure nil
-  :hook ((prog-mode . smerge-mode)))
-
-(provide 'icejam-aider)
-;;; icejam-aider.el ends here

lisp/icejam-avy.el

@@ -8,12 +8,11 @@
 
 ;; Avy is a navigation manager.
 
-(eval-when-compile (defvar icejam-keys-mode-map))
-
 ;;; Code:
+(require 'icejam-keys-mode)
+
 (use-package avy :ensure t :defer t
-  :config
+  :custom (avy-timeout-seconds 1 "Wait for 1 second for candidates")
-  (setopt avy-timeout-seconds 1.0) ;; Wait for 1 second for candidates
   :bind (:map icejam-keys-mode-map
               ;; Jump to text in sight with CMD-j
               ([(hyper j)] . avy-goto-char-timer)))

lisp/icejam-base.el

@@ -9,8 +9,11 @@
 ;; pkg/base defines basic packages and environment.
 
 ;;; Code:
+(require 'icejam-keys-mode)
 
+;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;;
 ;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
+
 ;; Update emacs less often
 (setopt idle-update-delay 1.0)
 
@@ -18,8 +21,7 @@
 ;; this to `nil' in the past, but the `bidi-display-reordering's docs say that
 ;; is an undefined state and suggest this to be just as good:
 (setq-default bidi-display-reordering 'left-to-right
-              bidi-paragraph-direction 'left-to-right
+              bidi-paragraph-direction 'left-to-right)
-              bidi-inhibit-bpa t)
 
 ;; Reduce rendering/line scan work for Emacs by not rendering cursors or regions
 ;; in non-focused windows.
@@ -31,13 +33,9 @@
 ;; quickly self-correct.
 (setopt fast-but-imprecise-scrolling t)
 
-;; Trust local folder
-(setopt trusted-content '("~/.emacs.d/" "~/Development/"))
-
 ;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;;
-(use-package tramp :ensure nil :defer 5
+(require 'tramp)
-  :config
+(setopt tramp-default-method "ssh")
-  (setopt tramp-default-method "ssh"))
 
 ;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
 (global-set-key (kbd "RET") 'newline)
@@ -50,14 +48,12 @@
 (use-package buffer-move :ensure t :defer t)
 
 ;; Garbage collection magic hack
-(use-package gcmh :ensure t :defer t
+(use-package gcmh :ensure t
-  :commands (gcmh-mode)
+  :custom ((gcmh-verbose nil "Do not log GC messages.")
-  :hook ((elpaca-after-init . (lambda () (gcmh-mode t))))
+           (gcmh-idle-delay 'auto "Compute GC delay based on gcmh-auto-idle-delay-factor")
+           (gcmh-auto-idle-delay-factor 10 "Original value was 10"))
   :config
-  (setopt gcmh-verbose nil) ;; Do not log GC messages
+  (gcmh-mode t))
-  (setopt gcmh-idle-delay 'auto) ;; Compute GC delay based on gcmh-auto-idle-delay-factor
-  (setopt gcmh-auto-idle-delay-factor 10) ;; Original value was 10
-  (setopt gcmh-high-cons-threshold (* 256 1024 1024)))
 
 ;; #====================== Backup config #==============================
 (setopt backup-directory-alist
@@ -67,21 +63,17 @@
 
 (setopt backup-by-copying t)
 (setopt delete-old-versions t
-  kept-new-versions 10
+  kept-new-versions 6
-  kept-old-versions 5
+  kept-old-versions 2
   version-control t)
 
 ; Do not create .#foo.file lock files
 (setopt create-lockfiles nil)
 
 ;; Enable line numbers and show cursors position
-(dolist (mode '(prog-mode-hook
+(add-hook 'prog-mode-hook 'display-line-numbers-mode)
-                text-mode-hook
+(add-hook 'text-mode-hook 'display-line-numbers-mode)
-                conf-mode-hook))
+(add-hook 'conf-mode-hook 'display-line-numbers-mode)
-  (add-hook mode 'display-line-numbers-mode)
-  ;; Highlight current line.
-  (add-hook mode 'hl-line-mode))
-
 ;; (global-display-line-numbers-mode t)
 (column-number-mode t)
 
@@ -95,8 +87,7 @@
 (setopt large-file-warning-threshold 50000000)
 
 ;; Numbers are arbitrary, but work on a large screen. Default is 160
-(setopt split-width-threshold 190)
+(setopt split-width-threshold 200)
-
 ;;;;;;;;;;;;;;;;;;;;;; Shell stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
 
@@ -105,18 +96,18 @@
 
 ;; Allow to execute 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
-  :defer t
-  :hook ((elpaca-after-init . exec-path-from-shell-initialize))
   :config
-  (declare-function exec-path-from-shell-initialize "exec-path-from-shell")
   (add-to-list 'exec-path "/usr/local/bin")
     (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))
 
-(use-package direnv :ensure t :defer t
+(use-package direnv :ensure t
-  :hook ((elpaca-after-init . direnv-mode)))
+  :config
+  (declare-function direnv-mode "direnv")
+  (direnv-mode t))
 
 ;; Draw underline lower
 (setopt x-underline-at-descent-line t)
@@ -128,15 +119,13 @@
         indicate-empty-lines nil)
 
 ;;;;;;;;;;;;;;;;; Treemacs
-(eval-when-compile (defvar icejam-keys-mode-map))
+(use-package treemacs :ensure t
-
-(use-package treemacs :ensure t :defer t
-  :hook ((elpaca-after-init . treemacs-follow-mode)
-         (elpaca-after-init . treemacs-project-follow-mode))
   :commands (treemacs-follow-mode treemacs-project-follow-mode treemacs)
   :bind (:map icejam-keys-mode-map
               ([(hyper b)] . treemacs))
-  :config (setopt treemacs-tag-follow-delay 1.0))
+  :config
+  (treemacs-follow-mode t)
+  (treemacs-project-follow-mode t))
 
 (use-package treemacs-all-the-icons :ensure t :defer t
   :requires (treemacs)
@@ -144,20 +133,24 @@
   :config (treemacs-load-theme "all-the-icons"))
 
 ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
-(use-package keyfreq :ensure t :defer t
+(use-package keyfreq :ensure t
-  :hook ((elpaca-after-init . keyfreq-mode)
-         (elpaca-after-init . keyfreq-autosave-mode))
   :config
-  (setopt keyfreq-file (concat user-emacs-directory "emacs.keyfreq")))
+  (declare-function keyfreq-mode "keyfreq")
+  (declare-function keyfreq-autosave-mode "keyfreq")
+  (keyfreq-mode t)
+  (keyfreq-autosave-mode t))
 
 ;;;;;;;;;;;;;;;;; Show hints about key combinations
-(use-package which-key :ensure nil :defer t
+(use-package which-key :ensure t
-  :hook ((elpaca-after-init . which-key-mode))
+  :custom (which-key-idle-delay 0.5)
-  :config
+  :config (which-key-mode t))
-  (setopt which-key-idle-delay 0.2))
 
 ;;;;;;;;;;;;;;;;; Use C-n to create a new line
 (setopt next-line-add-newlines t)
 
+;;;;;;;;;;;;;;;;; Speed up long line display by disabling bidirectional text
+(setq-default bidi-paragraph-direction 'left-to-right
+              bidi-inhibit-bpa t)
+
 (provide 'icejam-base)
 ;;; icejam-base.el ends here

lisp/icejam-blocking.el

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

lisp/icejam-company-yasnippet.el

@@ -0,0 +1,90 @@
+;;; icejam-company-yasnippet.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Company completion framework configuration
+;;; Code:
+(require 'icejam-blocking)
+
+(use-package yasnippet :ensure t
+  :config
+  (yas-global-mode t)
+  (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-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
+  (global-company-mode t)
+
+  ;; Hacks for orderless
+  (defun just-one-face (fn &rest args)
+    (let ((orderless-match-faces [completions-common-part]))
+      (apply fn args)))
+
+  (advice-add 'company-capf--candidates :around #'just-one-face)
+
+  (defun company-completion-styles (capf-fn &rest args)
+    (let ((completion-styles '(partial-completion basic)))
+      (apply capf-fn args)))
+
+  (advice-add 'company-capf :around #'company-completion-styles)
+
+  (setq-default
+   company-minimum-prefix-length 3 ;; minimum prefix character number for auto complete.
+   company-idle-delay 0.1
+   company-require-match nil
+   company-echo-delay 0 ;;;; company-show-numbers t
+   company-tooltip-align-annotations t ;; align annotations to the right tooltip border.
+   company-tooltip-flip-when-above t
+   company-tooltip-limit 10  ;; tooltip candidates max limit.
+   company-tooltip-minimum 2 ;; minimum candidates limit.
+   company-tooltip-minimum-width 10 ;; The minimum width of the tooltip's inner area.
+   ;; This doesn't include the margins and the scroll bar.
+   company-tooltip-margin 2 ;; width of margin columns to show around the tooltip
+   company-tooltip-offset-display 'lines ;; 'lines - how to show tooltip unshown candidates number.
+   company-show-numbers nil ;; t: show quick-access numbers for the first ten candidates.
+   company-selection-wrap-around t ;; loop over candidates
+   company-dabbrev-other-buffers t ;; Only offer dabbrev from the same major mode
+   company-dabbrev-downcase nil    ;; Preserve case of candidates
+   company-format-margin-function nil
+   ;; company-async-wait 0.03
+   ;; company-async-timeout 2
+   )
+
+  ;; Absolute defaults for company mode
+  (setopt company-backends
+        '((company-files                ; files & directory
+           company-keywords             ; keywords
+           company-capf
+           )
+          (company-dabbrev company-abbrev)
+          ))
+
+  ;; Use standard emacs next and previous bindings for navigating company
+  ;; suggestions
+  (define-key company-active-map (kbd "C-p") 'company-select-previous-or-abort)
+  (define-key company-active-map (kbd "C-n") 'company-select-next-or-abort)
+
+  (defun icejam-insert-space-and-complete ()
+    "Insert space before trying to complete a section."
+    (interactive)
+    (save-excursion
+      (insert " "))
+    (company-indent-or-complete-common))
+
+  ;; Only use RETURN for completion in company
+  (unbind-key "TAB" company-active-map)
+
+;;; Yasnippet configuration
+  (define-key prog-mode-map (kbd "C-c y") 'company-yasnippet)
+  (define-key prog-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
+  (define-key prog-mode-map (kbd "TAB") 'company-indent-or-complete-common)
+
+  (define-key text-mode-map (kbd "C-c y") 'company-yasnippet)
+  (define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
+  (define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common))
+
+(provide 'icejam-company-yasnippet)
+;;; icejam-company-yasnippet.el ends here

lisp/icejam-complete-at-point.el

@@ -1,95 +0,0 @@
-;;; icejam-complete-at-point.el -- summary -*- lexical-binding: t; -*-
-;;; Commentary:
-;;; Completion framework configuration
-;;; Code:
-(use-package yasnippet :ensure t :defer t
-  :hook ((elpaca-after-init . yas-global-mode))
-  :config
-  (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-v" yas-minor-mode-map))
-
-(use-package yasnippet-snippets :ensure t :after (yasnippet))
-
-;; Corfu is the main engine for displaying suggestions.
-(use-package corfu :ensure t :defer t
-  :hook ((elpaca-after-init . global-corfu-mode)
-         (global-corfu-mode . corfu-popupinfo-mode))
-  :config
-  ;; Go up to go the the last item on the list
-  (setopt corfu-cycle t
-          corfu-count 20 ;; Show 20 completion candidates
-
-          corfu-max-width 100 ;; Max width of the corfu frame
-          corfu-right-margin-width 0.5
-          corfu-left-margin-width 0.5
-          corfu-bar-width 0.5
-          ;; Do not insert when you type a word that happens to be a
-          ;; completion candidate. A typical example is `format`, which
-          ;; is a yas snippet.
-          corfu-on-exact-match 'quit
-          corfu-quit-at-boundary t
-          corfu-popupinfo-delay '(0.4 . 0.2)
-          corfu-auto t
-          corfu-auto-delay 0.2
-          corfu-quit-no-match 'separator
-
-          ;; Invoke completion with tab when needed.
-          tab-always-indent 'complete))
-
-;; Allow corfu to work in terminal
-(use-package corfu-terminal :ensure t :defer t
-  :if (not (display-graphic-p))
-  :hook ((elpaca-after-init . corfu-terminal-mode)))
-
-;; These are actual completions
-(use-package cape :ensure t :after corfu
-  :config
-  (declare-function cape-dabbrev 'cape)
-  (declare-function cape-file 'cape)
-  (declare-function cape-keyword 'cape)
-  (declare-function cape-elisp-symbol 'cape)
-  (declare-function cape-capf-super 'cape)
-
-  ;; Set default completion values:
-  (set-default 'completion-at-point-functions
-               (list (cape-capf-super #'cape-dabbrev #'yasnippet-capf)
-                     #'cape-file
-                     #'cape-keyword)))
-
-(defun icejam-set-no-eglot-capfs ()
-  "Set `completion-at-point-function` to non-LSP list."
-  (setq-local completion-at-point-functions
-              (list (cape-capf-super #'cape-dabbrev #'yasnippet-capf)
-                    #'cape-file
-                    #'cape-keyword)))
-
-(defun icejam-set-eglot-capfs ()
-  "Set `completion-at-point-function` to list where LSP is supported."
-  (setq-local completion-at-point-functions
-              (list (cape-capf-super #'yasnippet-capf #'eglot-completion-at-point)
-                    #'cape-dabbrev
-                    #'cape-file)))
-
-(defun icejam-set-elisp-capfs ()
-  "Set `completion-at-point-function` to what is useful in Elisp."
-  (setq-local completion-at-point-functions
-              (list (cape-capf-super #'elisp-completion-at-point
-                                     #'yasnippet-capf)
-                    #'cape-dabbrev
-                    #'cape-file
-                    #'cape-elisp-symbol)))
-
-(use-package yasnippet-capf :ensure t :after corfu :defer t
-  :config
-  (declare-function yasnippet-capf 'yasnippet)
-  (setopt yasnippet-capf-lookup-by 'name))
-
-(use-package nerd-icons-corfu :ensure t :defer 5
-  :after corfu
-  :config
-  (declare-function nerd-icons-corfu-formatter 'nerd-icons-corfu)
-  (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
-
-(provide 'icejam-complete-at-point)
-;;; icejam-complete-at-point.el ends here

lisp/icejam-completing-read.el

@@ -2,11 +2,11 @@
 ;;; Commentary:
 ;;;
 ;;; completing-read is the way of completing things in minibuffer.  This module
-;;; provides all of that functionality, everything related to minbuffer being
+;;; provides all of that functionality, everything related to minbuffer being helpful.
-;;; helpful.
 ;;;
 ;;; Code:
-(eval-when-compile (defvar icejam-keys-mode-map))
+
+(require 'icejam-keys-mode)
 
 ;; Preparations for using Vertico/Orderless
 (setopt
@@ -31,48 +31,30 @@
 (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
 
 ;; Actual orderless
-(use-package vertico :ensure t :defer t
+(use-package vertico :ensure t
-  :hook ((elpaca-after-init . vertico-mode))
+  :custom ((vertico-scroll-margin 1 "Scroll on N-1")
+           (vertico-count 15 "Show 5 more candidates")
+           (vertico-resize t "Grow and shrink the vertico minibufffer")
+           (vertico-cycle t "Cycle completion"))
   :config
-  (setopt vertico-scroll-margin 1) ;; Scroll on N-1
+  (vertico-mode t))
-  (setopt vertico-count 15)        ;; Show 5 more candidates
-  (setopt vertico-resize t) ;; Grow and shrink the vertico minibufffer
-  (setopt vertico-cycle t)  ;; Cycle completion
-
-  ;; Use H-enter to submit current value instead of first matching candidate
-  (keymap-set vertico-map "H-<return>" 'vertico-exit-input)
-
-  ;; Add working page up /down
-  (keymap-set vertico-map "<next>" 'vertico-scroll-up)
-  (keymap-set vertico-map "<prior>" 'vertico-scroll-down))
 
 (use-package orderless :ensure t
-  :config
+  :custom ((completion-styles '(orderless partial-completion basic)
-  ;; Fallback to basic if orderless does not work.
+                              "Fallback to basic if orderless does not work.")
-  (setopt completion-styles '(orderless basic))
+           (completion-category-defaults nil)
-  (setopt completion-category-defaults nil)
+           (completion-category-overrides
-  (setopt completion-category-overrides '((file (styles partial-completion)))))
+            '((file (styles partial-completion))))))
 
-(use-package marginalia :ensure t :defer t
-  :hook ((elpaca-after-init . marginalia-mode)))
 
+(use-package marginalia :ensure t
+  :config (marginalia-mode t))
 (use-package consult :ensure t
-  :config
-  ;; Using ripgrep, show hidden files but ignore contents of .git
-  (setopt consult-ripgrep-args
-          "rg --null --line-buffered --color=never --max-columns=1000 \
---path-separator / --smart-case --no-heading --with-filename --line-number \
---search-zip --hidden --glob \"!.git/*\"")
   :bind (:map icejam-keys-mode-map
               ("C-c t" . find-file)
-              ("M-g g" . consult-goto-line)
+              ("M-g"   . consult-goto-line)
               ("C-c a" . consult-ripgrep)))
-
+(use-package helpful :ensure t)
-(use-package helpful :ensure t :defer t
-  :bind (([remap describe-key] . helpful-key)
-         ([remap describe-variable] . helpful-variable)
-         ([remap describe-function] . helpful-callable)
-         ([remap describe-command] . helpful-command)))
 
 (provide 'icejam-completing-read)
 ;;; icejam-completing-read.el ends here

lisp/icejam-copilot.el

@@ -0,0 +1,45 @@
+;;; icejam-copilot.el --- summary
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Copilot and other GPT stuff
+
+;;; Code:
+(use-package copilot :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
+  :defer t
+  ;; It sort of sucks so let's disable it.
+  ;; :hook ((prog-mode . copilot-mode))
+  :bind (:map copilot-completion-map
+              ([tab] . copilot-accept-completion))
+  :config
+  (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode . 2)))
+
+;; Enable Anthropic Claude LLM support for chat (it also sucks)
+(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
+  :type 'string
+  :group 'icejam
+  :initialize 'custom-initialize-set)
+
+(use-package gptel :ensure t :defer t
+  :config
+  (setq
+   gptel-model 'claude-3-5-sonnet-20241022
+   gptel-backend (gptel-make-anthropic "Claude"
+                   :stream t :key (lambda () anthropic-api-key))))
+
+;; Pretend to be 'AI editor'.
+(use-package elysium :ensure t :defer t
+  :custom
+  ((elysium-window-size 0.33 "The elysium buffer will be 1/3 your screen")
+   (elysium-window-style 'vertical "Elysium buffer will be vertical")))
+
+;; Merging with SMerge
+(use-package smerge-mode :ensure nil
+  :hook ((prog-mode . smerge-mode)))
+
+(provide 'icejam-copilot)
+;;; icejam-copilot.el ends here

lisp/icejam-custom-init.el

@@ -12,23 +12,18 @@
 
 ;; Set GC at 500 MB for startup
 (setopt gc-cons-threshold 500000000)
-(setopt gc-cons-percentage 5.0)
+(setopt gc-cons-percentage 0.6)
-
-(add-hook 'after-init-hook (lambda ()
-                             ;; Restore GC to normal, but still high
-                             (setopt gc-cons-threshold 204800000)
-                             (setopt gc-cons-percentage 0.2)))
 
 ;; Allow for deeper stacktraces / recursion
 ;; (setopt max-lisp-eval-depth 10000)
 
 ;;; Use elpaca for package management.
-(defvar elpaca-installer-version 0.11)
+(defvar elpaca-installer-version 0.7)
 (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
 (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
 (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
 (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
-                              :ref nil :depth 1 :inherit ignore
+                              :ref nil :depth 1
                               :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                               :build (:not elpaca--activate-package)))
 (let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
@@ -65,85 +60,83 @@
 ;; Use package settings
 (setopt use-package-verbose t)
 (setopt use-package-compute-statistics t)
+(elpaca elpaca-use-package
+  ;; Enable use-package :ensure support for Elpaca.
+  (elpaca-use-package-mode))
 
-;; Enable use-package :ensure support for Elpaca.
+(elpaca-load-lockfile (concat user-emacs-directory "elpaca.lock"))
-(defvar elpaca-use-package)
-(elpaca elpaca-use-package (elpaca-use-package-mode))
-
-;; (elpaca-load-lockfile (concat user-emacs-directory "elpaca.lock"))
-;; (setopt elpaca-lock-file (concat user-emacs-directory "elpaca.lock"))
-
-(use-package benchmark-init :ensure (:wait t)
-  :config
-  (add-hook 'after-init-hook 'benchmark-init/deactivate))
 
 (defun icejam-elpaca-write-lock ()
   "Write elpaca lock file."
   (interactive)
-  (elpaca-write-lock-file (concat user-emacs-directory "elpaca.lock")))
+  (elpaca-write-lockfile (concat user-emacs-directory "elpaca.lock")))
 
 ;; I don't know why this needs to be here and with a lisp directory, but
 ;; normal subdirs.el file doesn't work.
-(add-to-list 'load-path (concat user-emacs-directory "lisp"))
 (add-to-list 'load-path (concat user-emacs-directory "lisp/themes"))
 (add-to-list 'load-path (concat user-emacs-directory "lisp/langs"))
 
 (defgroup :icejam nil "My customisation group.")
 
 ;; General configuration files.
-(use-package icejam-keys-mode :ensure nil)
+(require 'icejam-keys-mode)
-(use-package icejam-base :ensure nil)
+(require 'icejam-blocking)
-(use-package icejam-sys-specific :ensure nil)
+(require 'icejam-base)
-(use-package icejam-tree-sitter :ensure nil)
+(require 'icejam-sys-specific)
-(use-package icejam-completing-read :ensure nil)
+(require 'icejam-tree-sitter)
-(use-package icejam-avy :ensure nil)
+(require 'icejam-completing-read)
-(use-package icejam-transient :ensure nil)
+(require 'icejam-avy)
-(use-package icejam-prog-mode :ensure nil)
+(require 'icejam-transient)
-(use-package icejam-complete-at-point :ensure nil)
+(require 'icejam-prog-mode)
-(use-package icejam-aider :ensure nil)
+(require 'icejam-company-yasnippet)
-(use-package icejam-flycheck :ensure nil)
+(require 'icejam-copilot)
-(use-package icejam-ispell :ensure nil)
+(require 'icejam-flycheck)
-(use-package icejam-deft :ensure nil)
+(require 'icejam-ispell)
-(use-package icejam-eglot :ensure nil)
+(require 'icejam-deft)
-(use-package icejam-dashboard :ensure nil)
+(require 'icejam-lsp)
-(use-package icejam-magit :ensure nil)
+(require 'icejam-dashboard)
-(use-package icejam-vundo :ensure nil)
+(require 'icejam-magit)
-(use-package icejam-speed-type :ensure nil)
+(require 'icejam-vundo)
+(require 'icejam-speed-type)
 
 ;; Themes
-(use-package icejam-themes :ensure nil)
+(require 'icejam-themes)
-(use-package icejam-fonts :ensure nil)
+(require 'icejam-fonts)
 
 ;; Actual supported languages and file syntax.
-(use-package icejam-lang-clang :ensure nil)
+(require 'icejam-lang-clang)
-(use-package icejam-lang-clojure :ensure nil)
+(require 'icejam-lang-clojure)
-(use-package icejam-lang-dart :ensure nil)
+;; (require 'icejam-lang-common-lisp)
-(use-package icejam-lang-dhall :ensure nil)
+(require 'icejam-lang-dart)
-(use-package icejam-lang-elisp :ensure nil)
+(require 'icejam-lang-dhall)
-(use-package icejam-lang-elixir :ensure nil)
+(require 'icejam-lang-elisp)
-(use-package icejam-lang-erlang :ensure nil)
+(require 'icejam-lang-elixir)
-(use-package icejam-lang-fsharp :ensure nil)
+(require 'icejam-lang-erlang)
-(use-package icejam-lang-gleam :ensure nil)
+(require 'icejam-lang-fsharp)
-(use-package icejam-lang-golang :ensure nil)
+(require 'icejam-lang-gleam)
-(use-package icejam-lang-haskell :ensure nil)
+(require 'icejam-lang-golang)
-(use-package icejam-lang-javascript :ensure nil)
+(require 'icejam-lang-haskell)
-(use-package icejam-lang-kotlin :ensure nil)
+(require 'icejam-lang-javascript)
-;; (use-package icejam-lang-lean :ensure nil)
+(require 'icejam-lang-kotlin)
-(use-package icejam-lang-lua :ensure nil)
+(require 'icejam-lang-lean)
-(use-package icejam-lang-markdown :ensure nil)
+(require 'icejam-lang-markdown)
-(use-package icejam-lang-ocaml :ensure nil)
+(require 'icejam-lang-ocaml)
-(use-package icejam-lang-other :ensure nil)
+(require 'icejam-lang-other)
-(use-package icejam-lang-php :ensure nil)
+(require 'icejam-lang-php)
-(use-package icejam-lang-purescript :ensure nil)
+(require 'icejam-lang-purescript)
-(use-package icejam-lang-python :ensure nil)
+(require 'icejam-lang-python)
-(use-package icejam-lang-ruby :ensure nil)
+(require 'icejam-lang-ruby)
-(use-package icejam-lang-rust :ensure nil)
+(require 'icejam-lang-rust)
-(use-package icejam-lang-sh :ensure nil)
+(require 'icejam-lang-sh)
-(use-package icejam-lang-web :ensure nil)
+(require 'icejam-lang-web)
-(use-package icejam-lang-ziglang :ensure nil)
+(require 'icejam-lang-ziglang)
 
 ;; Diminish modeline litter
-(use-package icejam-diminish :ensure nil)
+(require 'icejam-diminish)
+
+;; Restore GC to normal, but still high
+(setopt gc-cons-threshold 200000000)
+(setopt gc-cons-percentage 0.2)
 
 (provide 'icejam-custom-init)
 ;;; icejam-custom-init.el ends here

lisp/icejam-dashboard.el

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

lisp/icejam-deft.el

@@ -3,12 +3,15 @@
 ;;; Notational velocity, backed by OneDrive.
 ;;; Code:
 
-(use-package deft :ensure t :defer t
+(require 'icejam-keys-mode)
-  :config
+(require 'icejam-transient)
-  (setopt deft-directory (substitute-in-file-name "$DEFT_PATH")
+
-          deft-default-extension "md"
+(use-package deft :ensure t
-          deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$"
+  :custom
-          deft-strip-summary-regexp (concat "\\("
+  ((deft-directory (substitute-in-file-name "$DEFT_PATH"))
+   (deft-default-extension "md")
+   (deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$")
+   (deft-strip-summary-regexp (concat "\\("
                                       "[\n\t]" ;; blank
                                       "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
                                       "\\|^Title:.*$" ;; Title string
@@ -16,8 +19,8 @@
                                       "\\|^\\[\\[file:.*$" ;; org-mode inline-images
                                       ;; org-mode properties
                                       ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
-                                          "\\)")
+                                      "\\)"))
-          deft-auto-save-interval 30.0))
+   (deft-auto-save-interval 30.0)))
 
 (provide 'icejam-deft)
 ;;; icejam-deft.el ends here

lisp/icejam-diminish.el

@@ -6,30 +6,27 @@
 
 ;;; Commentary:
 
-;; diminish minor modes to remove modeline litter.
+;; diminish minor modes
 
 ;;; Code:
-(use-package diminish :ensure t :defer t :commands (diminish))
+(require 'icejam-blocking)
+;; (use-package diminish :ensure t)
 
-(defun icejam-diminish-modes ()
+(with-eval-after-load 'diminish
-  "Diminish selected modes."
+  (with-eval-after-load 'flyspell (diminish 'flyspell-mode))
-  (dolist (package-and-mode '((flyspell flyspell-mode)
+  (with-eval-after-load 'flycheck (diminish 'flycheck-mode))
-                              (flycheck flycheck-mode)
+  (with-eval-after-load 'rainbow-mode (diminish 'rainbow-mode))
-                              (rainbow-mode rainbow-mode)
+  (with-eval-after-load 'undo-tree (diminish 'undo-tree-mode))
-                              (undo-tree undo-tree-mode)
+  (with-eval-after-load 'company (diminish 'company-mode))
-                              (which-key which-key-mode)
+  (with-eval-after-load 'which-key (diminish 'which-key-mode))
-                              (eldoc eldoc-mode)
+  (with-eval-after-load 'eldoc (diminish 'eldoc-mode))
-                              (yasnippet yas-minor-mode)
+  (with-eval-after-load 'yasnippet (diminish 'yas-minor-mode))
-                              (whitespace whitespace-mode)
+  (with-eval-after-load 'whitespace (diminish 'whitespace-mode))
-                              (autorevert auto-revert-mode)
+  (with-eval-after-load 'autorevert (diminish 'auto-revert-mode))
-                              (ivy ivy-mode)
+  (with-eval-after-load 'ivy (diminish 'ivy-mode))
-                              (smerge-mode smerge-mode)
+  (with-eval-after-load 'company-box (diminish 'company-box-mode))
-                              (gcmh gcmh-mode)))
+  (with-eval-after-load 'smerge-mode (diminish 'smerge-mode))
-    (let ((package (car package-and-mode))
+  (with-eval-after-load 'gcmh (diminish 'gcmh-mode)))
-          (mode (car (last package-and-mode))))
-      (with-eval-after-load package (diminish mode)))))
-
-(add-hook 'elpaca-after-init-hook 'icejam-diminish-modes)
 
 (provide 'icejam-diminish)
 ;;; icejam-diminish.el ends here

lisp/icejam-eglot.el

@@ -1,16 +0,0 @@
-;;; icejam-eglot -- summary -*- lexical-binding: t; -*-
-;;; Commentary:
-;;; Global Language Server Protocol Config
-;;; Code:
-
-(use-package eldoc-box :ensure t
-  :hook ((emacs-lisp-mode . eldoc-box-hover-at-point-mode)
-         (eglot--managed-mode . eldoc-box-hover-at-point-mode))
-  :custom-face
-  (eldoc-box-markdown-separator ((t (:inherit (fringe))))))
-
-;; Add debugger support to emacs.
-(use-package dape :ensure t)
-
-(provide 'icejam-eglot)
-;;; icejam-eglot.el ends here

lisp/icejam-flycheck.el

@@ -2,67 +2,28 @@
 ;;; Commentary:
 ;;; Code:
 
-;; Use flycheck checks with flymake.
+;; Use flycheck globally to check syntax and compile languages
-(use-package flymake-flycheck :ensure t :defer t :config
+(use-package flycheck :ensure t
-(setq-default
+  :custom ((flycheck-emacs-lisp-load-path 'inherit))
-     flycheck-disabled-checkers
-     (append (default-value 'flycheck-disabled-checkers)
-             '(emacs-lisp emacs-lisp-checkdoc
-                          emacs-lisp-package sh-shellcheck))))
-
-(declare-function flymake--project-diagnostics-buffer 'flymake)
-(declare-function flymake--diagnostics-buffer-name 'flymake)
-(declare-function flymake-project-diagnostics-mode 'flymake)
-(declare-function flymake-diagnostics-buffer-mode 'flymake)
-
-(use-package el-patch :ensure t :defer t
   :config
-  ;; Show the diagnostics from flymake in a second window (usually on the
+  (global-flycheck-mode t)
-  ;; opposite side from this one) instead of at the bottom of the current one.
+  (setopt flycheck-emacs-lisp-load-path 'inherit)
-  ;; Essentially revert the interesting part of this commit:
+  (unbind-key "C-c ! C-c" flycheck-mode-map)
-  ;; https://github.com/emacs-mirror/emacs/commit/419550c7907275bf962986e1cc8fba1989d8659c
+  (unbind-key "C-c ! C-w" flycheck-mode-map)
-  (el-patch-feature 'flymake)
+  (unbind-key "C-c ! ?" flycheck-mode-map)
-  (with-eval-after-load 'flymake
+  (unbind-key "C-c ! C" flycheck-mode-map)
-    (el-patch-defun flymake-show-project-diagnostics ()
+  (unbind-key "C-c ! H" flycheck-mode-map)
-      "Show a list of Flymake diagnostics for the current project."
+  (unbind-key "C-c ! V" flycheck-mode-map)
-      (interactive)
+  (unbind-key "C-c ! c" flycheck-mode-map)
-      (let* ((prj (project-current))
+  (unbind-key "C-c ! e" flycheck-mode-map)
-             (root (project-root prj))
+  (unbind-key "C-c ! h" flycheck-mode-map)
-             (buffer (flymake--project-diagnostics-buffer root)))
+  (unbind-key "C-c ! i" flycheck-mode-map)
-        (with-current-buffer buffer
+  (unbind-key "C-c ! l" flycheck-mode-map)
-          (flymake-project-diagnostics-mode)
+  (unbind-key "C-c ! n" flycheck-mode-map)
-          (setq-local flymake--project-diagnostic-list-project prj)
+  (unbind-key "C-c ! p" flycheck-mode-map)
-          (display-buffer (current-buffer))
+  (unbind-key "C-c ! s" flycheck-mode-map)
-          (revert-buffer))))
+  (unbind-key "C-c ! v" flycheck-mode-map)
-
+  (unbind-key "C-c ! x" flycheck-mode-map))
-    (el-patch-defun flymake-show-buffer-diagnostics ()
-      "Show a list of Flymake diagnostics for current buffer."
-      (interactive)
-      (unless flymake-mode
-        (user-error "Flymake mode is not enabled in the current buffer"))
-      (let* ((name (flymake--diagnostics-buffer-name))
-             (source (current-buffer))
-             (target (or (get-buffer name)
-                         (with-current-buffer (get-buffer-create name)
-                           (flymake-diagnostics-buffer-mode)
-                           (current-buffer)))))
-        (with-current-buffer target
-          (setq flymake--diagnostics-buffer-source source)
-          (display-buffer (current-buffer))
-          (revert-buffer))))))
-
-;; Use flymake, the built in linter/checker.
-(use-package flymake :ensure nil
-  :defer t
-  :config
-  ;; Show 'Fly' in mode line.
-  (setopt flymake-mode-line-lighter "Fly")
-  ;; Use the same load-path as normal configuration. This makes the errors that
-  ;; appear in elisp files less jarring.
-  (setopt elisp-flymake-byte-compile-load-path load-path)
-  :hook ((prog-mode . flymake-mode)
-         (text-mode . flymake-mode)
-         (flymake-mode . flymake-flycheck-auto)))
 
 (provide 'icejam-flycheck)
 ;;; icejam-flycheck.el ends here

lisp/icejam-fonts.el

@@ -3,11 +3,13 @@
 ;; Author: Maciej Szlosarczyk
 ;; Maintainer: Maciej Szlosarczyk
 ;; Version: 0.1-snapshot
+
 ;;; Commentary:
 
 ;; Set font stuff
 
 ;;; Code:
+
 ;; (defconst icejam-font "Monoid"
 ;; (defconst icejam-font "Fira Mono"
 ;; (defconst icejam-font "Fira Code"
@@ -16,47 +18,29 @@
 ;; (defconst icejam-font "Input Mono Condensed"
 ;; (defconst icejam-font "SF Mono"
 ;; (defconst icejam-font "Monaco"
-;; (defconst icejam-font "JetBrains Mono" "Default font.")
+;; (defconst icejam-font "JetBrains Mono"
 ;; (defconst icejam-font "JuliaMono"
 ;; (defconst icejam-font "Rec Mono Semicasual"
+;; (defconst icejam-font "Victor Mono"
 ;; (defconst icejam-font "IBM Plex Mono"
 ;; (defconst icejam-font "Berkeley Mono Trial"
 ;; (defconst icejam-font "Inconsolata"
-;; (defconst icejam-font "Victor Mono Medium" "Default font.")
-;; (defconst icejam-font "Iosevka Term" "Default font.")
 
-(defconst icejam-default-font-family "Iosevka Term" "Default font.")
+(defconst icejam-font "Iosevka Term"
-(defconst icejam-variable-font-family "Lexica Ultralegible" "Variable pitch font.")
+  "Default font.")
-(defconst icejam-markdown-font-family "Iosevka Comfy Motion"
+(defconst icejam-font-size 14
-  "Font used to render code blocks in markdown.
+  "Default size of then font.
-It is different than default font to keep it visually distinct.")
+It is used to calculated the size in relation to the screen
+in icejam-set-font-to-screen.")
 
-;; Require dash functions to be included:
+(defcustom icejam-mut-font
-(declare-function -> "dash.el")
+  icejam-font
-
-(defconst icejam-font-height 14
-  "Default height of then font.
-It is used to calculated the height in relation to the screen
-in `icejam-set-font-to-screen`.")
-
-(defcustom icejam-mut-default-font-family
-  icejam-default-font-family
   "Current font, defaults to the one loaded in the beginning."
   :type 'string
   :group 'icejam)
-(defcustom icejam-mut-variable-font-family
+(defcustom icejam-mut-font-size
-  icejam-default-font-family
+  icejam-font-size
-  "Current variable-pitch font.  Defaults to `icejam-variable-font-family`."
+  "Current font size."
-  :type 'string
-  :group 'icejam)
-(defcustom icejam-mut-markdown-font-family
-  icejam-markdown-font-family
-  "Current markdown font family, defaults to the one loaded in the beginning."
-  :type 'string
-  :group 'icejam)
-(defcustom icejam-mut-font-height
-  icejam-font-height
-  "Current font height."
   :type 'integer
   :group 'icejam)
 
@@ -65,89 +49,94 @@ in `icejam-set-font-to-screen`.")
 (defvar lsp-ui-doc-frame-hook)
 
 (defun icejam-set-lsp-ui-font-hook ()
-  "Reset LSP IO font to specified `icejam-font` and `icejam-font-height`."
+  "Reset LSP IO font to specified icejam-font and icejam-font-size."
   (setopt lsp-ui-doc-frame-hook nil)
   (add-hook 'lsp-ui-doc-frame-hook
             (lambda (frame _w)
-              (set-face-attribute 'default frame
+              (set-face-attribute
-                                  :family icejam-mut-default-font-family
+               'default frame :font
-                                  :height (-> icejam-mut-font-height
+               (format "%s %d" icejam-mut-font (- icejam-mut-font-size 2))))))
-                                              (- 2)
-                                              (* 10))))))
 
-(defun icejam-set-font (family height)
+(defun icejam-set-font (name size)
-  "Set font to FAMILY and its HEIGHT to X.
+  "Set font to NAME and its SIZE to X pixels."
+  (interactive "sNew font: \nnEnter size for %s: ")
+  (setopt icejam-mut-font name)
+  (setopt icejam-mut-font-size size)
 
-Not all faces will be set to this value.  Some of them look better with being
+  (set-face-attribute 'default nil :font (format "%s %d" name size))
-slightly smaller than the default face, by 1 point.  Those are: `tooltip'.
 
-Modeline faces (`mode-line' and `mode-line-inactive') look better if they are
+  ;; Set completion and modeline font to be 1 pixel point smaller than
-two points smaller."
+  ;; the general font
-  (interactive "sNew font: \nnEnter height for %s: ")
+  ;; (set-face-attribute
-  (setopt icejam-mut-default-font-family family)
+  ;;  'markdown-code-face nil :font (format "%s %d" name (- size 1)))
-  (setopt icejam-mut-font-height height)
+  (set-face-attribute
-  (setopt icejam-mut-variable-font-family icejam-variable-font-family)
+   'tooltip nil :font (format "%s %d" name (- size 1)))
-
+  (set-face-attribute
-  ;; Set default font.
+   'company-tooltip nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute 'default nil
+  (set-face-attribute
-                      :family family
+   'company-tooltip-annotation nil :font (format "%s %d" name (- size 1)))
-                      :height (-> height
+  (set-face-attribute
-                                  (* 10)))
+   'company-tooltip-mouse nil :font (format "%s %d" name (- size 1)))
-
+  (set-face-attribute
-  ;; Set variable-pitch font
+   'mode-line nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute 'variable-pitch nil
+  (set-face-attribute
-                      :family icejam-mut-variable-font-family
+   'mode-line-inactive nil :font (format "%s %d" name (- size 1)))
-                      :height (-> height
-                                  (* 10)))
-
-  ;; Some font faces look better when they are 1 point smaller.
-  (dolist (face '(tooltip))
-    (set-face-attribute face nil :height (-> height
-                                             (- 1)
-                                             (* 10))))
-
-  ;; And some, mainly in modeline with 2 points.
-  (dolist (face '(mode-line
-                  mode-line-inactive))
-    (set-face-attribute face nil :height (-> height
-                                             (- 2)
-                                             (* 10))))
 
   ;; Call LSP-UI hook
   (icejam-set-lsp-ui-font-hook))
 
 (defun icejam-set-font-to-screen ()
-  "Automatically set font height to suit the monitor."
+  "Automatically set font size to suit the monitor."
+  ;; If display is set to emulate FullHD resultion or less, make the font
+  ;; smaller.
   (interactive)
+  (cond ((eq (x-display-list) nil))
+        ;; built-in screen
+        ((>= 1050 (x-display-pixel-height))
+         (icejam-set-font icejam-font icejam-font-size))
 
-  ;; Only do anything if there's a display at all.
+        ;; 4K screen on a Mac
-  (if (x-display-list)
+        ((>= 1080 (x-display-pixel-height))
-      (let ((pixel-height (x-display-pixel-height)))
+         (icejam-set-font icejam-font icejam-font-size))
-        (cond
-         ;; MacBook 14" built-in screen.
-         ((>= 1080 pixel-height)
-          (icejam-set-font icejam-default-font-family icejam-font-height))
 
-         ;; 27" screen connected to a MacBook.
+        ;; Other screens
-         ((>= 1440 pixel-height)
+        ((>= 1120 (x-display-pixel-height))
-          (icejam-set-font icejam-default-font-family (+ icejam-font-height 3)))
+         (icejam-set-font icejam-font icejam-font-size))
+
+        ((>= 1440 (x-display-pixel-height))
+         (icejam-set-font icejam-font (+ icejam-font-size 3)))
+
+        ((>= 1920 (x-display-pixel-height))
+         (icejam-set-font icejam-font icejam-font-size))
 
         ;; 4K screen on Windows or Linux
-         ((>= 2160 pixel-height)
+        ((>= 2160 (x-display-pixel-height))
-          (icejam-set-font icejam-default-font-family (- icejam-font-height 3)))))))
+         (icejam-set-font icejam-font (- icejam-font-size 3)))
 
-;; Run the above function once, after elpaca finishes all downloads.
+        ;; Default
-(add-hook 'elpaca-after-init-hook 'icejam-set-font-to-screen)
+        (t (icejam-set-font icejam-font (- icejam-font-size 3)))))
 
-(defun icejam-set-font-height (height)
+;; Do it automatically on startup
-  "Set font to a specified HEIGHT."
+(icejam-set-font-to-screen)
-  (interactive "nEnter height for font: ")
-  (icejam-set-font icejam-mut-default-font-family height))
 
-(defun icejam-set-font-height-for-this-frame (new-height)
+(defun icejam-set-font-size (size)
-  "Set font NEW-HEIGHT for this frame only."
+  "Set font to a specified SIZE."
-  (interactive "nEnter new height for font in this frame: ")
+  (interactive "nEnter size for font: ")
-  (set-frame-font (format "%s %d" icejam-mut-default-font-family new-height)))
+  (icejam-set-font icejam-mut-font size))
+
+(defun icejam-set-font-size-for-this-frame (new-size)
+  "Set font NEW-SIZE for this frame only."
+  (interactive "nEnter new size for font in this frame: ")
+  (set-frame-font (format "%s %d" icejam-mut-font new-size)))
+
+;; Remove ugly black line
+(set-face-attribute 'vertical-border nil :foreground
+                    (face-attribute 'fringe :background))
+
+;; Set fringe colors to default, so it does not bother you.
+(set-face-attribute 'fringe nil
+                    :foreground (face-foreground 'default)
+                    :background (face-background 'default))
 
 (provide 'icejam-fonts)
 ;;; icejam-fonts.el ends here

lisp/icejam-ispell.el

@@ -3,10 +3,12 @@
 ;;; Highlight misspelled words
 ;;; Code:
 
-(use-package ispell :ensure nil :defer t
+
-  :config
+
-  (setopt ispell-program-name "aspell")
+(use-package ispell :ensure nil
-  (setopt ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")))
+  :custom
+  ((ispell-program-name "aspell")
+   (ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2"))))
 
 (use-package flyspell :ensure nil
   :hook ((prog-mode . flyspell-mode)

lisp/icejam-keys-mode.el

@@ -19,47 +19,43 @@
 ;; Globally enable my minor mode
 (icejam-keys-mode)
 
+;;; Helpful key bindings
+(define-key icejam-keys-mode-map (kbd "C-c \\") 'split-window-right) ;; Split window to the right
+(define-key icejam-keys-mode-map (kbd "C-c /") 'split-window-below) ;; Split window to the bottom
+
+;; Move between windows key bindings
+(define-key icejam-keys-mode-map (kbd "C-c <left>") 'windmove-left)
+(define-key icejam-keys-mode-map (kbd "C-c <right>") 'windmove-right)
+(define-key icejam-keys-mode-map (kbd "C-c <up>") 'windmove-up)
+(define-key icejam-keys-mode-map (kbd "C-c <down>") 'windmove-down)
+
+;; The same, but without using arrow keys
+(define-key icejam-keys-mode-map (kbd "C-c [") 'windmove-left)
+(define-key icejam-keys-mode-map (kbd "C-c ]") 'windmove-right)
+(define-key icejam-keys-mode-map (kbd "C-c {") 'windmove-up)
+(define-key icejam-keys-mode-map (kbd "C-c }") 'windmove-down)
+
+;; Kill current buffer and window
+(define-key icejam-keys-mode-map (kbd "C-c q") 'kill-buffer-and-window)
+
+;; List buffers
+(define-key icejam-keys-mode-map (kbd "C-c b") 'ibuffer)
+
+;; Revert without asking
 (defun icejam-revert-buffer-no-confirm ()
   "Revert buffer without confirmation."
   (interactive) (revert-buffer t t))
 
-;; Splitting window
+(define-key icejam-keys-mode-map (kbd "C-c r") 'icejam-revert-buffer-no-confirm)
-(keymap-set icejam-keys-mode-map "C-c \\" #'split-window-right)
-(keymap-set icejam-keys-mode-map "C-c /" #'split-window-below)
-(keymap-set icejam-keys-mode-map "C-c \"" #'split-window-right)
-(keymap-set icejam-keys-mode-map "C-c %" #'split-window-below)
-(keymap-set icejam-keys-mode-map "C-c '" #'split-window-right)
-(keymap-set icejam-keys-mode-map "C-c 5" #'split-window-below)
 
-;; Move between windows
+;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
-(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
+(define-key icejam-keys-mode-map [home] 'beginning-of-line)
-(keymap-set icejam-keys-mode-map "C-c <right>" #'windmove-right)
+(define-key icejam-keys-mode-map [end] 'end-of-line)
-(keymap-set icejam-keys-mode-map "C-c <up>" #'windmove-up)
-(keymap-set icejam-keys-mode-map "C-c <down>" #'windmove-down)
-
-;; History of buffers
-(keymap-set icejam-keys-mode-map "C-c s [" #'previous-buffer)
-(keymap-set icejam-keys-mode-map "C-c s ]" #'next-buffer)
-
-;; These are slightly more conveniently located on an Ergodox/Moonlander
-(keymap-set icejam-keys-mode-map "C-c s <left>" #'previous-buffer)
-(keymap-set icejam-keys-mode-map "C-c s <right>" #'next-buffer)
-
-;; List of buffers buffer
-(keymap-set icejam-keys-mode-map "C-c b" #'ibuffer)
-
-;; Manipulate buffers (kill or revert)
-(keymap-set icejam-keys-mode-map "C-c q" #'kill-buffer-and-window)
-(keymap-set icejam-keys-mode-map "C-c r" #'icejam-revert-buffer-no-confirm)
-
-;; Make emacs behave like a normal editor from 21st century.
-(keymap-set icejam-keys-mode-map "<home>" #'beginning-of-line)
-(keymap-set icejam-keys-mode-map "<end>" #'end-of-line)
 
 ;;;;;;;;; Translate keys ;;;;;;;;;;;;;;;;;;;;;
-(keymap-set key-translation-map "<f6>" "C-c l") ;; On F6, send C-c l
+(define-key key-translation-map (kbd "<f6>") (kbd "C-c l")) ;; On F6, send C-c l
-(keymap-set key-translation-map "<f7>" "C-c c") ;; On F7, send C-c c
+(define-key key-translation-map (kbd "<f7>") (kbd "C-c c")) ;; On F7, send C-c c
-(keymap-set key-translation-map "<f8>" "C-c p") ;; On F8, send C-c p
+(define-key key-translation-map (kbd "<f8>") (kbd "C-c p")) ;; On F8, send C-c p
 
 (provide 'icejam-keys-mode)
 ;;; icejam-keys-mode.el ends here

lisp/icejam-lsp.el

@@ -0,0 +1,76 @@
+;;; icejam-lsp -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Global Language Server Protocol Config
+;;; Code:
+
+;; (use-package lsp-mode :ensure (:depth 5) :requires (company))
+(with-eval-after-load 'lsp-mode
+  (setq-default lsp-file-watch-threshold 10000
+                lsp-restart 'auto-restart
+                lsp-prefer-capf t
+                lsp-completion-provider :capf
+                lsp-server-trace nil
+                lsp-lens-enable nil
+                lsp-lens-mode nil
+                read-process-output-max (* 1024 1024 4)
+                ;; Disable the piece of shit vue LSP server. It activates itself in every
+                ;; project with .js, .ts or .json file due to something called 'takeover
+                ;; mode' or 'hybrid mode' or some such.
+                ;; It would be okay, but it also doesn't work 99% of the time.
+
+                ;; When needed, enable this hot garbage in dir-locals.el
+                lsp-disabled-clients '(vue-semantic-server
+                                       ;; Ruby LSP servers, none of which actually work.
+                                       ruby-ls rubocop-ls typeprof-ls)
+                lsp-log-io nil
+                lsp-enable-file-watchers nil)
+  (unbind-key "s-l =" lsp-mode-map)
+  (unbind-key "s-l G" lsp-mode-map)
+  (unbind-key "s-l T" lsp-mode-map)
+  (unbind-key "s-l a" lsp-mode-map)
+  (unbind-key "s-l g" lsp-mode-map)
+  (unbind-key "s-l r" lsp-mode-map)
+  (unbind-key "C-S-SPC" lsp-mode-map)
+  (unbind-key "s-l G g" lsp-mode-map)
+  (unbind-key "s-l G r" lsp-mode-map)
+  (unbind-key "s-l G s" lsp-mode-map)
+  (unbind-key "s-l h g" lsp-mode-map)
+  (unbind-key "s-l h h" lsp-mode-map)
+  (unbind-key "s-l h s" lsp-mode-map)
+  (unbind-key "s-l g a" lsp-mode-map)
+  (unbind-key "s-l g e" lsp-mode-map)
+  (unbind-key "s-l g g" lsp-mode-map)
+  (unbind-key "s-l g h" lsp-mode-map)
+  (unbind-key "s-l g r" lsp-mode-map)
+  (unbind-key "s-l T D" lsp-mode-map)
+  (unbind-key "s-l T L" lsp-mode-map)
+  (unbind-key "s-l T S" lsp-mode-map)
+  (unbind-key "s-l T T" lsp-mode-map)
+  (unbind-key "s-l T b" lsp-mode-map)
+  (unbind-key "s-l T d" lsp-mode-map)
+  (unbind-key "s-l T f" lsp-mode-map)
+  (unbind-key "s-l T l" lsp-mode-map)
+  (unbind-key "s-l T s" lsp-mode-map)
+  (unbind-key "s-l F a" lsp-mode-map)
+  (unbind-key "s-l F b" lsp-mode-map)
+  (unbind-key "s-l F r" lsp-mode-map)
+  (unbind-key "s-l = =" lsp-mode-map)
+  (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 r" lsp-mode-map)
+  (unbind-key "s-l s s" lsp-mode-map))
+
+(use-package lsp-ui :ensure t :after (lsp-mode))
+(with-eval-after-load 'lsp-ui
+  (setq lsp-ui-doc-enable t
+        lsp-ui-header t
+        lsp-ui-delay 0.5 ;; Wait half a second to display documentation
+        lsp-ui-doc-position 'at-point
+        lsp-ui-doc-include-signature t))
+
+;; Lsp debugger mode
+(use-package dap-mode :ensure t :after (lsp-mode lsp-ui))
+
+(provide 'icejam-lsp)
+;;; icejam-lsp.el ends here

lisp/icejam-magit.el

@@ -2,11 +2,10 @@
 ;;; Commentary:
 ;;; Code:
 
-(eval-when-compile (defvar icejam-keys-mode-map))
+(require 'icejam-keys-mode)
 
 (use-package magit
   :ensure t
-  :commands (magit-blame-quit)
   :defer t
   :bind (:map icejam-keys-mode-map
               ("<f5> c" . magit-checkout)

lisp/icejam-prog-mode.el

@@ -12,42 +12,44 @@
 (global-eldoc-mode t)
 
 ;; Revert tag tables without asking
-(use-package etags :ensure nil :defer t
+(use-package etags :ensure nil
-  :config
+  :custom (tags-revert-without-query t "Revert tag tables without asking"))
-  (setopt tags-revert-without-query t))
 
 ;;; Show trailing whitespace and remove whitespace on save
 (use-package whitespace :ensure nil
+  :custom ((whitespace-style #'(face trailing empty) "New whitespace style.")
+           (require-final-newline 't "Insert newline on save"))
   :hook ((prog-mode . whitespace-mode)
          (text-mode . whitespace-mode)
          (conf-mode . whitespace-mode)
-         (before-save . whitespace-cleanup))
+         (before-save . whitespace-cleanup)))
-  :config
-  (setopt whitespace-style #'(face trailing empty) ;; New whitespace style
-          require-final-newline 't ;; Insert newline on save
-          ))
 
 (setq-default indent-tabs-mode nil)
 
 ;; Use colorful, matching parens
 ;; Rework the code below to enumerate each hook separately:
-(use-package rainbow-delimiters :ensure t :defer t
+(use-package rainbow-delimiters :ensure t
   :hook ((prog-mode . rainbow-delimiters-mode)
-         (text-mode . rainbow-delimiters-mode)
+         (text-mode . rainbow-delimiters-mode))
-         (elpaca-after-init . electric-pair-mode)
+  :config
-         (elpaca-after-init . show-paren-mode)))
+  (electric-pair-mode t)
+  (show-paren-mode t))
 
 ;;; Show hex (#aaa) colors as colors
-(use-package rainbow-mode :ensure t :defer t
+(use-package rainbow-mode :ensure t
   :hook ((prog-mode . rainbow-mode)
          (text-mode . rainbow-mode)))
 
 ;; Dash integration
-(use-package dash-at-point :ensure t :defer t
+(use-package dash-at-point :ensure t)
-  :config
+(with-eval-after-load 'dash-at-point
   (add-to-list 'dash-at-point-mode-alist '(enh-ruby-mode  . "ruby,rubygems,rails"))
   (add-to-list 'dash-at-point-mode-alist '(elixir-ts-mode . "elixir,hex")))
 
+;; By default, use 2 spaces for indentation
+(setopt tab-width 2)
+(setopt tab-stop-list (number-sequence tab-width 200 tab-width))
+
 ;; Ensure indentation in steps:
 (defun icejam-set-indent (step)
   "Set indentation to STEP."
@@ -55,25 +57,17 @@
   (setq-local tab-width step)
   (setq-local tab-stop-list (number-sequence step 200 step)))
 
-;; By default, use 2 spaces for indentation
+(use-package column-enforce-mode :ensure t
-(icejam-set-indent 2)
+  :config
-
+  (declare-function global-column-enforce-mode "column-enforce-mode")
-(use-package column-enforce-mode :ensure t :defer t
+  (global-column-enforce-mode t))
-  :hook (elpaca-after-init . global-column-enforce-mode))
 
 ;; PCRE to Emacs regex translations
-(use-package pcre2el :ensure t :defer 5)
+(use-package pcre2el :ensure t)
 
 ;; Visual regexp
-(use-package visual-regexp-steroids :ensure t
+(use-package visual-regexp-steroids :ensure t :requires (pcre2el)
-  :after (pcre2el)
+  :custom (vr/engine 'pcre2el "Use pcre2el for regexes"))
-  :config
-  ;; Use pcre2el for regexes - so that I can use brackets more naturally with
-  ;; regexp.
-  (setopt vr/engine 'pcre2el))
-
-;; Format all programming languages with the same package
-(use-package apheleia :ensure t :defer t)
 
 (provide 'icejam-prog-mode)
 ;;; icejam-prog-mode.el ends here

lisp/icejam-sys-specific.el

@@ -4,15 +4,16 @@
 ;;; Code:
 
 (defconst IS-MAC (eq system-type 'darwin))
+(defconst IS-BSD (eq system-type 'berkeley-unix))
 (defconst IS-GNU (eq system-type 'gnu/linux))
 
-(eval-when-compile (defvar icejam-keys-mode-map))
+(require 'icejam-keys-mode)
 
 (defun icejam-function-delete-window ()
   "Kill a window."
   (interactive) (delete-window))
 
-;; Mac-specific config
+;;;;;;;;; Mac-specific config ;;;;;;;;;;;;;;;;;;;;;
 (if IS-MAC
     (progn
       (setq mac-option-modifier 'meta)
@@ -29,30 +30,30 @@
             (setq mac-option-modifier nil)
             (setq mac-command-modifier 'meta))))
 
-      ;; Mac binding (fix)
+      ;;;;;;;;; Mac binding (fix) ;;;;;;;;;;;;;;;;;;
-      (keymap-set icejam-keys-mode-map "H-<right>" #'end-of-line)
+      (define-key icejam-keys-mode-map (kbd "H-<right>") #'end-of-line)
-      (keymap-set icejam-keys-mode-map "H-<left>" #'beginning-of-line)
+      (define-key icejam-keys-mode-map (kbd "H-<left>") #'beginning-of-line)
-      (keymap-set icejam-keys-mode-map "H-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (define-key icejam-keys-mode-map (kbd "H-<up>") #'scroll-down) ; WTF is this reverse, I dunno
-      (keymap-set icejam-keys-mode-map "H-<down>" #'scroll-up)
+      (define-key icejam-keys-mode-map (kbd "H-<down>") #'scroll-up)
 
       ;; Use CMD bindings that you know from the operating system
-      (keymap-set icejam-keys-mode-map "H-a" #'mark-whole-buffer) ;; Select all
+      (define-key icejam-keys-mode-map [(hyper a)] #'mark-whole-buffer) ;; Select all
-      (keymap-set icejam-keys-mode-map "H-v" #'yank) ;; Paste
+      (define-key icejam-keys-mode-map [(hyper v)] #'yank) ;; Paste
-      (keymap-set icejam-keys-mode-map "H-x" #'kill-region) ;; Cut
+      (define-key icejam-keys-mode-map [(hyper x)] #'kill-region) ;; Cut
-      (keymap-set icejam-keys-mode-map "H-c" #'kill-ring-save) ;; Copy
+      (define-key icejam-keys-mode-map [(hyper c)] #'kill-ring-save) ;; Copy
-      (keymap-set icejam-keys-mode-map "H-s" #'save-buffer) ;; Save
+      (define-key icejam-keys-mode-map [(hyper s)] #'save-buffer) ;; Save
-      (keymap-set icejam-keys-mode-map "H-z" #'undo) ;; Undo
+      (define-key icejam-keys-mode-map [(hyper z)] #'undo) ;; Undo
-      (keymap-set icejam-keys-mode-map "H-Z" #'undo-redo) ;; Redo
+      (define-key icejam-keys-mode-map [(hyper q)] #'kill-emacs) ;; Close emacs
-      (keymap-set icejam-keys-mode-map "H-q" #'kill-emacs) ;; Close emacs
+      (define-key icejam-keys-mode-map [(hyper w)] #'icejam-function-delete-window) ;; Close window
-      (keymap-set icejam-keys-mode-map "H-w" #'icejam-function-delete-window) ;; Close window
 
       ;; And then some extras
-      (keymap-set icejam-keys-mode-map "H-l" #'goto-line) ;; Goto Line
+      (define-key icejam-keys-mode-map [(hyper l)] #'goto-line) ;; Goto Line
       ;; Disable meta on right alt (useful for Polish characters)
       ;; (setq mac-right-option-modifier nil)
 
       ;; Allow for fullscreen frames without gaps
-      (setq frame-resize-pixelwise t)))
+      (setq frame-resize-pixelwise t)
+      ))
 
 (defun icejam-switch-right-left-alt ()
   "Set keyboard to das keyboard."
@@ -65,25 +66,42 @@
       (setq mac-option-modifier 'meta)
       (setq mac-right-option-modifier nil))))
 
-;; Linux-specific config
+;;;;;;;;; Linux-specific config ;;;;;;;;;;;;;;;;;;;;;
 (if IS-GNU
     (progn
-      ;; Save and undo
+      ;;;; Save and undo
-      (keymap-set icejam-keys-mode-map "s-s" #'save-buffer)
+      (define-key icejam-keys-mode-map (kbd "s-s") 'save-buffer)
-      (keymap-set icejam-keys-mode-map "s-z" #'undo)
+      (define-key icejam-keys-mode-map (kbd "s-z") 'undo)
-      (keymap-set icejam-keys-mode-map "s-Z" #'undo-redo)
+      (define-key icejam-keys-mode-map (kbd "s-a") 'mark-whole-buffer)
-      (keymap-set icejam-keys-mode-map "s-a" #'mark-whole-buffer)
 
-      ;; Copy and paste bindings
+      ;;;;;;;; Copy and paste bindings ;;;;;;;;;;;;;;;;;;
-      (keymap-set icejam-keys-mode-map "s-x" #'kill-region)
+      (define-key icejam-keys-mode-map (kbd "s-x") 'kill-region)
-      (keymap-set icejam-keys-mode-map "s-v" #'yank)
+      (define-key icejam-keys-mode-map (kbd "s-v") 'yank)
-      (keymap-set icejam-keys-mode-map "s-c" #'kill-ring-save)
+      (define-key icejam-keys-mode-map (kbd "s-c") 'kill-ring-save)
 
-      ;; Linux Ergo bindings (fix)
+      ;;;;;;;;; Linux Ergo bindings (fix) ;;;;;;;;;;;;;;;;;;
-      (keymap-set icejam-keys-mode-map "C-<right>" #'end-of-line)
+      (define-key icejam-keys-mode-map (kbd "C-<right>") 'end-of-line)
-      (keymap-set icejam-keys-mode-map "C-<left>" #'beginning-of-line)
+      (define-key icejam-keys-mode-map (kbd "C-<left>") 'beginning-of-line)
-      (keymap-set icejam-keys-mode-map "C-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (define-key icejam-keys-mode-map (kbd "C-<up>") 'scroll-down) ; WTF is this reverse, I dunno
-      (keymap-set icejam-keys-mode-map "C-<down>" #'scroll-up)))
+      (define-key icejam-keys-mode-map (kbd "C-<down>") 'scroll-up)))
+
+;;;;;;;;; BSD-specific config ;;;;;;;;;;;;;;;;;;;;;
+(if IS-BSD
+    (progn
+      (define-key icejam-keys-mode-map (kbd "A-<right>") 'end-of-line)
+      (define-key icejam-keys-mode-map (kbd "A-<left>") 'beginning-of-line)
+      (define-key icejam-keys-mode-map (kbd "A-<up>") 'scroll-down) ; WTF is this reverse, I dunno
+      (define-key icejam-keys-mode-map (kbd "A-<down>") 'scroll-up)
+
+      (define-key icejam-keys-mode-map (kbd "A-a") 'mark-whole-buffer)
+      (define-key icejam-keys-mode-map (kbd "A-v") 'yank)
+      (define-key icejam-keys-mode-map (kbd "A-x") 'kill-region)
+      (define-key icejam-keys-mode-map (kbd "A-c") 'kill-ring-save)
+      (define-key icejam-keys-mode-map (kbd "A-s") 'save-buffer)
+      (define-key icejam-keys-mode-map (kbd "A-l") 'goto-line)
+      (define-key icejam-keys-mode-map (kbd "A-w" '+delete-window)
+      (define-key icejam-keys-mode-map (kbd "A-z") 'undo)
+      (define-key icejam-keys-mode-map (kbd "A-q") 'kill-emacs))))
 
 (provide 'icejam-sys-specific)
 ;;; icejam-sys-specific.el ends here

lisp/icejam-themes.el

@@ -3,20 +3,31 @@
 ;;; Code:
 
 (use-package spaceline :ensure t
-  :hook ((elpaca-after-init . spaceline-emacs-theme))
+  :hook ((elpaca-after-init . spaceline-emacs-theme)))
-  :config
-  ;; Recompile spaceline after each theme has been reloaded to ensure
-  ;; that there are no artifacts instead of arrows on the screen.
-  (setopt enable-theme-functions 'spaceline-compile))
 
-(use-package base16-theme :ensure t)
+(use-package base16-theme :ensure t
+  ;; :config
+  ;; (load-theme 'base16-atelier-forest-light t t)
+  ;; (load-theme 'base16-harmonic16-light t t)
+  ;; (load-theme 'base16-horizon-light t t)
+  ;; (load-theme 'base16-humanoid-light t t)
+  ;; (load-theme 'base16-zenburn t)
+  ;; (load-theme 'base16-tomorrow-night-eighties t t)
+  ;; (load-theme 'base16-darcula t t)
+  ;; (load-theme 'base16-solarflare t t)
+  ;; (load-theme 'base16-snazzy t t)
+  ;; (load-theme 'base16-onedark t t)
+  ;; (load-theme 'base16-gruvbox-dark-hard t t)
+  ;; (load-theme 'modus-vivendi t t)
+  ;; (load-theme 'base16-zenbones t t)
+  )
 
 ;; (use-package apropospriate-theme :ensure t
 ;;   :config (load-theme 'apropospriate-light t t))
 ;; (use-package leuven-theme :ensure t
 ;;   :config
 ;;   (load-theme 'leuven t t))
-(use-package modus-themes :ensure t)
+;; (use-package modus-themes :ensure t )
 ;; (use-package darktooth-theme :ensure t
 ;;   :config
 ;;   (load-theme 'darktooth t t))
@@ -32,7 +43,6 @@
 ;; (use-package zenburn-theme :ensure t
 ;;   :config
 ;;   (load-theme 'zenburn t t))
-
 ;; (use-package catppuccin-theme :ensure t
 ;;   :custom
 ;;   ((catpuccin-flavor 'frappe))
@@ -42,19 +52,11 @@
 ;; Disable cursor blinking
 (blink-cursor-mode 0)
 
-;; Scroll with the trackpad smoothly
-(pixel-scroll-precision-mode 1)
-
 ;; My own theme modifications:
 (with-eval-after-load 'base16-theme
   (setopt base16-theme-256-color-source 'colors)
-  (load-theme 'base16-equilibrium-light t t)
-  (load-theme 'base16-gruvbox-dark-pale t t)
-  (load-theme 'base16-onedark t t)
-  (load-theme 'modus-operandi-tinted t t)
   (require 'icejam-base16-zenburn)
   (require 'icejam-base16-harmonic-light)
-  (require 'icejam-base16-catppuccin-latte)
 
   (if (memq window-system '(x mac ns))
       (enable-theme 'icejam-base16-zenburn)

lisp/icejam-transient.el

@@ -2,9 +2,11 @@
 ;;; Commentary:
 ;;; Global Transient definitions.
 ;;; Code:
-(eval-when-compile (defvar icejam-keys-mode-map))
 
-(use-package transient :ensure (:wait t))
+(require 'icejam-avy)
+(require 'icejam-keys-mode)
+(require 'icejam-blocking)
+;; (use-package transient :ensure (:wait t) :demand t)
 
 (defun icejam-mark-and-indent-whole-buffer ()
   "Mark and indent whole buffer."
@@ -13,116 +15,100 @@
 
 (transient-define-prefix icejam-project-menu ()
   "Project Commands."
-  [["Project"
+  [""
+   ["Project"
     ("s" "Switch project"       project-switch-project)
     ("f" "Find file in project" project-find-file)
-    ("g" "Grep in project" consult-ripgrep)
+    ("g" "Grep in project"      consult-ripgrep)]
-    ("t" "Find file anywhere" find-file)]
+   ["Completions"
+    ("a" "Grep in buffer"       consult-line)
+    ("b" "Buffer list"          consult-buffer)
+    ("t" "Find file"            find-file)]
    ["Magit"
     ("m" "Git status"           magit-status)
     ("C" "Git checkout"         magit-checkout)
-    ("M" "Git blame" magit-blame)]
+    ("M" "Git blame"            magit-blame)]]
-   ["Completions"
+  [""
-    ("a" "Find line by contents" consult-line)
+   ["LISP"
-    ("b" "Find buffer by name" consult-buffer)]]
-  [["LISP"
     ("i" "IELM"                 ielm)
-    ("B" "iBuffer"              ibuffer)
     ("e" "eval-region"          eval-region)]
    ["Other"
     ("d" "deft"                 deft)
-    ("T" "Speed Type"           speed-type-text)]]
+    ("T" "Speed Type"           speed-type-text)]])
-  [[""
-    ("q" "Quit" keyboard-quit)]])
 
 (transient-define-prefix icejam-code-menu ()
   "Code Commands."
-  [["Manipulate"
+  [""
+   ["Manipulate"
     ("c" "Toggle Comment"     comment-line)
     ("r" "Replace"            vr/replace)
-    ("i" "Indent"             indent-region)]]
+    ("i" "Indent"             indent-region)]
-  [["Complete"
+   ["Complete"
-    ("g" "Ask GPTel"             gptel-menu)
+    ("y" "Snippet"            company-yasnippet)
-    ("a" "Aider"                 aidermacs-transient-menu)
+    ("m" "Any (Company)"      company-complete)
-    ("e" "Refactor with Elysium" elysium-query)]]
+    ("g" "Ask GPT"            gptel-menu)
-   [["Find"
+    ("e" "Refactor (Elysium)" elysium-query)]
+   ["Find"
     ("s" "Swiper"             consult-line)
     ("u" "Vundo"              vundo)
     ("d" "Dash"               dash-at-point)]])
 
-(transient-define-prefix icejam-buffer-menu ()
+(transient-define-prefix icejam-window-menu ()
-  "Buffers and windows."
+  "Windows Commands."
   [""
-   ["Move Cursor"
+   ["Move"
-    :pad-keys t
+    ("<left>" " Left"   windmove-left)
-    ("<left>"  "Left buffer" windmove-left)
+    ("<right>" "Right"  windmove-right)
-    ("<right>" "Right buffer" windmove-right)
+    ("<up>" "   Up"     windmove-up)
-    ("<up>"    "Top buffer" windmove-up)
+    ("<down>" " Down"   windmove-down)]
-    ("<down>"  "Bottom buffer" windmove-down)]
-   ["Move this buffer"
-    :pad-keys t
-    ("v[" "To left" buf-move-left)
-    ("v]" "To right"  buf-move-right)
-    ("h[" "Up" buf-move-up)
-    ("h]" "Down"  buf-move-down)]]
-  [["Jump to"
-    ("w" "Word" avy-goto-word-1)
-    ("l" "Line" avy-goto-line)
-    ("c" "Character" avy-goto-char-2)]
    ["Split"
-    ("sr" "To right" split-window-right)
+    ("h" "Horizontally" split-window-below)
-    ("sb" "To bottom" split-window-below)
+    ("v" "Vertically"   split-window-right)]
-    ("\\" "To right" split-window-right)
+   ["Kill"
-    ("/"  "To bottom" split-window-below)]]
+    ""
-  [["Buffers"
+    ""
-    :pad-keys t
+    ""
-    ("s[" "Go to previous buffer" previous-buffer)
+    ("k" "Kill Buffer"  kill-buffer-and-window)]])
-    ("s]" "Go to next buffer" next-buffer)
-    ("bi" "iBuffer" ibuffer)
-    ("bf" "Find buffer" consult-buffer)
-    ("k" "Kill buffer and window" kill-buffer-and-window)]]
-  [["Fonts"
-    :pad-keys t
-    ("fs" "Adjust font size globally" global-text-scale-adjust)
-    ("fi" "Increase by one in this buffer"
-     (lambda () (interactive) (text-scale-increase 1)))
-    ("fd" "Decrease by one in this buffer"
-     (lambda () (interactive) (text-scale-decrease 1)))
-    ("fr" "Reset this buffer"
-     (lambda () (interactive) (text-scale-adjust 0)))]]
-  [[""
-    ("q" "Quit" keyboard-quit)]])
 
 (transient-define-prefix icejam-language-menu ()
   "Language (Buffer) Commands."
-  [[:description
+  [""
-    (lambda ()
+   ["Buffer"
-      (concat (propertize "Code actions for " 'face 'transient-heading)
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-              (propertize (format "%s" major-mode) 'face 'transient-key)
+    ("f" "Format"      lsp-format-buffer)
-              (propertize ":\n" 'face 'transient-heading)))
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)]
+   ["Other"
+    ("m" "iMenu"       lsp-ui-imenu)
+    ("e" "Show Errors" flycheck-list-errors)]])
 
-    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+(transient-define-prefix icejam-history-menu ()
-    ("e" "Show errors" flymake-show-buffer-diagnostics)
+  "Buffer History Commands."
-    ("f" "Format buffer with apheleia formatter" apheleia-format-buffer)
+  ["History"
+   ("[" "Previous" previous-buffer)
+   ("]" "Next" previous-buffer)])
 
-    ;; This only appears for emacs-lisp-mode
+(transient-define-prefix icejam-move-menu ()
-    ("d" "Explain thing at point" helpful-at-point :if-mode emacs-lisp-mode)
+  "Move Commands."
+  [""
+   ["Move this buffer"
+    ("{" "Up"    buf-move-left)
+    ("[" "Left"  buf-move-right)
+    ("}" "Right" buf-move-up)
+    ("]" "Down"  buf-move-down)]
+   ["Jump to"
+    ("w" "Word" avy-goto-word-1)
+    ("l" "Character" avy-goto-line)
+    ("c" "Line" avy-goto-char-2)]])
 
-    ("m" "iMenu" consult-imenu)
+(transient-define-prefix icejam-font-menu ()
-
+  "Font Commands."
-    ;; Finally, quit.
+  [""
-    ("q" "Quit" keyboard-quit)]])
+   ["Everywhere"
-
+    ("s" "Adjust font size" global-text-scale-adjust)]
-(transient-define-prefix icejam-elpaca-menu ()
+   ["In this buffer"
-  "Commands related to packages."
+    ("i" "Bigger"           (lambda () (interactive) (text-scale-increase 1)))
-  [["Packages and compilation"
+    ("d" "Smaller"          (lambda () (interactive) (text-scale-decrease 1)))
-    ("m" "Open Elpaca manager" elpaca-manager)
+    ("r" "Reset"            (lambda () (interactive) (text-scale-adjust 0)))]])
-    ("f" "Fetch all package updates" elpaca-fetch-all)
-    ("s" "Symlink treesitter grammar objects" icejam-tree-sitter-symlink-grammar-objects)
-    ("p" "Prune native compilation cache" native-compile-prune-cache)
-    ("w" "Write elpaca lockfile" icejam-elpaca-write-lock)]]
-  [[""
-    ("q" "Quit" keyboard-quit)]])
 
 (defcustom icejam-language-transient-alist
   '()
@@ -143,24 +129,13 @@ You can pass MAYBE-MODE to find mode explicitly."
   (interactive)
   (funcall (icejam-language-transient-for-mode)))
 
-(transient-define-prefix icejam-command-palette ()
+(define-key icejam-keys-mode-map (kbd "C-c p") 'icejam-project-menu)
-  "All transient menus in one place."
+(define-key icejam-keys-mode-map (kbd "C-c c") 'icejam-code-menu)
-  ["Command palette\n"
+(define-key icejam-keys-mode-map (kbd "C-c w") 'icejam-window-menu)
-   ["The thing you are editing"
+(define-key icejam-keys-mode-map (kbd "C-c s") 'icejam-history-menu)
-    ("p" "Project" icejam-project-menu)
+(define-key icejam-keys-mode-map (kbd "C-c f") 'icejam-font-menu)
-    ("c" "Code" icejam-code-menu)
+(define-key icejam-keys-mode-map (kbd "C-c m") 'icejam-move-menu)
-    ("l" "Language" icejam-transient-for-lang)
+(define-key icejam-keys-mode-map (kbd "C-c l") 'icejam-transient-for-lang)
-    ("r" "Revert Buffer" icejam-revert-buffer-no-confirm)]
-   ["The editor itself"
-    ("b" "iBuffer" ibuffer)
-    ("P" "Packages" icejam-elpaca-menu)
-    ("w" "Window" icejam-buffer-menu)]])
-
-(keymap-set icejam-keys-mode-map "C-c p" #'icejam-project-menu)
-(keymap-set icejam-keys-mode-map "C-c c" #'icejam-code-menu)
-(keymap-set icejam-keys-mode-map "C-c w" #'icejam-buffer-menu)
-(keymap-set icejam-keys-mode-map "C-c l" #'icejam-transient-for-lang)
-(keymap-set icejam-keys-mode-map "H-p" #'icejam-command-palette)
 
 (provide 'icejam-transient)
 ;;; icejam-transient.el ends here

lisp/icejam-tree-sitter.el

@@ -10,14 +10,13 @@
 ;; community.
 
 ;;; Code:
-(use-package tree-sitter-langs :ensure t :defer t
-  :commands tree-sitter-langs--bin-dir
-  :hook
-  (elpaca-after-init . (lambda () (add-to-list
-                                   'treesit-extra-load-path
-                                   (tree-sitter-langs--bin-dir)))))
 
-(defun icejam-tree-sitter-symlink-grammar-objects ()
+(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 ()
     "Create symlinks for treesitter grammars.
 Tree-sitter-langs-build releases grammars as LANG.so. Treesit needs
 libtree-sitter-LANG.so"
@@ -30,7 +29,7 @@ libtree-sitter-LANG.so"
                             (file-name-nondirectory file))))
         (if (memq system-type '(ms-dos windows-nt cygwin))
             (copy-file file target)
-        (make-symbolic-link file target)))))
+          (make-symbolic-link file target))))))
 
 (provide 'icejam-tree-sitter)
 ;;; icejam-tree-sitter.el ends here

lisp/icejam-vundo.el

@@ -10,11 +10,8 @@
 
 ;;; Code:
 
-;; Undo UI
+;;;;;;;;;;;;;;;;; Use more advanced undo options
-(use-package vundo :ensure t :defer t
+(use-package vundo :ensure t :defer t)
-  :config
-  ;; Keep 64 MB of undo data, we have enough RAM to do this.
-  (setopt undo-limit (* 64 1024 1024)))
 
 (provide 'icejam-vundo)
 ;;; icejam-vundo.el ends here

lisp/langs/icejam-lang-clang.el

@@ -2,6 +2,8 @@
 ;;; Commentary:
 ;;; Code:
 
+(require 'icejam-prog-mode)
+
 (declare-function column-enforce-n "column-enforce-mode" (number))
 
 (defun icejam-lang-activate-clang-mode ()
@@ -17,7 +19,10 @@
 
   (if (boundp 'c-default-style)
       (setq-local c-default-style "bsd")
-    (defvar c-default-style "bsd")))
+    (defvar c-default-style "bsd"))
+
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-etags company-yasnippet)))
 
 (add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)
 

lisp/langs/icejam-lang-clojure.el

@@ -2,14 +2,16 @@
 ;;; Commentary:
 ;;; Code:
 
+(require 'icejam-prog-mode)
+(require 'icejam-transient)
+
 (declare-function column-enforce-n "column-enforce-mode" (number))
-(declare-function icejam-set-indent 'icejam-prog-mode)
 
 (use-package clojure-mode :defer t :ensure t)
 
 (use-package cider
   :requires clojure-mode
-  :commands (cider-mode cider-jack-in)
+  :commands cider-jack-in
   :defer t
   :ensure t
   :config (setq cider-annotate-completion-function t))
@@ -30,7 +32,7 @@
     ("r" "Reload"      icejam-revert-buffer-no-confirm)
     ("f" "Format"      cider-format-buffer)
     ("l" "Load"        cider-load-buffer)
-    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+    ("e" "Show Errors" flycheck-list-errors)]]
   [""
    ("q"  "Quit"        keyboard-quit)])
 
@@ -39,8 +41,10 @@
   (icejam-set-indent 2) ;; Default indentation of 2 characters
   (column-enforce-n 80)
   (cider-mode 1)
+  (setq-local indent-tabs-mode nil)
 
-  (define-key clojure-mode-map (kbd "C-c l") 'icejam-lang-cider-context-menu)
+  (define-key
+    clojure-mode-map (kbd "C-c l") 'icejam-lang-cider-context-menu)
 
   ;; Do not enable paredit for clojure
   ;; (paredit-mode 1)
@@ -54,7 +58,7 @@
 	(setq-local cider-show-error-buffer 'except-in-repl))
 
 (add-hook 'cider-repl-mode-hook 'icejam-lang-clojure-repl-config)
-(add-hook 'cider-mode-hook 'cider-enable-flex-completion)
+(add-hook 'cider-mode-hook #'cider-company-enable-fuzzy-completion)
 
 (provide 'icejam-lang-clojure)
 ;;; icejam-lang-clojure.el ends here

lisp/langs/icejam-lang-common-lisp.el

@@ -0,0 +1,22 @@
+;;; common-lisp.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'icejam-prog-mode)
+(require 'icejam-company-yasnippet)
+
+(use-package slime :ensure t)
+(use-package slime-company :ensure t
+  :requires (slime company))
+
+(setq inferior-lisp-program "sbcl")
+(slime-setup '(slime-fancy slime-company slime-quicklisp slime-asdf))
+
+(provide 'icejam-lang-common-lisp)
+;;; icejam-lang-common-lisp.el ends here

lisp/langs/icejam-lang-dart.el

@@ -2,11 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
+(require 'icejam-prog-mode)
+
 (use-package dart-mode :ensure t :defer t)
+(use-package lsp-dart :defer t :ensure t :requires (dart-mode lsp))
 
 (defun icejam-lang-activate-dart-mode ()
   "Reconfigure dart mode for your own purposes."
-  (eglot-ensure))
+  (lsp))
 
 (add-hook 'dart-mode-hook 'icejam-lang-activate-dart-mode)
 

lisp/langs/icejam-lang-dhall.el

@@ -2,12 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
-(use-package dhall-mode :ensure t :defer t)
+(require 'icejam-prog-mode)
+(require 'icejam-lsp)
+
+(use-package dhall-mode :ensure t :defer t :requires (lsp))
 
 (defun icejam-lang-activate-dhall-mode ()
   "Reconfigure dhall mode for your own purposes."
-  (eglot-ensure)
+  (lsp))
-  (icejam-set-eglot-capfs))
 
 (add-hook 'dhall-mode-hook 'icejam-lang-activate-dhall-mode)
 (add-hook 'dhall-mode-hook 'display-line-numbers-mode)

lisp/langs/icejam-lang-elisp.el

@@ -2,26 +2,43 @@
 ;;; Commentary:
 ;;; Code:
 
-(eval-when-compile
+(require 'icejam-prog-mode)
-  (declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-transient)
-  (declare-function icejam-set-elisp-capfs 'icejam-complete-at-point)
-  (declare-function icejam-set-indent 'icejam-prog-mode))
 
+(use-package lispy :ensure t)
+
+(declare-function column-enforce-n "column-enforce-mode" (number))
 (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
 
-(use-package lispy :ensure t :defer t :commands (lispy-mode))
+(transient-define-prefix icejam-elisp-lang-menu ()
-;; (use-package geiser-guile :ensure t :defer t)
+  "Elisp Buffer Commands."
+  [""
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("d" "Explain"     helpful-at-point)
+    ("e" "Show Errors" flycheck-list-errors)]]
+  [""
+   ("q" "Quit"        keyboard-quit)])
 
-(defun icejam-activate-emacs-lisp-mode ()
+(add-to-list
+ '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 ()
     "Goodies for editing Emacs files."
-
     (icejam-set-indent 2) ;; Default indentation of 2 characters
-  (column-enforce-n 80) ;; Use 80 char limit.
+    (column-enforce-n 80)
-  (lispy-mode t)        ;; Modal editing for Lisp
-  (icejam-set-elisp-capfs))
 
-(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
+    (lispy-mode t)
-(add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)
+    (setq-default indent-tabs-mode nil)
+
+    ;; Company list override
+    (add-to-list (make-local-variable 'company-backends)
+                 '(company-yasnippet company-capf)))
+
+  (add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode))
 
 (provide 'icejam-lang-elisp)
 ;;; icejam-lang-elisp.el ends here

lisp/langs/icejam-lang-elixir.el

@@ -2,40 +2,32 @@
 ;;; Commentary:
 ;;; Code:
 
-(eval-when-compile
+(require 'icejam-prog-mode)
-  (declare-function transient-define-prefix 'transient)
+(require 'icejam-flycheck)
-  (declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-transient)
-  (declare-function -> 'dash)
-  (declare-function yas--table-get-create 'yasnippet)
-  (declare-function yas--remove-template-by-uuid 'yasnippet)
-  (declare-function icejam-set-indent 'icejam-prog-mode)
-  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-  (defvar icejam-language-transient-alist)
-  (defvar icejam-elixir-lang-menu)
-  (defvar apheleia-mode-alist))
 
-(use-package elixir-ts-mode :ensure t :defer t :after (apheleia)
+(declare-function lsp "lsp-mode" nil)
-  :config
+(declare-function column-enforce-n "column-enforce-mode" (number))
-  (add-to-list 'apheleia-mode-alist '(heex-ts-mode . mix-format)))
+
+(use-package elixir-mode :ensure t)
+(use-package elixir-ts-mode :ensure t :requires (elixir-mode lsp-mode lsp-ui))
+
+(with-eval-after-load 'elixir-ts-mode
+  (add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-ts-mode))
+  (add-to-list 'auto-mode-alist '("\\.ex\\'" . elixir-ts-mode)))
 
 (transient-define-prefix icejam-elixir-lang-menu ()
-  [[:description
+  "Elixir Buffer Commands."
-    (lambda ()
+  [""
-      (concat (propertize "Code actions for " 'face 'transient-heading)
+   ["LSP"
-              (propertize (format "%s" major-mode) 'face 'transient-key)
+    ("m" "iMenu"       lsp-ui-imenu)]
-              (propertize ":\n" 'face 'transient-heading)))
+   ["Buffer"
-    ("m" "iMenu" consult-imenu)
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("f" "Format"      elixir-format)
-    ("e" "Show errors" flymake-show-buffer-diagnostics)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("f" "Format buffer with Elixir formatter" apheleia-format-buffer)
+    ("e" "Show Errors" flycheck-list-errors)]]
-
+  [""
-    ("q" "Quit" keyboard-quit)]])
+   ("q" "Quit"        keyboard-quit)])
-
-(defun icejam-delete-elixir-snippets ()
-  "This function deletes Elixir snippets I don't use."
-  (-> 'elixir-mode
-      (yas--table-get-create)
-      (yas--remove-template-by-uuid "defmodule XXX end")))
 
 (add-to-list
  'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu))
@@ -44,27 +36,21 @@
   "All things Elixir."
   (icejam-set-indent 2)
   (column-enforce-n 98)
-  (eglot-ensure)
+  (lsp)
+  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+  (setq-local lsp-eldoc-enable-hover nil)
+  (setq-local lsp-completion-enable-additional-text-edit nil)
+  (setq-local company-minimum-prefix-length 3)
 
   ;; If needed, switch the one below to false to disable documentation pop-ups
   ;; (setq-local lsp-ui-doc-enable t)
-  (icejam-set-eglot-capfs)
+
-  (icejam-delete-elixir-snippets))
+  ;; Company list override
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'heex-ts-mode-hook 'icejam-activate-elixir-ts-mode)
 (add-hook 'elixir-ts-mode-hook 'icejam-activate-elixir-ts-mode)
 
-;; (use-package ert :ensure nil :defer t)
-;; (ert-deftest icejam-activate-elixir-ts-mode ()
-;;   "Test `elixir-ts-mode` activation."
-;;   (with-temp-buffer
-;;     (elixir-ts-mode)
-;;     (icejam-activate-elixir-ts-mode)
-;;     (should (eq major-mode 'elixir-ts-mode))
-;;     (should (bound-and-true-p column-enforce-mode))
-;;     (should (equal " 98col" (buffer-local-value 'column-enforce-mode-line-string
-;;                                             (current-buffer))))
-;;     (should (eq 2 (buffer-local-value 'tab-width (current-buffer))))))
-
 (provide 'icejam-lang-elixir)
 ;;; icejam-lang-elixir.el ends here

lisp/langs/icejam-lang-erlang.el

@@ -2,22 +2,85 @@
 ;;; Commentary:
 ;;; Code:
 
-(declare-function column-enforce-n 'column-enforce-mode)
+(require 'icejam-prog-mode)
-(declare-function icejam-set-indent 'icejam-prog-mode)
+(require 'icejam-lsp)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package erlang :defer t :ensure (:depth 1))
+(declare-function lsp "lsp-mode" nil)
+(declare-function column-enforce-n "column-enforce-mode" (number))
+
+(use-package erlang
+  :defer t
+  :ensure (:depth 1)
+  :after (lsp lsp-ui))
+
+(cl-defun icejam-erlang-emacs-path (erlang-version)
+  "Find path to Emacs tooling for ERLANG-VERSION."
+  (car (split-string
+        (shell-command-to-string
+         (format "find $HOME/.asdf/installs/erlang/%s/ -name erlang.el"
+                 erlang-version)) "erlang.el")))
+
+(cl-defun icejam-erlang-path (erlang-version)
+  "Find asdf path for ERLANG-VERSION."
+  (format "$HOME/.asdf/installs/erlang/%s/" erlang-version))
+
+(defun icejam-erlang-plist (erlang-version)
+  "Create property list for ERLANG-VERSION."
+  (list :version erlang-version
+        :erlang-path (icejam-erlang-path erlang-version)
+        :emacs-path (icejam-erlang-emacs-path erlang-version)))
+
+(cl-defun icejam-installed-erlangs ()
+  "List Erlang versions installed with asdf."
+  (split-string
+   (shell-command-to-string
+    (format "asdf list erlang"))))
+
+(cl-defun icejam-erlang-available-versions--plist ()
+  "Create plist for all installed Erlang versions."
+  (mapcar 'icejam-erlang-plist (icejam-installed-erlangs)))
+
+(defvar icejam-erlang-available-versions (icejam-erlang-available-versions--plist))
+
+(cl-defun icejam-erlang-currently-in-use ()
+  "Get Erlang version currently in use."
+  (car (split-string (shell-command-to-string "asdf current erlang"))))
+
+(cl-defun icejam-erlang-current-version--plistp (erlang-plist)
+  "Check if currently in use Erlang is the same as the one in ERLANG-PLIST."
+  (equal (plist-get erlang-plist :version) (icejam-erlang-currently-in-use)))
+
+(cl-defun icejam-erlang-current-plist ()
+  "Create plist from current Erlang version."
+  (seq-find 'icejam-erlang-current-version--plistp icejam-erlang-available-versions))
 
 (defun icejam-activate-erlang-mode ()
-  "Start Erlang related editing process."
+  "All things for all Erlang, including header files."
+  (when (featurep 'erlang-start) (unload-feature 'erlang-start))
+
+  (defvar erlang/current-erlang (icejam-erlang-current-plist))
+
+  (add-to-list (make-local-variable 'load-path)
+               (plist-get erlang/current-erlang :emacs-path))
+
+  (add-to-list (make-local-variable 'exec-path)
+               (format "%slib/tools-3.1/emacs"
+                       (plist-get erlang/current-erlang :erlang-path)))
+
+  (setq-local erlang-man-root-dir
+              (format "%sman"
+                      (plist-get erlang/current-erlang :erlang-path)))
+
+  (require 'erlang-start)
   (icejam-set-indent 4)
   (column-enforce-n 80)
 
   ;; Start LSP
-  (eglot-ensure)
+  (lsp)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)
 

lisp/langs/icejam-lang-fsharp.el

@@ -9,20 +9,24 @@
 ;; Fsharp configuration
 
 ;;; Code:
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function column-enforce-n 'column-enforce-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package fsharp-mode :ensure t :defer t)
+(require 'icejam-prog-mode)
+(require 'icejam-lsp)
+
+(use-package fsharp-mode
+  :requires (lsp-mode lsp-ui)
+  :ensure t
+  :defer t)
 
 (defun icejam-activate-fsharp-mode ()
   "Activate F# goodies."
   (icejam-set-indent 4)
   (column-enforce-n 100)
-  (eglot-ensure)
+  (lsp-deferred)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)
 

lisp/langs/icejam-lang-gleam.el

@@ -9,23 +9,24 @@
 ;; Gleam language support
 
 ;;; Code:
-(declare-function column-enforce-n 'column-enforce-mode (number))
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package gleam-ts-mode :defer t :ensure t
+(require 'icejam-prog-mode)
-  :mode (rx ".gleam" eos))
 
-;; (add-to-list 'auto-mode-alist '("\\.gleam\\'" . gleam-ts-mode))
+(use-package gleam-ts-mode
+  :ensure (:type git
+                 :host github
+                 :repo "gleam-lang/gleam-mode"
+                 :files ("gleam-ts-mode.el")))
+
+(add-to-list 'auto-mode-alist '("\\.gleam\\'" . gleam-ts-mode))
 
 (defun icejam-lang-activate-gleam-mode ()
   "All things Gleam."
   (icejam-set-indent 2)
   (column-enforce-n 100)
-  (eglot-ensure)
+  (lsp))
-  (icejam-set-eglot-capfs))
 
-(add-hook 'gleam-ts-mode-hook 'icejam-lang-activate-gleam-mode)
+(add-hook 'gleam-mode-hook 'icejam-lang-activate-gleam-mode)
 
 (provide 'icejam-lang-gleam)
 ;;; icejam-lang-gleam.el ends here

lisp/langs/icejam-lang-golang.el

@@ -9,20 +9,21 @@
 ;; golang mode stuff
 
 ;;; Code:
-(declare-function column-enforce-n 'column-enforce-mode (number))
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package go-mode :defer t :ensure t)
+(require 'icejam-prog-mode)
+
+(use-package go-mode
+  :requires (lsp-mode lsp-ui)
+  :defer t
+  :ensure t)
 
 (defun icejam-activate-golang-mode ()
   "Activate my own Golang mode settings."
   (icejam-set-indent 8)
   (column-enforce-n 100)
-  (eglot-ensure)
+  (lsp))
-  (icejam-set-eglot-capfs))
 
-(add-hook 'go-mode-hook #'icejam-activate-golang-mode)
+(add-hook 'go-mode-hook 'icejam-activate-golang-mode)
 
 (provide 'icejam-lang-golang)
 ;;; icejam-lang-golang.el ends here

lisp/langs/icejam-lang-haskell.el

@@ -10,20 +10,26 @@
 
 ;;; Code:
 
-(declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-prog-mode)
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package haskell-mode :ensure t :defer t)
+(use-package haskell-mode
+  :ensure t
+  :defer t)
+
+(use-package lsp-haskell
+  :ensure t
+  :defer t
+  :requires (lsp-mode lsp-ui haskell-mode))
 
 (defun icejam-activate-haskell-mode ()
-  "Run this in `haskell-mode'."
+  "Run this in haskell-mode."
   (icejam-set-indent 2)
   (column-enforce-n 80)
-  (eglot-ensure)
+  (lsp-deferred)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)
 

lisp/langs/icejam-lang-javascript.el

@@ -2,24 +2,15 @@
 ;;; Commentary:
 ;;; Code:
 
-(declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-prog-mode)
-(declare-function icejam-set-indent 'icejam-prog-mode)
+(require 'icejam-flycheck)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+(require 'icejam-lsp)
 
-(use-package js2-mode :ensure t :defer t :after(web-mode))
+(use-package js2-mode
+  :requires (web-mode company-web lsp-mode lsp-ui)
+  :ensure t)
 
-(use-package typescript-ts-mode :ensure nil :defer t)
+(use-package typescript-mode :ensure t)
-
-(add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-ts-mode))
-(add-to-list 'auto-mode-alist '("\\.tsx\\'" . typescript-ts-mode))
-
-(defun icejam-activate-typescript-ts-mode ()
-  "Typescript mode overrides."
-  (icejam-set-indent 2)
-  (eglot-ensure)
-  (column-enforce-n 100))
-
-(add-hook 'typescript-ts-mode-hook 'icejam-activate-typescript-ts-mode)
 
 ;; (use-package vue-mode
 ;;   :ensure t
@@ -34,17 +25,21 @@
 	(icejam-set-indent 2)
 
   (when (not (string-match-p ".json" (buffer-file-name)))
-    (eglot-ensure))
+    (lsp-deferred))
 
 	(column-enforce-n 80)
 	(setq-local js2-basic-offset 2)
   (setq-local js2-strict-missing-semi-warning nil)
+  (setq-local lsp-eldoc-enable-hover nil)
   (setq js2-mode-show-parse-errors nil)
   (setq js2-mode-show-strict-warnings nil)
 
+  (setq-local lsp-eldoc-enable-hover nil)
   (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
 
-  (icejam-set-eglot-capfs))
+  ;; "Company list override."
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'js2-mode-hook 'icejam-activate-js2-mode)
 

lisp/langs/icejam-lang-kotlin.el

@@ -9,25 +9,26 @@
 ;; kotlin does a thing.
 
 ;;; Code:
-(declare-function column-enforce-n 'column-enforce-mode (number))
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package kotlin-ts-mode :ensure t :defer t)
+(use-package kotlin-mode
+	:defer t
+	:ensure t)
 
-(add-to-list 'auto-mode-alist '("\\.kt\\'" . kotlin-ts-mode))
+(use-package gradle-mode
-(add-to-list 'auto-mode-alist '("\\.kts\\'" . kotlin-ts-mode))
+	:defer t
-
+	:ensure t)
-(use-package gradle-mode :defer t :ensure t)
 
 (defun icejam-activate-kotlin-mode ()
   "All things Kotlin."
-  (icejam-set-indent 2)
+  (icejam-set-indent 4)
   (column-enforce-n 100)
-  (eglot-ensure)
+  (lsp)
-  (icejam-set-eglot-capfs))
 
-(add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
+  ;; Company list override
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
+
+(add-hook 'kotlin-mode-hook 'icejam-activate-kotlin-mode)
 
 (provide 'icejam-lang-kotlin)
 ;;; icejam-lang-kotlin.el ends here

lisp/langs/icejam-lang-lean.el

@@ -1,7 +1,9 @@
 ;;; lean -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+
+(require 'icejam-prog-mode)
+(require 'icejam-lsp)
 
 (use-package lean4-mode
   :ensure (lean4-mode
@@ -9,6 +11,7 @@
 	   :host github
 	   :repo "leanprover/lean4-mode"
 	   :files ("*.el" "data"))
+  :requires (lsp)
   :defer t)
 
 (defun icejam-activate-lean-mode ()
@@ -16,12 +19,13 @@
   (interactive)
 
   ;; Run LSP
-  (eglot-ensure)
+  (lsp-deferred)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
-(add-hook 'lean4-mode-hook #'icejam-activate-lean-mode)
+(add-hook 'lean4-mode-hook 'icejam-activate-lean-mode)
 
 (provide 'icejam-lang-lean)
 ;;; icejam-lang-lean.el ends here

lisp/langs/icejam-lang-lua.el

@@ -1,30 +0,0 @@
-;;; icejam-lang-lua.el --- summary -*- lexical-binding: t; -*-
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Commentary:
-
-;; Lua mode
-
-;;; Code:
-(eval-when-compile
-  (declare-function column-enforce-n 'column-enforce-mode (number))
-  (declare-function icejam-set-indent 'icejam-prog-mode)
-  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-  (defvar icejam-language-transient-alist))
-
-(use-package lua-mode :ensure t :defer t)
-
-(defun icejam-activate-lua-mode ()
-  "All things related to Lua."
-  (icejam-set-indent 4)
-  (column-enforce-n 100)
-  (eglot-ensure)
-  (icejam-set-eglot-capfs))
-
-(add-hook 'lua-mode-hook 'icejam-activate-lua-mode)
-
-(provide 'icejam-lang-lua)
-;;; icejam-lang-lua.el ends here

lisp/langs/icejam-lang-markdown.el

@@ -2,36 +2,25 @@
 ;;; Commentary:
 ;;; Code:
 
-(eval-when-compile
+(require 'icejam-prog-mode)
-  (declare-function elpaca-installed-p "elpaca")
+(declare-function elpaca-installed-p "elpacs")
-  (declare-function column-enforce-n 'column-enforce-mode (number))
-  (declare-function icejam-set-indent 'icejam-prog-mode)
-  (declare-function icejam-set-no-eglot-capfs 'icejam-prog-mode)
-  (declare-function rxt--re-builder-switch-pcre-mode "pcre2el"))
-
-;; Markdown is a dependency of LSP mode. By wrapping it in unless we silence
-;; a warning from the byte compiler.
 (unless (elpaca-installed-p 'markdown-mode)
-  (use-package markdown-mode :ensure t :defer t
+  (use-package markdown-mode :ensure t))
-    :commands (markdown-preview)
-    :config
-    ;; Render preview and open it in browser.
-    (keymap-set markdown-mode-map "C-c C-v" #'markdown-preview)
 
-    ;; Render HTML preview with pandoc
+(with-eval-after-load 'markdown-mode
-    (setq-default markdown-command '("pandoc"
+  (setq-default markdown-command "pandoc"))
-                                     "-f"
-                                     "markdown_mmd"
-                                     "-t"
-                                     "html5"
-                                     "--template"
-                                     "github.html5"
-                                     "--highlight-style"
-                                     "pygments"))))
 
 (defun icejam-lang-activate-markdown-mode ()
   "Reconfigure markdown mode for your own purposes."
-  (icejam-set-indent 2))
+  (icejam-set-indent 2)
+  (column-enforce-n 10000)
+
+  ;; Markdown mode reuses my bindings, remove them.
+  (define-key markdown-mode-map (kbd "C-c <left>") nil)
+  (define-key markdown-mode-map (kbd "C-c <right>") nil)
+  (define-key markdown-mode-map (kbd "C-c <up>") nil)
+  (define-key markdown-mode-map (kbd "C-c <down>") nil)
+  (define-key markdown-mode-map (kbd "C-c C-v") 'markdown-preview))
 
 (add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
 (add-hook 'markdown-mode-hook 'display-line-numbers-mode)

lisp/langs/icejam-lang-ocaml.el

@@ -1,12 +1,13 @@
 ;;; ocaml -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(declare-function icejam-set-indent 'icejam-prog-mode)
+
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+(require 'icejam-transient)
-(eval-when-compile (defvar icejam-language-transient-alist))
+(require 'icejam-prog-mode)
+(declare-function lsp "lsp-mode" nil)
 
 (use-package merlin :defer t :ensure t)
-(use-package opam-switch-mode :defer t :ensure t :commands (opam-switch-mode))
+(use-package opam-switch-mode :defer t :ensure t)
 (use-package dune :defer t :ensure t)
 (use-package tuareg :defer t :ensure t)
 
@@ -21,7 +22,7 @@
     ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
    [""
     ("f" "Format"   lsp-format-buffer)
-    ("e" "Errors"   flymake-show-buffer-diagnostics)
+    ("e" "Errors"   flycheck-list-errors)
     ("o" "Opam Env" opam-switch-set-switch)]]
   [""
    ("q" "Quit"      keyboard-quit)])
@@ -47,8 +48,7 @@
   (icejam-set-indent 2)
   (opam-switch-mode t)
   (icejam-load-ocaml-site-packages)
-  (eglot-ensure)
+  (lsp))
-  (icejam-set-eglot-capfs))
 
 (add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)
 

lisp/langs/icejam-lang-other.el

@@ -18,21 +18,22 @@
 (use-package nginx-mode :ensure t :defer t)
 (use-package
   jenkinsfile-mode
-  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git"
+  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git" :branch "master")
-                 :branch "master")
   :defer t)
+(use-package lua-mode :ensure t :defer t)
 
 ;; Graphql schema definition files.
 (use-package graphql-mode :ensure t :defer t
   :mode ("\\.graphqls\\'" . graphql-mode))
 
 ;; Yaml
-(use-package yaml-mode :ensure t :defer t)
+(declare-function lsp "lsp-mode" nil)
+(use-package yaml-mode :ensure t :defer t :requires (lsp))
 
 (with-eval-after-load 'yaml-mode
   (defun icejam-lang-activate-yaml-mode ()
     "Activate yaml-mode."
-    (eglot-ensure))
+    (lsp))
   (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))
 
 ;; Other text files

lisp/langs/icejam-lang-php.el

@@ -9,23 +9,25 @@
 ;; php related settings
 
 ;;; Code:
-(declare-function column-enforce-n 'column-enforce-mode (number))
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(eval-when-compile (defvar icejam-language-transient-alist))
 
-(use-package php-mode :ensure t :defer t)
+(require 'icejam-prog-mode)
+(require 'icejam-flycheck)
+(require 'icejam-transient)
 
-(transient-define-prefix icejam-lang-php-context-menu ()
+(use-package php-mode
+  :requires (lsp-mode lsp-ui)
+  :ensure t)
+
+(transient-define-prefix icejam-lang-php/context-menu ()
   "PHP Buffer Commands."
   [""
    ["LSP"
-    ("m" "iMenu"       consult-imenu)]
+    ("m" "iMenu"       lsp-ui-imenu)]
    ["Buffer"
     ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      eglot-format-buffer)
+    ("f" "Format"      lsp-format-buffer)
     ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+    ("e" "Show Errors" flycheck-list-errors)]]
   [""
    ("q" "Quit"        keyboard-quit)])
 
@@ -35,10 +37,11 @@
   (icejam-set-indent 4)
   (column-enforce-n 80)
 
-  (keymap-set php-mode-map "C-c l" #'icejam-lang-php-context-menu)
+  (define-key php-mode-map (kbd "C-c l") 'icejam-lang-php/context-menu)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'php-mode-hook 'icejam-lang-activate-php-mode)
 

lisp/langs/icejam-lang-purescript.el

@@ -6,17 +6,12 @@
 
 ;;; Commentary:
 
-;; Configuration for purescript.
+;; purescript does a thing.
 
 ;;; Code:
-
+(use-package purescript-mode
-(declare-function column-enforce-n 'column-enforce-mode (number))
+  :requires (lsp-mode lsp-ui)
-(declare-function icejam-set-indent 'icejam-prog-mode)
+  :ensure t)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-
-(use-package purescript-mode :ensure t :defer t)
-
-(declare-function purescript-indentation-mode "purescript-mode")
 
 (defun icejam-activate-purescript-mode ()
   "All things Purescript."
@@ -26,8 +21,9 @@
   ;; Purescript indentation
   (purescript-indentation-mode t)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)
 

lisp/langs/icejam-lang-python.el

@@ -1,24 +1,23 @@
 ;;; python -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(declare-function column-enforce-n "column-enforce-mode" (number))
-(declare-function transient-define-prefix 'transient)
 
-(eval-when-compile
+(require 'icejam-prog-mode)
-  (defvar icejam-language-transient-alist)
+(require 'icejam-transient)
-  (defvar icejam-python-lang-menu))
+
+(declare-function lsp nil)
+(declare-function column-enforce-n "column-enforce-mode" (number))
 
 (transient-define-prefix icejam-python-lang-menu ()
   "Python Buffer Commands."
   [""
    ["LSP"
-    ("m" "iMenu"       consult-imenu)]
+    ("m" "iMenu"       lsp-ui-imenu)]
    ["Buffer"
     ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      eglot-format-buffer)
+    ("f" "Format"      lsp-format-buffer)
     ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+    ("e" "Show Errors" flycheck-list-errors)]]
   [""
    ("q" "Quit"        keyboard-quit)])
 
@@ -28,11 +27,12 @@
 
 (defun icejam-lang-activate-python-mode ()
   "Activate python mode."
-  (eglot-ensure)
+  (lsp)
   (column-enforce-n 99)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)
 

lisp/langs/icejam-lang-ruby.el

@@ -2,11 +2,9 @@
 ;;; Commentary:
 ;;; Code:
 
-(declare-function icejam-set-indent 'icejam-prog-mode)
+(require 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(eval-when-compile (defvar icejam-language-transient-alist))
 
-(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
+(use-package rspec-mode :ensure t :defer t)
 (use-package ruby-end :ensure t :defer t)
 (use-package rbs-mode :ensure t :defer t)
 
@@ -23,10 +21,11 @@
   (setq ruby-insert-encoding-magic-comment nil)
 
   ;; Start LSP
-  (eglot-ensure)
+  (lsp)
 
-  ;; Capf override
+  ;; Company list override
-  (icejam-set-eglot-capfs))
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'ruby-ts-mode-hook 'rspec-mode)
 (add-hook 'ruby-ts-mode-hook 'ruby-end-mode)

lisp/langs/icejam-lang-rust.el

@@ -1,27 +1,19 @@
 ;;; rust -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(eval-when-compile
+
-  (declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-prog-mode)
-  (declare-function icejam-set-indent 'icejam-prog-mode)
-  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
 
 (use-package rust-mode
   :ensure t
   :defer t
-  :config (setopt rust-mode-treesitter-derive t))
+  :config
-
+  (setq rust-mode-treesitter-derive t))
-(use-package rustic
-  :ensure t
-  :defer t
-  :after (rust-mode)
-  :config (setopt rustic-format-on-save nil)
-  (setopt rustic-lsp-client 'eglot))
 
 (use-package flycheck-rust
   :ensure t
   :defer t
-  :after (rust-mode lsp))
+  :requires (rust-mode lsp))
 
 (defun icejam-activate-rust-mode ()
   "All things for Rust mode."
@@ -30,8 +22,11 @@
   (column-enforce-n 99)
 
   ;; Run LSP
-  (eglot-ensure)
+  (lsp-deferred)
-  (icejam-set-eglot-capfs))
+
+  ;; Company list override
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet)))
 
 (add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
 (add-hook 'rust-mode-hook 'flycheck-rust-setup)

lisp/langs/icejam-lang-web.el

@@ -1,7 +1,13 @@
 ;;; web -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(use-package web-mode :ensure t :defer t)
+
+(require 'icejam-lsp)
+(require 'icejam-flycheck)
+
+(use-package web-mode
+  :requires (lsp-mode flycheck)
+  :ensure t)
 
 ;; Eex Web mode
 (add-to-list 'auto-mode-alist '("\\.eex\\'" . web-mode))
@@ -27,8 +33,16 @@
 	(setq-local web-mode-markup-indent-offset 2)
   (setq-local lsp-eldoc-enable-hover nil)
   (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+
+  (add-to-list (make-local-variable 'company-backends)
+               '(company-capf company-yasnippet))
+
+	(when (string-match-p ".jsx" (buffer-file-name))
+		(lsp))
+	(when (string-match-p ".tsx" (buffer-file-name))
+		(lsp))
 	(when (string-match-p ".vue" (buffer-file-name))
-    (eglot-ensure)))
+		(lsp)))
 
 (add-hook 'web-mode-hook 'icejam-activate-web-mode)
 

lisp/langs/icejam-lang-ziglang.el

@@ -9,11 +9,9 @@
 ;; ziglang does a thing.
 
 ;;; Code:
-(declare-function column-enforce-n 'column-enforce-mode (number))
+(require 'icejam-prog-mode)
-(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package zig-mode :ensure t :defer t)
+(use-package zig-mode :ensure t :defer t :requires (lsp))
 
 (defun icejam-activate-zig-mode ()
   "Goodies for editing zig files."
@@ -23,8 +21,7 @@
 
   ;; Set indentation to 4 chars
   (icejam-set-indent 4)
-  (eglot-ensure)
+  (lsp))
-  (icejam-set-eglot-capfs))
 
 (add-hook 'zig-mode-hook 'icejam-activate-zig-mode)
 

lisp/themes/icejam-base16-catppuccin-latte.el

@@ -1,49 +0,0 @@
-;; icejam-base16-catppuccin-latte.el -- A base16 colorscheme
-
-;;; Commentary:
-;; Base16: (https://github.com/tinted-theming/home)
-
-;;; Authors:
-;; Scheme: https://github.com/catppuccin/catppuccin
-;; Template: Kaleb Elwert <belak@coded.io>
-
-;;; Code:
-
-;; Modifications:
-;; 03 darker by 8% #bcc0cc => #aaafbe
-
-(eval-when-compile
-  (declare-function base16-theme-define "base16-theme" (theme-name theme-colors)))
-
-(defvar icejam-base16-catppuccin-latte-theme-colors
-  '(:base00 "#eff1f5"
-            :base01 "#e6e9ef"
-            :base02 "#ccd0da"
-            :base03 "#aaafbe"
-            :base04 "#acb0be"
-            :base05 "#4c4f69"
-            :base06 "#dc8a78"
-            :base07 "#7287fd"
-            :base08 "#d20f39"
-            :base09 "#fe640b"
-            :base0A "#df8e1d"
-            :base0B "#40a02b"
-            :base0C "#179299"
-            :base0D "#1e66f5"
-            :base0E "#8839ef"
-            :base0F "#dd7878")
-  "All colors for Base16 Catppuccin Latte are defined here.")
-
-;; Define the theme
-(deftheme icejam-base16-catppuccin-latte)
-
-;; Add all the faces to the theme
-(with-eval-after-load 'base16-theme
-  (base16-theme-define 'icejam-base16-catppuccin-latte
-                       icejam-base16-catppuccin-latte-theme-colors))
-
-;; Mark the theme as provided
-(provide-theme 'icejam-base16-catppuccin-latte)
-(provide 'icejam-base16-catppuccin-latte)
-
-;;; icejam-base16-catppuccin-latte.el ends here

lisp/themes/icejam-base16-modus-operandi-tinted.el

@@ -1,41 +0,0 @@
-;;; base16-modus-operandi-tinded.el --- summary
-;;; Commentary:
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Code:
-
-(use-package icejam-themes :ensure nil)
-
-(defvar base16-modus-operandi-tinted-colors
-  '(:base00 "#fbf7f0"
-    :base01 "#efe9dd"
-    :base02 "#c9b9b0"
-    :base03 "#595959"
-    :base04 "#595959"
-    :base05 "#000000"
-    :base06 "#193668"
-    :base07 "#193668"
-    :base08 "#a60000"
-    :base09 "#006300"
-    :base0A "#006300"
-    :base0B "#0031a9"
-    :base0C "#721045"
-    :base0D "#00598b"
-    :base0E "#731c52"
-    :base0F "#80601f")
-  "All colors for Base16 Modus Operandi are defined here.")
-
-;; Define the theme
-(deftheme base16-modus-operandi-tinted)
-
-;; Add all the faces to the theme
-(declare-function base16-theme-define 'base16-theme)
-(base16-theme-define 'base16-modus-operandi-tinted base16-modus-operandi-tinted-colors)
-
-;; Mark the theme as provided
-(provide-theme 'base16-modus-operandi-tinted)
-(provide 'icejam-base16-modus-operandi-tinted)
-;;; icejam-base16-modus-operandi-tinted.el ends here

lisp/themes/icejam-base16-not-harmonic.el

@@ -5,7 +5,7 @@
 ;; Based on harmonic-dark theme by Jannik Seibert (https://github.com/janniks)
 ;;; Code:
 
-(use-package icejam-themes :ensure nil)
+(use-package base16-theme :ensure t :defer t)
 
 (defvar base16-not-harmonic-colors
   '(:base00 "#102941"
@@ -30,7 +30,6 @@
 (deftheme base16-not-harmonic)
 
 ;; Add all the faces to the theme
-(declare-function base16-theme-define 'base16-theme)
 (base16-theme-define 'base16-not-harmonic base16-not-harmonic-colors)
 
 ;; Customise things

lisp/themes/icejam-base16-summerfruit-light.el

@@ -7,7 +7,7 @@
 
 ;;; Code:
 
-(use-package icejam-themes :ensure nil)
+(use-package base16-theme :ensure t :defer t)
 
 (defvar base16-summerfruit-light-modified-colors
   '(:base00 "#fdfcfa"
@@ -32,7 +32,6 @@
 (deftheme base16-summerfruit-light-modified)
 
 ;; Add all the faces to the theme
-(declare-function base16-theme-define 'base16-theme)
 (base16-theme-define 'base16-summerfruit-light-modified base16-summerfruit-light-modified-colors)
 
 ;; Mark the theme as provided

snippets/text-mode/dco-signoff

@@ -1,4 +0,0 @@
-# -*- mode: snippet -*-
-# name: dco-signoff
-# --
-Signed-off-by: Maciej Szlosarczyk (${1:maciej@sosek.net})