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

Compare commits

base: maciej:main
Branches Tags
maciej:main
maciej:setup-ci-maybe
..
compare: maciej:setup-ci-maybe
Branches Tags
maciej:main
maciej:setup-ci-maybe

No commits in common. "main" and "setup-ci-maybe" have entirely different histories.
main ... setup-ci-m

61 changed files with 2037 additions and 2335 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.forgejo/workflows/demo.yml
View file

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

2
.gitignore vendored
View file

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

13
README.MD
View file

@ -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 ## 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 And then put the following lines into init.el
```emacs ```emacs
(add-to-list 'load-path (concat user-emacs-directory "lisp"))
(require 'icejam-custom-init) (require 'icejam-custom-init)
``` ```

13
early-init.el
View file

@ -17,17 +17,4 @@
;; Log garbage collection. ;; Log garbage collection.
(setq garbage-collection-messages nil) (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 ;;; early-init.el ends here

2010
elpaca.lock
View file

File diff suppressed because it is too large Load diff

81
lisp/icejam-aider.el
View file

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

7
lisp/icejam-avy.el
View file

@ -8,12 +8,11 @@
;; Avy is a navigation manager. ;; Avy is a navigation manager.
(eval-when-compile (defvar icejam-keys-mode-map))
;;; Code: ;;; Code:
(require 'icejam-keys-mode)
(use-package avy :ensure t :defer t (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 :bind (:map icejam-keys-mode-map
;; Jump to text in sight with CMD-j ;; Jump to text in sight with CMD-j
([(hyper j)] . avy-goto-char-timer))) ([(hyper j)] . avy-goto-char-timer)))

87
lisp/icejam-base.el
View file

@ -9,8 +9,11 @@
;; pkg/base defines basic packages and environment. ;; pkg/base defines basic packages and environment.
;;; Code: ;;; Code:
(require 'icejam-keys-mode)
;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;;
;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;; ;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
;; Update emacs less often ;; Update emacs less often
(setopt idle-update-delay 1.0) (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 ;; 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: ;; is an undefined state and suggest this to be just as good:
(setq-default bidi-display-reordering 'left-to-right (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 ;; Reduce rendering/line scan work for Emacs by not rendering cursors or regions
;; in non-focused windows. ;; in non-focused windows.
@ -31,13 +33,9 @@
;; quickly self-correct. ;; quickly self-correct.
(setopt fast-but-imprecise-scrolling t) (setopt fast-but-imprecise-scrolling t)
;; Trust local folder
(setopt trusted-content '("~/.emacs.d/" "~/Development/"))
;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;; ;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;;
(use-package tramp :ensure nil :defer 5 (require 'tramp)
:config (setopt tramp-default-method "ssh")
(setopt tramp-default-method "ssh"))
;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
(global-set-key (kbd "RET") 'newline) (global-set-key (kbd "RET") 'newline)
@ -50,14 +48,12 @@
(use-package buffer-move :ensure t :defer t) (use-package buffer-move :ensure t :defer t)
;; Garbage collection magic hack ;; Garbage collection magic hack
(use-package gcmh :ensure t :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 :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 #============================== ;; #====================== Backup config #==============================
(setopt backup-directory-alist (setopt backup-directory-alist
@ -67,21 +63,17 @@
(setopt backup-by-copying t) (setopt backup-by-copying t)
(setopt delete-old-versions 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) version-control t)
; Do not create .#foo.file lock files ; Do not create .#foo.file lock files
(setopt create-lockfiles nil) (setopt create-lockfiles nil)
;; Enable line numbers and show cursors position ;; 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) ;; (global-display-line-numbers-mode t)
(column-number-mode t) (column-number-mode t)
@ -95,8 +87,7 @@
(setopt large-file-warning-threshold 50000000) (setopt large-file-warning-threshold 50000000)
;; Numbers are arbitrary, but work on a large screen. Default is 160 ;; Numbers are arbitrary, but work on a large screen. Default is 160
(setopt split-width-threshold 190) (setopt split-width-threshold 200)
;;;;;;;;;;;;;;;;;;;;;; Shell stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;; Shell stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on) (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
@ -105,18 +96,18 @@
;; Allow to execute path from shell ;; Allow to execute path from shell
(use-package exec-path-from-shell (use-package exec-path-from-shell
;; :if (memq window-system '(x mac ns)) :if (memq window-system '(x mac ns))
:ensure t :ensure t
:defer t
:hook ((elpaca-after-init . exec-path-from-shell-initialize))
:config :config
(declare-function exec-path-from-shell-initialize "exec-path-from-shell")
(add-to-list 'exec-path "/usr/local/bin") (add-to-list 'exec-path "/usr/local/bin")
(dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE")) (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
(add-to-list 'exec-path-from-shell-variables var))) (add-to-list 'exec-path-from-shell-variables var))
(exec-path-from-shell-initialize))
(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 ;; Draw underline lower
(setopt x-underline-at-descent-line t) (setopt x-underline-at-descent-line t)
@ -128,15 +119,13 @@
indicate-empty-lines nil) indicate-empty-lines nil)
;;;;;;;;;;;;;;;;; Treemacs ;;;;;;;;;;;;;;;;; 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) :commands (treemacs-follow-mode treemacs-project-follow-mode treemacs)
:bind (:map icejam-keys-mode-map :bind (:map icejam-keys-mode-map
([(hyper b)] . treemacs)) ([(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 (use-package treemacs-all-the-icons :ensure t :defer t
:requires (treemacs) :requires (treemacs)
@ -144,20 +133,24 @@
:config (treemacs-load-theme "all-the-icons")) :config (treemacs-load-theme "all-the-icons"))
;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
(use-package keyfreq :ensure t :defer t (use-package keyfreq :ensure t
:hook ((elpaca-after-init . keyfreq-mode)
(elpaca-after-init . keyfreq-autosave-mode))
:config :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 ;;;;;;;;;;;;;;;;; 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 ;;;;;;;;;;;;;;;;; Use C-n to create a new line
(setopt next-line-add-newlines t) (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) (provide 'icejam-base)
;;; icejam-base.el ends here ;;; icejam-base.el ends here

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

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

90
lisp/icejam-company-yasnippet.el Normal file
View file

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

95
lisp/icejam-complete-at-point.el
View file

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

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

@ -2,11 +2,11 @@
;;; Commentary: ;;; Commentary:
;;; ;;;
;;; completing-read is the way of completing things in minibuffer. This module ;;; 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: ;;; Code:
(eval-when-compile (defvar icejam-keys-mode-map))
(require 'icejam-keys-mode)
;; Preparations for using Vertico/Orderless ;; Preparations for using Vertico/Orderless
(setopt (setopt
@ -31,48 +31,30 @@
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode) (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
;; Actual orderless ;; Actual orderless
(use-package vertico :ensure t :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 :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 (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 (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 :bind (:map icejam-keys-mode-map
("C-c t" . find-file) ("C-c t" . find-file)
("M-g g" . consult-goto-line) ("M-g" . consult-goto-line)
("C-c a" . consult-ripgrep))) ("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) (provide 'icejam-completing-read)
;;; icejam-completing-read.el ends here ;;; icejam-completing-read.el ends here

45
lisp/icejam-copilot.el Normal file
View file

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

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

@ -12,23 +12,18 @@
;; Set GC at 500 MB for startup ;; Set GC at 500 MB for startup
(setopt gc-cons-threshold 500000000) (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 ;; Allow for deeper stacktraces / recursion
;; (setopt max-lisp-eval-depth 10000) ;; (setopt max-lisp-eval-depth 10000)
;;; Use elpaca for package management. ;;; 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-directory (expand-file-name "elpaca/" user-emacs-directory))
(defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory)) (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
(defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory)) (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
(defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git" (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")) :files (:defaults "elpaca-test.el" (:exclude "extensions"))
:build (:not elpaca--activate-package))) :build (:not elpaca--activate-package)))
(let* ((repo (expand-file-name "elpaca/" elpaca-repos-directory)) (let* ((repo (expand-file-name "elpaca/" elpaca-repos-directory))
@ -65,85 +60,83 @@
;; Use package settings ;; Use package settings
(setopt use-package-verbose t) (setopt use-package-verbose t)
(setopt use-package-compute-statistics t) (setopt use-package-compute-statistics t)
(elpaca elpaca-use-package
;; Enable use-package :ensure support for Elpaca. ;; Enable use-package :ensure support for Elpaca.
(defvar elpaca-use-package) (elpaca-use-package-mode))
(elpaca elpaca-use-package (elpaca-use-package-mode))
;; (elpaca-load-lockfile (concat user-emacs-directory "elpaca.lock")) (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 () (defun icejam-elpaca-write-lock ()
"Write elpaca lock file." "Write elpaca lock file."
(interactive) (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 ;; I don't know why this needs to be here and with a lisp directory, but
;; normal subdirs.el file doesn't work. ;; 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/themes"))
(add-to-list 'load-path (concat user-emacs-directory "lisp/langs")) (add-to-list 'load-path (concat user-emacs-directory "lisp/langs"))
(defgroup :icejam nil "My customisation group.") (defgroup :icejam nil "My customisation group.")
;; General configuration files. ;; 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 ;; 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. ;; 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 ;; 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) (provide 'icejam-custom-init)
;;; icejam-custom-init.el ends here ;;; icejam-custom-init.el ends here

19
lisp/icejam-dashboard.el
View file

@ -10,20 +10,19 @@
;;; Code: ;;; Code:
(use-package dashboard :ensure t :defer t (use-package dashboard :ensure t :demand t
:commands dashboard-setup-startup-hook :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) ;; (bookmarks . 5)
;; (agenda . 5) ;; (agenda . 5)
;; (registers . 5) ;; (registers . 5)
(projects . 5))) (projects . 5))))
(dashboard-setup-startup-hook)) :config (dashboard-setup-startup-hook))
(provide 'icejam-dashboard) (provide 'icejam-dashboard)
;;; icejam-dashboard.el ends here ;;; icejam-dashboard.el ends here

19
lisp/icejam-deft.el
View file

@ -3,12 +3,15 @@
;;; Notational velocity, backed by OneDrive. ;;; Notational velocity, backed by OneDrive.
;;; Code: ;;; 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 "[\n\t]" ;; blank
"\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
"\\|^Title:.*$" ;; Title string "\\|^Title:.*$" ;; Title string
@ -16,8 +19,8 @@
"\\|^\\[\\[file:.*$" ;; org-mode inline-images "\\|^\\[\\[file:.*$" ;; org-mode inline-images
;; org-mode properties ;; org-mode properties
;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;; ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
"\\)") "\\)"))
deft-auto-save-interval 30.0)) (deft-auto-save-interval 30.0)))
(provide 'icejam-deft) (provide 'icejam-deft)
;;; icejam-deft.el ends here ;;; icejam-deft.el ends here

39
lisp/icejam-diminish.el
View file

@ -6,30 +6,27 @@
;;; Commentary: ;;; Commentary:
;; diminish minor modes to remove modeline litter. ;; diminish minor modes
;;; Code: ;;; 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) (provide 'icejam-diminish)
;;; icejam-diminish.el ends here ;;; icejam-diminish.el ends here

16
lisp/icejam-eglot.el
View file

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

81
lisp/icejam-flycheck.el
View file

@ -2,67 +2,28 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 :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) (provide 'icejam-flycheck)
;;; icejam-flycheck.el ends here ;;; icejam-flycheck.el ends here

179
lisp/icejam-fonts.el
View file

@ -3,11 +3,13 @@
;; Author: Maciej Szlosarczyk ;; Author: Maciej Szlosarczyk
;; Maintainer: Maciej Szlosarczyk ;; Maintainer: Maciej Szlosarczyk
;; Version: 0.1-snapshot ;; Version: 0.1-snapshot
;;; Commentary: ;;; Commentary:
;; Set font stuff ;; Set font stuff
;;; Code: ;;; Code:
;; (defconst icejam-font "Monoid" ;; (defconst icejam-font "Monoid"
;; (defconst icejam-font "Fira Mono" ;; (defconst icejam-font "Fira Mono"
;; (defconst icejam-font "Fira Code" ;; (defconst icejam-font "Fira Code"
@ -16,47 +18,29 @@
;; (defconst icejam-font "Input Mono Condensed" ;; (defconst icejam-font "Input Mono Condensed"
;; (defconst icejam-font "SF Mono" ;; (defconst icejam-font "SF Mono"
;; (defconst icejam-font "Monaco" ;; (defconst icejam-font "Monaco"
;; (defconst icejam-font "JetBrains Mono" "Default font.") ;; (defconst icejam-font "JetBrains Mono"
;; (defconst icejam-font "JuliaMono" ;; (defconst icejam-font "JuliaMono"
;; (defconst icejam-font "Rec Mono Semicasual" ;; (defconst icejam-font "Rec Mono Semicasual"
;; (defconst icejam-font "Victor Mono"
;; (defconst icejam-font "IBM Plex Mono" ;; (defconst icejam-font "IBM Plex Mono"
;; (defconst icejam-font "Berkeley Mono Trial" ;; (defconst icejam-font "Berkeley Mono Trial"
;; (defconst icejam-font "Inconsolata" ;; (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." "Current font, defaults to the one loaded in the beginning."
:type 'string :type 'string
:group 'icejam) :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 :type 'integer
:group 'icejam) :group 'icejam)
@ -65,89 +49,94 @@ in `icejam-set-font-to-screen`.")
(defvar lsp-ui-doc-frame-hook) (defvar lsp-ui-doc-frame-hook)
(defun icejam-set-lsp-ui-font-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) (setopt lsp-ui-doc-frame-hook nil)
(add-hook 'lsp-ui-doc-frame-hook (add-hook 'lsp-ui-doc-frame-hook
(lambda (frame _w) (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 ;; Call LSP-UI hook
(icejam-set-lsp-ui-font-hook)) (icejam-set-lsp-ui-font-hook))
(defun icejam-set-font-to-screen () (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) (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 ;; 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) (provide 'icejam-fonts)
;;; icejam-fonts.el ends here ;;; icejam-fonts.el ends here

10
lisp/icejam-ispell.el
View file

@ -3,10 +3,12 @@
;;; Highlight misspelled words ;;; Highlight misspelled words
;;; Code: ;;; 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 (use-package flyspell :ensure nil
:hook ((prog-mode . flyspell-mode) :hook ((prog-mode . flyspell-mode)

64
lisp/icejam-keys-mode.el
View file

@ -19,47 +19,43 @@
;; Globally enable my minor mode ;; Globally enable my minor mode
(icejam-keys-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 () (defun icejam-revert-buffer-no-confirm ()
"Revert buffer without confirmation." "Revert buffer without confirmation."
(interactive) (revert-buffer t t)) (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 ;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;; 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) (provide 'icejam-keys-mode)
;;; icejam-keys-mode.el ends here ;;; icejam-keys-mode.el ends here

76
lisp/icejam-lsp.el Normal file
View file

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

3
lisp/icejam-magit.el
View file

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

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

@ -12,42 +12,44 @@
(global-eldoc-mode t) (global-eldoc-mode t)
;; Revert tag tables without asking ;; 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 ;;; Show trailing whitespace and remove whitespace on save
(use-package whitespace :ensure nil (use-package whitespace :ensure nil
:custom ((whitespace-style #'(face trailing empty) "New whitespace style.")
(require-final-newline 't "Insert newline on save"))
:hook ((prog-mode . whitespace-mode) :hook ((prog-mode . whitespace-mode)
(text-mode . whitespace-mode) (text-mode . whitespace-mode)
(conf-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) (setq-default indent-tabs-mode nil)
;; Use colorful, matching parens ;; Use colorful, matching parens
;; Rework the code below to enumerate each hook separately: ;; 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) :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 ;;; 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) :hook ((prog-mode . rainbow-mode)
(text-mode . rainbow-mode))) (text-mode . rainbow-mode)))
;; Dash integration ;; 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 '(enh-ruby-mode . "ruby,rubygems,rails"))
(add-to-list 'dash-at-point-mode-alist '(elixir-ts-mode . "elixir,hex"))) (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: ;; Ensure indentation in steps:
(defun icejam-set-indent (step) (defun icejam-set-indent (step)
"Set indentation to STEP." "Set indentation to STEP."
@ -55,25 +57,17 @@
(setq-local tab-width step) (setq-local tab-width step)
(setq-local tab-stop-list (number-sequence step 200 step))) (setq-local tab-stop-list (number-sequence step 200 step)))
;; 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 ;; PCRE to Emacs regex translations
(use-package pcre2el :ensure t :defer 5) (use-package pcre2el :ensure t)
;; Visual regexp ;; 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) (provide 'icejam-prog-mode)
;;; icejam-prog-mode.el ends here ;;; icejam-prog-mode.el ends here

84
lisp/icejam-sys-specific.el
View file

@ -4,15 +4,16 @@
;;; Code: ;;; Code:
(defconst IS-MAC (eq system-type 'darwin)) (defconst IS-MAC (eq system-type 'darwin))
(defconst IS-BSD (eq system-type 'berkeley-unix))
(defconst IS-GNU (eq system-type 'gnu/linux)) (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 () (defun icejam-function-delete-window ()
"Kill a window." "Kill a window."
(interactive) (delete-window)) (interactive) (delete-window))
;; Mac-specific config ;;;;;;;;; Mac-specific config ;;;;;;;;;;;;;;;;;;;;;
(if IS-MAC (if IS-MAC
(progn (progn
(setq mac-option-modifier 'meta) (setq mac-option-modifier 'meta)
@ -29,30 +30,30 @@
(setq mac-option-modifier nil) (setq mac-option-modifier nil)
(setq mac-command-modifier 'meta)))) (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 ;; 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 ;; 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) ;; Disable meta on right alt (useful for Polish characters)
;; (setq mac-right-option-modifier nil) ;; (setq mac-right-option-modifier nil)
;; Allow for fullscreen frames without gaps ;; Allow for fullscreen frames without gaps
(setq frame-resize-pixelwise t))) (setq frame-resize-pixelwise t)
))
(defun icejam-switch-right-left-alt () (defun icejam-switch-right-left-alt ()
"Set keyboard to das keyboard." "Set keyboard to das keyboard."
@ -65,25 +66,42 @@
(setq mac-option-modifier 'meta) (setq mac-option-modifier 'meta)
(setq mac-right-option-modifier nil)))) (setq mac-right-option-modifier nil))))
;; Linux-specific config ;;;;;;;;; Linux-specific config ;;;;;;;;;;;;;;;;;;;;;
(if IS-GNU (if IS-GNU
(progn (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) (provide 'icejam-sys-specific)
;;; icejam-sys-specific.el ends here ;;; icejam-sys-specific.el ends here

34
lisp/icejam-themes.el
View file

@ -3,20 +3,31 @@
;;; Code: ;;; Code:
(use-package spaceline :ensure t (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 ;; (use-package apropospriate-theme :ensure t
;; :config (load-theme 'apropospriate-light t t)) ;; :config (load-theme 'apropospriate-light t t))
;; (use-package leuven-theme :ensure t ;; (use-package leuven-theme :ensure t
;; :config ;; :config
;; (load-theme 'leuven t t)) ;; (load-theme 'leuven t t))
(use-package modus-themes :ensure t) ;; (use-package modus-themes :ensure t )
;; (use-package darktooth-theme :ensure t ;; (use-package darktooth-theme :ensure t
;; :config ;; :config
;; (load-theme 'darktooth t t)) ;; (load-theme 'darktooth t t))
@ -32,7 +43,6 @@
;; (use-package zenburn-theme :ensure t ;; (use-package zenburn-theme :ensure t
;; :config ;; :config
;; (load-theme 'zenburn t t)) ;; (load-theme 'zenburn t t))
;; (use-package catppuccin-theme :ensure t ;; (use-package catppuccin-theme :ensure t
;; :custom ;; :custom
;; ((catpuccin-flavor 'frappe)) ;; ((catpuccin-flavor 'frappe))
@ -42,19 +52,11 @@
;; Disable cursor blinking ;; Disable cursor blinking
(blink-cursor-mode 0) (blink-cursor-mode 0)
;; Scroll with the trackpad smoothly
(pixel-scroll-precision-mode 1)
;; My own theme modifications: ;; My own theme modifications:
(with-eval-after-load 'base16-theme (with-eval-after-load 'base16-theme
(setopt base16-theme-256-color-source 'colors) (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-zenburn)
(require 'icejam-base16-harmonic-light) (require 'icejam-base16-harmonic-light)
(require 'icejam-base16-catppuccin-latte)
(if (memq window-system '(x mac ns)) (if (memq window-system '(x mac ns))
(enable-theme 'icejam-base16-zenburn) (enable-theme 'icejam-base16-zenburn)

183
lisp/icejam-transient.el
View file

@ -2,9 +2,11 @@
;;; Commentary: ;;; Commentary:
;;; Global Transient definitions. ;;; Global Transient definitions.
;;; Code: ;;; 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 () (defun icejam-mark-and-indent-whole-buffer ()
"Mark and indent whole buffer." "Mark and indent whole buffer."
@ -13,116 +15,100 @@
(transient-define-prefix icejam-project-menu () (transient-define-prefix icejam-project-menu ()
"Project Commands." "Project Commands."
[["Project" [""
["Project"
("s" "Switch project" project-switch-project) ("s" "Switch project" project-switch-project)
("f" "Find file in project" project-find-file) ("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" ["Magit"
("m" "Git status" magit-status) ("m" "Git status" magit-status)
("C" "Git checkout" magit-checkout) ("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) ("i" "IELM" ielm)
("B" "iBuffer" ibuffer)
("e" "eval-region" eval-region)] ("e" "eval-region" eval-region)]
["Other" ["Other"
("d" "deft" deft) ("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 () (transient-define-prefix icejam-code-menu ()
"Code Commands." "Code Commands."
[["Manipulate" [""
["Manipulate"
("c" "Toggle Comment" comment-line) ("c" "Toggle Comment" comment-line)
("r" "Replace" vr/replace) ("r" "Replace" vr/replace)
("i" "Indent" indent-region)]] ("i" "Indent" indent-region)]
[["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) ("s" "Swiper" consult-line)
("u" "Vundo" vundo) ("u" "Vundo" vundo)
("d" "Dash" dash-at-point)]]) ("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" ["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 () (transient-define-prefix icejam-language-menu ()
"Language (Buffer) Commands." "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 (defcustom icejam-language-transient-alist
'() '()
@ -143,24 +129,13 @@ You can pass MAYBE-MODE to find mode explicitly."
(interactive) (interactive)
(funcall (icejam-language-transient-for-mode))) (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) (provide 'icejam-transient)
;;; icejam-transient.el ends here ;;; icejam-transient.el ends here

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

@ -10,12 +10,11 @@
;; community. ;; community.
;;; Code: ;;; Code:
(use-package tree-sitter-langs :ensure t :defer t
:commands tree-sitter-langs--bin-dir (use-package tree-sitter-langs :ensure t
:hook :config
(elpaca-after-init . (lambda () (add-to-list (declare-function tree-sitter-langs--bin-dir "tree-sitter-langs")
'treesit-extra-load-path (add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))
(tree-sitter-langs--bin-dir)))))
(defun icejam-tree-sitter-symlink-grammar-objects () (defun icejam-tree-sitter-symlink-grammar-objects ()
"Create symlinks for treesitter grammars. "Create symlinks for treesitter grammars.
@ -30,7 +29,7 @@ libtree-sitter-LANG.so"
(file-name-nondirectory file)))) (file-name-nondirectory file))))
(if (memq system-type '(ms-dos windows-nt cygwin)) (if (memq system-type '(ms-dos windows-nt cygwin))
(copy-file file target) (copy-file file target)
(make-symbolic-link file target))))) (make-symbolic-link file target))))))
(provide 'icejam-tree-sitter) (provide 'icejam-tree-sitter)
;;; icejam-tree-sitter.el ends here ;;; icejam-tree-sitter.el ends here

7
lisp/icejam-vundo.el
View file

@ -10,11 +10,8 @@
;;; Code: ;;; 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) (provide 'icejam-vundo)
;;; icejam-vundo.el ends here ;;; icejam-vundo.el ends here

7
lisp/langs/icejam-lang-clang.el
View file

@ -2,6 +2,8 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; Code:
(require 'icejam-prog-mode)
(declare-function column-enforce-n "column-enforce-mode" (number)) (declare-function column-enforce-n "column-enforce-mode" (number))
(defun icejam-lang-activate-clang-mode () (defun icejam-lang-activate-clang-mode ()
@ -17,7 +19,10 @@
(if (boundp 'c-default-style) (if (boundp 'c-default-style)
(setq-local c-default-style "bsd") (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) (add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)

14
lisp/langs/icejam-lang-clojure.el
View file

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

22
lisp/langs/icejam-lang-common-lisp.el Normal file
View file

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

5
lisp/langs/icejam-lang-dart.el
View file

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

8
lisp/langs/icejam-lang-dhall.el
View file

@ -2,12 +2,14 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 () (defun icejam-lang-activate-dhall-mode ()
"Reconfigure dhall mode for your own purposes." "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 'icejam-lang-activate-dhall-mode)
(add-hook 'dhall-mode-hook 'display-line-numbers-mode) (add-hook 'dhall-mode-hook 'display-line-numbers-mode)

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

@ -2,26 +2,43 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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)) (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)])
(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 () (defun icejam-activate-emacs-lisp-mode ()
"Goodies for editing Emacs files." "Goodies for editing Emacs files."
(icejam-set-indent 2) ;; Default indentation of 2 characters (icejam-set-indent 2) ;; Default indentation of 2 characters
(column-enforce-n 80) ;; 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) (provide 'icejam-lang-elisp)
;;; icejam-lang-elisp.el ends here ;;; icejam-lang-elisp.el ends here

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

@ -2,40 +2,32 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 () (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 (add-to-list
'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu)) 'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu))
@ -44,27 +36,21 @@
"All things Elixir." "All things Elixir."
(icejam-set-indent 2) (icejam-set-indent 2)
(column-enforce-n 98) (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 ;; If needed, switch the one below to false to disable documentation pop-ups
;; (setq-local lsp-ui-doc-enable t) ;; (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 'heex-ts-mode-hook 'icejam-activate-elixir-ts-mode)
(add-hook 'elixir-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) (provide 'icejam-lang-elixir)
;;; icejam-lang-elixir.el ends here ;;; icejam-lang-elixir.el ends here

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

@ -2,22 +2,85 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 () (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) (icejam-set-indent 4)
(column-enforce-n 80) (column-enforce-n 80)
;; Start LSP ;; 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) (add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)

18
lisp/langs/icejam-lang-fsharp.el
View file

@ -9,20 +9,24 @@
;; Fsharp configuration ;; Fsharp configuration
;;; Code: ;;; 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 () (defun icejam-activate-fsharp-mode ()
"Activate F# goodies." "Activate F# goodies."
(icejam-set-indent 4) (icejam-set-indent 4)
(column-enforce-n 100) (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) (add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)

19
lisp/langs/icejam-lang-gleam.el
View file

@ -9,23 +9,24 @@
;; Gleam language support ;; Gleam language support
;;; Code: ;;; 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 () (defun icejam-lang-activate-gleam-mode ()
"All things Gleam." "All things Gleam."
(icejam-set-indent 2) (icejam-set-indent 2)
(column-enforce-n 100) (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) (provide 'icejam-lang-gleam)
;;; icejam-lang-gleam.el ends here ;;; icejam-lang-gleam.el ends here

15
lisp/langs/icejam-lang-golang.el
View file

@ -9,20 +9,21 @@
;; golang mode stuff ;; golang mode stuff
;;; Code: ;;; 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 () (defun icejam-activate-golang-mode ()
"Activate my own Golang mode settings." "Activate my own Golang mode settings."
(icejam-set-indent 8) (icejam-set-indent 8)
(column-enforce-n 100) (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) (provide 'icejam-lang-golang)
;;; icejam-lang-golang.el ends here ;;; icejam-lang-golang.el ends here

22
lisp/langs/icejam-lang-haskell.el
View file

@ -10,20 +10,26 @@
;;; Code: ;;; 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 () (defun icejam-activate-haskell-mode ()
"Run this in `haskell-mode'." "Run this in haskell-mode."
(icejam-set-indent 2) (icejam-set-indent 2)
(column-enforce-n 80) (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) (add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)

31
lisp/langs/icejam-lang-javascript.el
View file

@ -2,24 +2,15 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 ;; (use-package vue-mode
;; :ensure t ;; :ensure t
@ -34,17 +25,21 @@
(icejam-set-indent 2) (icejam-set-indent 2)
(when (not (string-match-p ".json" (buffer-file-name))) (when (not (string-match-p ".json" (buffer-file-name)))
(eglot-ensure)) (lsp-deferred))
(column-enforce-n 80) (column-enforce-n 80)
(setq-local js2-basic-offset 2) (setq-local js2-basic-offset 2)
(setq-local js2-strict-missing-semi-warning nil) (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-parse-errors nil)
(setq js2-mode-show-strict-warnings nil) (setq js2-mode-show-strict-warnings nil)
(setq-local lsp-eldoc-enable-hover nil)
(setq-local flycheck-check-syntax-automatically '(save mode-enabled)) (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) (add-hook 'js2-mode-hook 'icejam-activate-js2-mode)

25
lisp/langs/icejam-lang-kotlin.el
View file

@ -9,25 +9,26 @@
;; kotlin does a thing. ;; kotlin does a thing.
;;; Code: ;;; 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 () (defun icejam-activate-kotlin-mode ()
"All things Kotlin." "All things Kotlin."
(icejam-set-indent 2) (icejam-set-indent 4)
(column-enforce-n 100) (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) (provide 'icejam-lang-kotlin)
;;; icejam-lang-kotlin.el ends here ;;; icejam-lang-kotlin.el ends here

14
lisp/langs/icejam-lang-lean.el
View file

@ -1,7 +1,9 @@
;;; lean -- summary -*- lexical-binding: t; -*- ;;; lean -- summary -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; Code: ;;; Code:
(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
(require 'icejam-prog-mode)
(require 'icejam-lsp)
(use-package lean4-mode (use-package lean4-mode
:ensure (lean4-mode :ensure (lean4-mode
@ -9,6 +11,7 @@
:host github :host github
:repo "leanprover/lean4-mode" :repo "leanprover/lean4-mode"
:files ("*.el" "data")) :files ("*.el" "data"))
:requires (lsp)
:defer t) :defer t)
(defun icejam-activate-lean-mode () (defun icejam-activate-lean-mode ()
@ -16,12 +19,13 @@
(interactive) (interactive)
;; Run LSP ;; 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) (provide 'icejam-lang-lean)
;;; icejam-lang-lean.el ends here ;;; icejam-lang-lean.el ends here

30
lisp/langs/icejam-lang-lua.el
View file

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

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

@ -2,36 +2,25 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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) (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 () (defun icejam-lang-activate-markdown-mode ()
"Reconfigure markdown mode for your own purposes." "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 'icejam-lang-activate-markdown-mode)
(add-hook 'markdown-mode-hook 'display-line-numbers-mode) (add-hook 'markdown-mode-hook 'display-line-numbers-mode)

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

@ -1,12 +1,13 @@
;;; ocaml -- summary -*- lexical-binding: t; -*- ;;; ocaml -- summary -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 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 dune :defer t :ensure t)
(use-package tuareg :defer t :ensure t) (use-package tuareg :defer t :ensure t)
@ -21,7 +22,7 @@
("i" "Indent" icejam-mark-and-indent-whole-buffer)] ("i" "Indent" icejam-mark-and-indent-whole-buffer)]
["" [""
("f" "Format" lsp-format-buffer) ("f" "Format" lsp-format-buffer)
("e" "Errors" flymake-show-buffer-diagnostics) ("e" "Errors" flycheck-list-errors)
("o" "Opam Env" opam-switch-set-switch)]] ("o" "Opam Env" opam-switch-set-switch)]]
["" [""
("q" "Quit" keyboard-quit)]) ("q" "Quit" keyboard-quit)])
@ -47,8 +48,7 @@
(icejam-set-indent 2) (icejam-set-indent 2)
(opam-switch-mode t) (opam-switch-mode t)
(icejam-load-ocaml-site-packages) (icejam-load-ocaml-site-packages)
(eglot-ensure) (lsp))
(icejam-set-eglot-capfs))
(add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode) (add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)

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

@ -18,21 +18,22 @@
(use-package nginx-mode :ensure t :defer t) (use-package nginx-mode :ensure t :defer t)
(use-package (use-package
jenkinsfile-mode 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) :defer t)
(use-package lua-mode :ensure t :defer t)
;; Graphql schema definition files. ;; Graphql schema definition files.
(use-package graphql-mode :ensure t :defer t (use-package graphql-mode :ensure t :defer t
:mode ("\\.graphqls\\'" . graphql-mode)) :mode ("\\.graphqls\\'" . graphql-mode))
;; Yaml ;; 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 (with-eval-after-load 'yaml-mode
(defun icejam-lang-activate-yaml-mode () (defun icejam-lang-activate-yaml-mode ()
"Activate yaml-mode." "Activate yaml-mode."
(eglot-ensure)) (lsp))
(add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode)) (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))
;; Other text files ;; Other text files

27
lisp/langs/icejam-lang-php.el
View file

@ -9,23 +9,25 @@
;; php related settings ;; php related settings
;;; Code: ;;; 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." "PHP Buffer Commands."
["" [""
["LSP" ["LSP"
("m" "iMenu" consult-imenu)] ("m" "iMenu" lsp-ui-imenu)]
["Buffer" ["Buffer"
("r" "Reload" icejam-revert-buffer-no-confirm) ("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) ("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)]) ("q" "Quit" keyboard-quit)])
@ -35,10 +37,11 @@
(icejam-set-indent 4) (icejam-set-indent 4)
(column-enforce-n 80) (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) (add-hook 'php-mode-hook 'icejam-lang-activate-php-mode)

18
lisp/langs/icejam-lang-purescript.el
View file

@ -6,17 +6,12 @@
;;; Commentary: ;;; Commentary:
;; Configuration for purescript. ;; purescript does a thing.
;;; Code: ;;; 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 () (defun icejam-activate-purescript-mode ()
"All things Purescript." "All things Purescript."
@ -26,8 +21,9 @@
;; Purescript indentation ;; Purescript indentation
(purescript-indentation-mode t) (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) (add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)

24
lisp/langs/icejam-lang-python.el
View file

@ -1,24 +1,23 @@
;;; python -- summary -*- lexical-binding: t; -*- ;;; python -- summary -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 () (transient-define-prefix icejam-python-lang-menu ()
"Python Buffer Commands." "Python Buffer Commands."
["" [""
["LSP" ["LSP"
("m" "iMenu" consult-imenu)] ("m" "iMenu" lsp-ui-imenu)]
["Buffer" ["Buffer"
("r" "Reload" icejam-revert-buffer-no-confirm) ("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) ("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)]) ("q" "Quit" keyboard-quit)])
@ -28,11 +27,12 @@
(defun icejam-lang-activate-python-mode () (defun icejam-lang-activate-python-mode ()
"Activate python mode." "Activate python mode."
(eglot-ensure) (lsp)
(column-enforce-n 99) (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) (add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)

13
lisp/langs/icejam-lang-ruby.el
View file

@ -2,11 +2,9 @@
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 ruby-end :ensure t :defer t)
(use-package rbs-mode :ensure t :defer t) (use-package rbs-mode :ensure t :defer t)
@ -23,10 +21,11 @@
(setq ruby-insert-encoding-magic-comment nil) (setq ruby-insert-encoding-magic-comment nil)
;; Start LSP ;; 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 'rspec-mode)
(add-hook 'ruby-ts-mode-hook 'ruby-end-mode) (add-hook 'ruby-ts-mode-hook 'ruby-end-mode)

25
lisp/langs/icejam-lang-rust.el
View file

@ -1,27 +1,19 @@
;;; rust -- summary -*- lexical-binding: t; -*- ;;; rust -- summary -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 (use-package rust-mode
:ensure t :ensure t
:defer 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 (use-package flycheck-rust
:ensure t :ensure t
:defer t :defer t
:after (rust-mode lsp)) :requires (rust-mode lsp))
(defun icejam-activate-rust-mode () (defun icejam-activate-rust-mode ()
"All things for Rust mode." "All things for Rust mode."
@ -30,8 +22,11 @@
(column-enforce-n 99) (column-enforce-n 99)
;; Run LSP ;; 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 'icejam-activate-rust-mode)
(add-hook 'rust-mode-hook 'flycheck-rust-setup) (add-hook 'rust-mode-hook 'flycheck-rust-setup)

18
lisp/langs/icejam-lang-web.el
View file

@ -1,7 +1,13 @@
;;; web -- summary -*- lexical-binding: t; -*- ;;; web -- summary -*- lexical-binding: t; -*-
;;; Commentary: ;;; Commentary:
;;; Code: ;;; 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 ;; Eex Web mode
(add-to-list 'auto-mode-alist '("\\.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 web-mode-markup-indent-offset 2)
(setq-local lsp-eldoc-enable-hover nil) (setq-local lsp-eldoc-enable-hover nil)
(setq-local flycheck-check-syntax-automatically '(save mode-enabled)) (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)) (when (string-match-p ".vue" (buffer-file-name))
(eglot-ensure))) (lsp)))
(add-hook 'web-mode-hook 'icejam-activate-web-mode) (add-hook 'web-mode-hook 'icejam-activate-web-mode)

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

@ -9,11 +9,9 @@
;; ziglang does a thing. ;; ziglang does a thing.
;;; Code: ;;; 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 () (defun icejam-activate-zig-mode ()
"Goodies for editing zig files." "Goodies for editing zig files."
@ -23,8 +21,7 @@
;; Set indentation to 4 chars ;; Set indentation to 4 chars
(icejam-set-indent 4) (icejam-set-indent 4)
(eglot-ensure) (lsp))
(icejam-set-eglot-capfs))
(add-hook 'zig-mode-hook 'icejam-activate-zig-mode) (add-hook 'zig-mode-hook 'icejam-activate-zig-mode)

49
lisp/themes/icejam-base16-catppuccin-latte.el
View file

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

41
lisp/themes/icejam-base16-modus-operandi-tinted.el
View file

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

3
lisp/themes/icejam-base16-not-harmonic.el
View file

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

3
lisp/themes/icejam-base16-summerfruit-light.el
View file

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

4
snippets/text-mode/dco-signoff
View file

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