Compare commits

..

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

61 changed files with 2037 additions and 2335 deletions

View file

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

2
.gitignore vendored
View file

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

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
@ -13,5 +19,6 @@ git clone git@github.com:maciej-szlosarczyk/emacs.git ~/.emacs.d
And then put the following lines into init.el
```emacs
(add-to-list 'load-path (concat user-emacs-directory "lisp"))
(require 'icejam-custom-init)
```

View file

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

File diff suppressed because it is too large Load diff

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

View file

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

View file

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

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

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

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

View file

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

View file

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

View file

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

View file

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

View file

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

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

View file

@ -2,67 +2,28 @@
;;; Commentary:
;;; Code:
;; Use flycheck checks with flymake.
(use-package flymake-flycheck :ensure t :defer t :config
(setq-default
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
;; Use flycheck globally to check syntax and compile languages
(use-package flycheck :ensure t
:custom ((flycheck-emacs-lisp-load-path 'inherit))
:config
;; Show the diagnostics from flymake in a second window (usually on the
;; opposite side from this one) instead of at the bottom of the current one.
;; Essentially revert the interesting part of this commit:
;; https://github.com/emacs-mirror/emacs/commit/419550c7907275bf962986e1cc8fba1989d8659c
(el-patch-feature 'flymake)
(with-eval-after-load 'flymake
(el-patch-defun flymake-show-project-diagnostics ()
"Show a list of Flymake diagnostics for the current project."
(interactive)
(let* ((prj (project-current))
(root (project-root prj))
(buffer (flymake--project-diagnostics-buffer root)))
(with-current-buffer buffer
(flymake-project-diagnostics-mode)
(setq-local flymake--project-diagnostic-list-project prj)
(display-buffer (current-buffer))
(revert-buffer))))
(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)))
(global-flycheck-mode t)
(setopt flycheck-emacs-lisp-load-path 'inherit)
(unbind-key "C-c ! C-c" flycheck-mode-map)
(unbind-key "C-c ! C-w" flycheck-mode-map)
(unbind-key "C-c ! ?" flycheck-mode-map)
(unbind-key "C-c ! C" flycheck-mode-map)
(unbind-key "C-c ! H" flycheck-mode-map)
(unbind-key "C-c ! V" flycheck-mode-map)
(unbind-key "C-c ! c" flycheck-mode-map)
(unbind-key "C-c ! e" flycheck-mode-map)
(unbind-key "C-c ! h" flycheck-mode-map)
(unbind-key "C-c ! i" flycheck-mode-map)
(unbind-key "C-c ! l" flycheck-mode-map)
(unbind-key "C-c ! n" flycheck-mode-map)
(unbind-key "C-c ! p" flycheck-mode-map)
(unbind-key "C-c ! s" flycheck-mode-map)
(unbind-key "C-c ! v" flycheck-mode-map)
(unbind-key "C-c ! x" flycheck-mode-map))
(provide 'icejam-flycheck)
;;; icejam-flycheck.el ends here

View file

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

View file

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

View file

@ -19,47 +19,43 @@
;; Globally enable my minor mode
(icejam-keys-mode)
;;; Helpful key bindings
(define-key icejam-keys-mode-map (kbd "C-c \\") 'split-window-right) ;; Split window to the right
(define-key icejam-keys-mode-map (kbd "C-c /") 'split-window-below) ;; Split window to the bottom
;; Move between windows key bindings
(define-key icejam-keys-mode-map (kbd "C-c <left>") 'windmove-left)
(define-key icejam-keys-mode-map (kbd "C-c <right>") 'windmove-right)
(define-key icejam-keys-mode-map (kbd "C-c <up>") 'windmove-up)
(define-key icejam-keys-mode-map (kbd "C-c <down>") 'windmove-down)
;; The same, but without using arrow keys
(define-key icejam-keys-mode-map (kbd "C-c [") 'windmove-left)
(define-key icejam-keys-mode-map (kbd "C-c ]") 'windmove-right)
(define-key icejam-keys-mode-map (kbd "C-c {") 'windmove-up)
(define-key icejam-keys-mode-map (kbd "C-c }") 'windmove-down)
;; Kill current buffer and window
(define-key icejam-keys-mode-map (kbd "C-c q") 'kill-buffer-and-window)
;; List buffers
(define-key icejam-keys-mode-map (kbd "C-c b") 'ibuffer)
;; Revert without asking
(defun icejam-revert-buffer-no-confirm ()
"Revert buffer without confirmation."
(interactive) (revert-buffer t t))
;; Splitting window
(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)
(define-key icejam-keys-mode-map (kbd "C-c r") 'icejam-revert-buffer-no-confirm)
;; Move between windows
(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
(keymap-set icejam-keys-mode-map "C-c <right>" #'windmove-right)
(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)
;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
(define-key icejam-keys-mode-map [home] 'beginning-of-line)
(define-key icejam-keys-mode-map [end] 'end-of-line)
;;;;;;;;; Translate keys ;;;;;;;;;;;;;;;;;;;;;
(keymap-set key-translation-map "<f6>" "C-c l") ;; On F6, send C-c l
(keymap-set key-translation-map "<f7>" "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 "<f6>") (kbd "C-c l")) ;; On F6, send C-c l
(define-key key-translation-map (kbd "<f7>") (kbd "C-c c")) ;; On F7, send C-c c
(define-key key-translation-map (kbd "<f8>") (kbd "C-c p")) ;; On F8, send C-c p
(provide 'icejam-keys-mode)
;;; icejam-keys-mode.el ends here

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

View file

@ -2,18 +2,17 @@
;;; Commentary:
;;; Code:
(eval-when-compile (defvar icejam-keys-mode-map))
(require 'icejam-keys-mode)
(use-package magit
:ensure t
:commands (magit-blame-quit)
:defer t
:bind (:map icejam-keys-mode-map
("<f5> c" . magit-checkout)
("<f5> b" . magit-blame-addition)
("<f5> g" . magit-status))
(:map magit-blame-mode-map
("<f5> b" . 'magit-blame-quit)))
(:map magit-blame-mode-map
("<f5> b" . 'magit-blame-quit)))
(provide 'icejam-magit)
;;; icejam-magit.el ends here

View file

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

View file

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

View file

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

View file

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

View file

@ -10,27 +10,26 @@
;; community.
;;; Code:
(use-package tree-sitter-langs :ensure t :defer t
:commands tree-sitter-langs--bin-dir
:hook
(elpaca-after-init . (lambda () (add-to-list
'treesit-extra-load-path
(tree-sitter-langs--bin-dir)))))
(defun icejam-tree-sitter-symlink-grammar-objects ()
"Create symlinks for treesitter grammars.
Tree-sitter-langs-build releases grammars as LANG.so. Treesit needs
(use-package tree-sitter-langs :ensure t
:config
(declare-function tree-sitter-langs--bin-dir "tree-sitter-langs")
(add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))
(defun icejam-tree-sitter-symlink-grammar-objects ()
"Create symlinks for treesitter grammars.
Tree-sitter-langs-build releases grammars as LANG.so. Treesit needs
libtree-sitter-LANG.so"
(interactive)
(dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
(concat "\\" (car tree-sitter-load-suffixes) "$")))
;; make symlink (or copy) libtree-sitter-c.so -> c.so
(let ((target (concat (file-name-as-directory (file-name-directory file))
"libtree-sitter-"
(file-name-nondirectory file))))
(if (memq system-type '(ms-dos windows-nt cygwin))
(copy-file file target)
(make-symbolic-link file target)))))
(interactive)
(dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
(concat "\\" (car tree-sitter-load-suffixes) "$")))
;; make symlink (or copy) libtree-sitter-c.so -> c.so
(let ((target (concat (file-name-as-directory (file-name-directory file))
"libtree-sitter-"
(file-name-nondirectory file))))
(if (memq system-type '(ms-dos windows-nt cygwin))
(copy-file file target)
(make-symbolic-link file target))))))
(provide 'icejam-tree-sitter)
;;; icejam-tree-sitter.el ends here

View file

@ -10,11 +10,8 @@
;;; Code:
;; Undo UI
(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)))
;;;;;;;;;;;;;;;;; Use more advanced undo options
(use-package vundo :ensure t :defer t)
(provide 'icejam-vundo)
;;; icejam-vundo.el ends here

View file

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

View file

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

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

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

View file

@ -2,36 +2,25 @@
;;; Commentary:
;;; Code:
(eval-when-compile
(declare-function elpaca-installed-p "elpaca")
(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.
(require 'icejam-prog-mode)
(declare-function elpaca-installed-p "elpacs")
(unless (elpaca-installed-p 'markdown-mode)
(use-package markdown-mode :ensure t :defer t
:commands (markdown-preview)
:config
;; Render preview and open it in browser.
(keymap-set markdown-mode-map "C-c C-v" #'markdown-preview)
(use-package markdown-mode :ensure t))
;; Render HTML preview with pandoc
(setq-default markdown-command '("pandoc"
"-f"
"markdown_mmd"
"-t"
"html5"
"--template"
"github.html5"
"--highlight-style"
"pygments"))))
(with-eval-after-load 'markdown-mode
(setq-default markdown-command "pandoc"))
(defun icejam-lang-activate-markdown-mode ()
"Reconfigure markdown mode for your own purposes."
(icejam-set-indent 2))
(icejam-set-indent 2)
(column-enforce-n 10000)
;; Markdown mode reuses my bindings, remove them.
(define-key markdown-mode-map (kbd "C-c <left>") nil)
(define-key markdown-mode-map (kbd "C-c <right>") nil)
(define-key markdown-mode-map (kbd "C-c <up>") nil)
(define-key markdown-mode-map (kbd "C-c <down>") nil)
(define-key markdown-mode-map (kbd "C-c C-v") 'markdown-preview))
(add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
(add-hook 'markdown-mode-hook 'display-line-numbers-mode)

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -2,11 +2,9 @@
;;; Commentary:
;;; Code:
(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))
(require 'icejam-prog-mode)
(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
(use-package rspec-mode :ensure t :defer t)
(use-package ruby-end :ensure t :defer t)
(use-package rbs-mode :ensure t :defer t)
@ -23,10 +21,11 @@
(setq ruby-insert-encoding-magic-comment nil)
;; Start LSP
(eglot-ensure)
(lsp)
;; Capf override
(icejam-set-eglot-capfs))
;; Company list override
(add-to-list (make-local-variable 'company-backends)
'(company-capf company-yasnippet)))
(add-hook 'ruby-ts-mode-hook 'rspec-mode)
(add-hook 'ruby-ts-mode-hook 'ruby-end-mode)

View file

@ -1,27 +1,19 @@
;;; rust -- summary -*- lexical-binding: t; -*-
;;; Commentary:
;;; 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))
(require 'icejam-prog-mode)
(use-package rust-mode
:ensure t
:defer t
:config (setopt 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))
:config
(setq rust-mode-treesitter-derive t))
(use-package flycheck-rust
:ensure t
:defer t
:after (rust-mode lsp))
:requires (rust-mode lsp))
(defun icejam-activate-rust-mode ()
"All things for Rust mode."
@ -30,8 +22,11 @@
(column-enforce-n 99)
;; Run LSP
(eglot-ensure)
(icejam-set-eglot-capfs))
(lsp-deferred)
;; Company list override
(add-to-list (make-local-variable 'company-backends)
'(company-capf company-yasnippet)))
(add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
(add-hook 'rust-mode-hook 'flycheck-rust-setup)

View file

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

View file

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

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

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

View file

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

View file

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

View file

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