Move some stuff

user-lisp/langs/icejam-lang-clang.el

@@ -0,0 +1,25 @@
+;;; languages/clang.el --- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(declare-function column-enforce-n "column-enforce-mode" (number))
+
+(defun icejam-lang-activate-clang-mode ()
+  "Goodies for editing c files."
+
+  ;; Set column width to 100
+  (column-enforce-n 100)
+
+  ;; Set indentation to 4 chars
+  (if (boundp 'c-basic-offset)
+      (setq-local c-basic-offset 4)
+    (defvar c-basic-offset 4))
+
+  (if (boundp 'c-default-style)
+      (setq-local c-default-style "bsd")
+    (defvar c-default-style "bsd")))
+
+(add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)
+
+(provide 'icejam-lang-clang)
+;;; icejam-lang-clang.el ends here

user-lisp/langs/icejam-lang-clojure.el

@@ -0,0 +1,70 @@
+;;; icejam-lang-clojure.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-clojure-lang-menu)
+  (defvar cider-annotate-completion-function)
+  (defvar cider-show-error-buffer)
+  (declare-function column-enforce-n "column-enforce-mode" (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-start-eglot 'icejam-eglot)
+  (declare-function transient-define-prefix 'transient))
+
+(use-package clojure-mode :defer t :ensure t)
+
+(use-package cider
+  :requires clojure-mode
+  :commands (cider-mode cider-jack-in)
+  :defer t
+  :ensure t
+  :config (setq cider-annotate-completion-function t))
+
+(use-package clj-refactor
+	:requires (cider clojure-mode)
+	:defer t
+	:ensure t)
+
+;; Transient
+(transient-define-prefix icejam-clojure-lang-menu ()
+  "Clojure Buffer Commands."
+  [""
+   ["Cider"
+    ("j" "Jack in"     cider-jack-in)
+    ("t" "Test"        cider-test-run-loaded-tests)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      cider-format-buffer)
+    ("l" "Load"        cider-load-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q"  "Quit"        keyboard-quit)])
+
+(add-to-list
+ 'icejam-language-transient-alist '(clojure-mode . icejam-clojure-lang-menu))
+
+(defun icejam-lang-activate-clojure-mode ()
+  "Goodies for clojure files."
+  (icejam-set-indent 2) ;; Default indentation of 2 characters
+  (column-enforce-n 80)
+  (cider-mode 1)
+
+  (icejam-start-eglot)
+
+  ;; Do not enable paredit for clojure
+  ;; (paredit-mode 1)
+	;; Do not show separate error window when in REPL
+  (setq cider-show-error-buffer 'except-in-repl))
+
+(add-hook 'clojure-mode-hook 'icejam-lang-activate-clojure-mode)
+
+(defun icejam-lang-clojure-repl-config ()
+  "Do not show stacktrace when in REPL."
+	(setq-local cider-show-error-buffer 'except-in-repl))
+
+(add-hook 'cider-repl-mode-hook 'icejam-lang-clojure-repl-config)
+(add-hook 'cider-mode-hook 'cider-enable-flex-completion)
+
+(provide 'icejam-lang-clojure)
+;;; icejam-lang-clojure.el ends here

user-lisp/langs/icejam-lang-dart.el

@@ -0,0 +1,14 @@
+;;; dart -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package dart-mode :ensure t :defer t)
+
+(defun icejam-lang-activate-dart-mode ()
+  "Reconfigure dart mode for your own purposes."
+  (eglot-ensure))
+
+(add-hook 'dart-mode-hook 'icejam-lang-activate-dart-mode)
+
+(provide 'icejam-lang-dart)
+;;; icejam-lang-dart.el ends here

user-lisp/langs/icejam-lang-dhall.el

@@ -0,0 +1,19 @@
+;;; dhall -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package dhall-mode :ensure t :defer t)
+
+(eval-when-compile
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(defun icejam-lang-activate-dhall-mode ()
+  "Reconfigure dhall mode for your own purposes."
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'dhall-mode-hook 'icejam-lang-activate-dhall-mode)
+(add-hook 'dhall-mode-hook 'display-line-numbers-mode)
+
+(provide 'icejam-lang-dhall)
+;;; icejam-lang-dhall.el ends here

user-lisp/langs/icejam-lang-elisp.el

@@ -0,0 +1,27 @@
+;;; languages/elisp -- summary -*- lexical-binding: t; -*-
+;;; 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))
+
+(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)
+
+(defun icejam-activate-emacs-lisp-mode ()
+  "Goodies for editing Emacs files."
+
+  (icejam-set-indent 2) ;; Default indentation of 2 characters
+  (column-enforce-n 80) ;; Use 80 char limit.
+  (lispy-mode t)        ;; Modal editing for Lisp
+  (icejam-set-elisp-capfs))
+
+(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
+(add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)
+
+(provide 'icejam-lang-elisp)
+;;; icejam-lang-elisp.el ends here

user-lisp/langs/icejam-lang-elixir.el

@@ -0,0 +1,68 @@
+;;; languages/elixir -- summary -*- lexical-binding: t; -*-
+;;; 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)
+  (declare-function icejam-start-eglot 'icejam-eglot)
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-elixir-lang-menu)
+  (defvar apheleia-mode-alist))
+
+(use-package elixir-ts-mode :ensure t :defer t :after (apheleia)
+  :config
+  (add-to-list 'apheleia-mode-alist '(heex-ts-mode . mix-format)))
+
+(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")))
+
+(add-to-list
+ 'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu))
+
+(defun icejam-activate-elixir-ts-mode ()
+  "All things Elixir."
+  (icejam-set-indent 2)
+  (column-enforce-n 98)
+  (icejam-set-eglot-capfs)
+  (icejam-start-eglot)
+  (icejam-delete-elixir-snippets))
+
+(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

user-lisp/langs/icejam-lang-erlang.el

@@ -0,0 +1,25 @@
+;;; languages/erlang -- summary -*- lexical-binding: t; -*-
+;;; 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)
+
+(use-package erlang :defer t :ensure (:depth 1))
+
+(defun icejam-activate-erlang-mode ()
+  "Start Erlang related editing process."
+  (icejam-set-indent 4)
+  (column-enforce-n 80)
+
+  ;; Start LSP
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)
+
+(provide 'icejam-lang-erlang)
+;;; icejam-lang-erlang.el ends here

user-lisp/langs/icejam-lang-fsharp.el

@@ -0,0 +1,31 @@
+;;; fsharp.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Fsharp configuration
+
+;;; Code:
+(eval-when-compile
+  (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)
+
+(defun icejam-activate-fsharp-mode ()
+  "Activate F# goodies."
+  (icejam-set-indent 4)
+  (column-enforce-n 100)
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)
+
+(provide 'icejam-lang-fsharp)
+;;; icejam-lang-fsharp.el ends here

user-lisp/langs/icejam-lang-gleam.el

@@ -0,0 +1,31 @@
+;;; gleam.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Gleam language support
+
+;;; 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))
+
+(use-package gleam-ts-mode :defer t :ensure t :mode (rx ".gleam" eos))
+
+;; (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)
+  (icejam-start-eglot)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'gleam-ts-mode-hook 'icejam-lang-activate-gleam-mode)
+
+(provide 'icejam-lang-gleam)
+;;; icejam-lang-gleam.el ends here

user-lisp/langs/icejam-lang-golang.el

@@ -0,0 +1,29 @@
+;;; icejam-lang-golang.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; golang mode stuff
+
+;;; 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))
+
+(use-package go-mode :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))
+
+(add-hook 'go-mode-hook #'icejam-activate-golang-mode)
+
+(provide 'icejam-lang-golang)
+;;; icejam-lang-golang.el ends here

user-lisp/langs/icejam-lang-haskell.el

@@ -0,0 +1,32 @@
+;;; haskell.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Provides configuration for haskell files
+
+;;; 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))
+
+(use-package haskell-mode :ensure t :defer t)
+
+(defun icejam-activate-haskell-mode ()
+  "Run this in `haskell-mode'."
+  (icejam-set-indent 2)
+  (column-enforce-n 80)
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)
+
+(provide 'icejam-lang-haskell)
+;;; icejam-lang-haskell.el ends here

user-lisp/langs/icejam-lang-java.el

@@ -0,0 +1,25 @@
+;;; java -- 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))
+
+(add-to-list 'auto-mode-alist '("\\.java\\'" . java-ts-mode))
+
+;; (use-package eglot-java :ensure t)
+
+(defun icejam-activate-java-mode ()
+	"Java mode overrides."
+	(icejam-set-indent 2)
+  (eglot-ensure)
+  (column-enforce-n 80)
+  (icejam-set-eglot-capfs))
+
+;; (add-hook 'java-ts-mode-hook 'eglot-java-mode)
+(add-hook 'java-ts-mode-hook 'icejam-activate-java-mode)
+
+(provide 'icejam-lang-java)
+;;; icejam-lang-java.el ends here

user-lisp/langs/icejam-lang-javascript.el

@@ -0,0 +1,53 @@
+;;; javascript -- 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))
+
+(use-package js2-mode :ensure t :defer t :after(web-mode))
+
+(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 vue-mode
+;;   :ensure t
+;;   :defer t)
+
+;; Use js2-mode for javascript editing
+(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
+(add-to-list 'auto-mode-alist '("\\.json\\'" . js2-mode))
+
+(defun icejam-activate-js2-mode ()
+	"JS2 mode overrides."
+	(icejam-set-indent 2)
+
+  (when (not (string-match-p ".json" (buffer-file-name)))
+    (eglot-ensure))
+
+	(column-enforce-n 80)
+	(setq-local js2-basic-offset 2)
+  (setq-local js2-strict-missing-semi-warning nil)
+  (setq js2-mode-show-parse-errors nil)
+  (setq js2-mode-show-strict-warnings nil)
+
+  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+
+  (icejam-set-eglot-capfs))
+
+(add-hook 'js2-mode-hook 'icejam-activate-js2-mode)
+
+(provide 'icejam-lang-javascript)
+;;; icejam-lang-javascript.el ends here

user-lisp/langs/icejam-lang-kotlin.el

@@ -0,0 +1,34 @@
+;;; kotlin.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; kotlin does a thing.
+
+;;; 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))
+
+(use-package kotlin-ts-mode :ensure t :defer 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)
+
+(defun icejam-activate-kotlin-mode ()
+  "All things Kotlin."
+  (icejam-set-indent 2)
+  (column-enforce-n 100)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
+
+(provide 'icejam-lang-kotlin)
+;;; icejam-lang-kotlin.el ends here

user-lisp/langs/icejam-lang-lua.el

@@ -0,0 +1,30 @@
+;;; 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

user-lisp/langs/icejam-lang-markdown.el

@@ -0,0 +1,38 @@
+;;; markdown -- summary -*- lexical-binding: t; -*-
+;;; 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"))
+
+(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)
+
+  ;; Render HTML preview with pandoc
+  (setq-default markdown-command '("pandoc"
+                                   "-f"
+                                   "markdown_mmd"
+                                   "-t"
+                                   "html5"
+                                   "--template"
+                                   "github.html5"
+                                   "--highlight-style"
+                                   "pygments")))
+
+
+(defun icejam-lang-activate-markdown-mode ()
+  "Reconfigure markdown mode for your own purposes."
+  (icejam-set-indent 2))
+
+(add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
+(add-hook 'markdown-mode-hook 'display-line-numbers-mode)
+
+(provide 'icejam-lang-markdown)
+;;; icejam-lang-markdown.el ends here

user-lisp/langs/icejam-lang-ocaml.el

@@ -0,0 +1,98 @@
+;;; ocaml -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(eval-when-compile
+  (defvar icejam-ocaml-lang-menu 'icejam-lang-ocaml)
+  (defvar icejam-language-transient-alist)
+  (declare-function transient-define-prefix 'transient)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(use-package merlin :defer t :ensure t)
+(use-package opam-switch-mode :defer t :ensure t :commands (opam-switch-mode))
+(use-package dune :defer t :ensure t)
+(use-package tuareg :defer t :ensure t)
+
+(with-eval-after-load 'tuareg
+  (add-hook 'tuareg-mode-hook 'merlin-mode))
+
+(transient-define-prefix icejam-ocaml-lang-menu ()
+  "Ocaml Actions."
+  ["OCaml actions"
+   [""
+    ("r" "Reload"   icejam-revert-buffer-no-confirm)
+    ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
+   [""
+    ("f" "Format"   lsp-format-buffer)
+    ("e" "Errors"   flymake-show-buffer-diagnostics)
+    ("o" "Opam Env" opam-switch-set-switch)]]
+  [""
+   ("q" "Quit"      keyboard-quit)])
+
+(add-to-list 'icejam-language-transient-alist '(tuareg-mode . icejam-ocaml-lang-menu))
+
+(defun icejam-load-ocaml-site-packages ()
+  "Generate ocaml config."
+  (let ((opam-share (ignore-errors (car (process-lines "opam" "var" "share")))))
+    (when (and opam-share (file-directory-p opam-share))
+      ;; Register Merlin
+      (add-to-list 'load-path (expand-file-name "emacs/site-lisp" opam-share))
+      (autoload 'merlin-mode "merlin" nil t nil)
+      (autoload 'utop "utop" nil t nil)
+      (autoload 'dune "dune" nil t nil)
+
+      ;; Use opam switch to lookup ocamlmerlin binary
+      (setq merlin-command 'opam))))
+
+;; OCaml setup
+(defun icejam-activate-tuareg-mode ()
+  "All thing OCaml."
+  (icejam-set-indent 2)
+  (opam-switch-mode t)
+  (icejam-load-ocaml-site-packages)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)
+
+;; Disable merlin keys that are unused by me
+(add-hook 'merlin-mode-hook (lambda ()
+                              (unbind-key "C-c C-d" merlin-mode-map)
+                              (unbind-key "C-c C-l" merlin-mode-map)
+                              (unbind-key "C-c C-n" merlin-mode-map)
+                              (unbind-key "C-c C-p" merlin-mode-map)
+                              (unbind-key "C-c C-r" merlin-mode-map)
+                              (unbind-key "C-c C-t" merlin-mode-map)
+                              (unbind-key "C-c C-x" merlin-mode-map)
+                              (unbind-key "C-c &" merlin-mode-map)))
+
+;; Use tuareg-opam with lock files
+(add-to-list 'auto-mode-alist '("\\.opam.locked\\'" . tuareg-opam-mode))
+
+;; (transient-define-prefix icejam-lang-reasonml-context-menu ()
+;;   "ReasonML Actions."
+;;   ["ReasonML actions"
+;;    [""
+;;     ("r" "Reload"   icejam-revert-buffer-no-confirm)
+;;     ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
+;;    [""
+;;     ("f" "Format"   refmt)
+;;     ("e" "Opam Env" opam-switch-set-switch)]]
+;;   [""
+;;    ("q" "Quit"      keyboard-quit)])
+
+
+;; (defun icejam-lang-activate-reason-mode ()
+;;   "Generate reason config."
+;;   (define-key
+;;     reason-mode-map (kbd "C-c l") 'icejam-lang-reasonml-context-menu))
+
+;; ;; Reason setup
+;; (add-hook 'reason-mode-hook
+;;           (lambda ()
+;;             (add-hook 'before-save-hook #'refmt-before-save)))
+;; (add-hook 'reason-mode-hook 'icejam-lang-activate-reason-mode)
+;; (add-hook 'reason-mode-hook 'merlin-mode)
+
+(provide 'icejam-lang-ocaml)
+;;; icejam-lang-ocaml.el ends here

user-lisp/langs/icejam-lang-other.el

@@ -0,0 +1,44 @@
+;;; other.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Load other languages or syntaxes configuration that do not fit anywhere else.
+
+;;; Code:
+
+;; Infrastructure files
+(use-package dockerfile-mode :ensure t :defer t)
+(use-package docker :ensure t :defer t)
+(use-package terraform-mode :ensure t :defer t)
+(use-package ansible :ensure t :defer t)
+(use-package nginx-mode :ensure t :defer t)
+(use-package
+  jenkinsfile-mode
+  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git"
+                 :branch "master")
+  :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)
+
+(with-eval-after-load 'yaml-mode
+  (defun icejam-lang-activate-yaml-mode ()
+    "Activate yaml-mode."
+    (eglot-ensure))
+  (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))
+
+;; Other text files
+(use-package json-mode :ensure t :defer t)
+(use-package git-modes :ensure t :defer t
+  :hook (gitignore . whitespace-mode-hook))
+
+(provide 'icejam-lang-other)
+;;; icejam-lang-other.el ends here

user-lisp/langs/icejam-lang-php.el

@@ -0,0 +1,49 @@
+;;; icejam-lang-php.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; php related settings
+
+;;; Code:
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-php-lang-menu)
+  (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)
+  (declare-function transient-define-prefix 'transient))
+
+(use-package php-mode :ensure t :defer t)
+
+(transient-define-prefix icejam-php-lang-menu ()
+  "PHP Buffer Commands."
+  [""
+   ["LSP"
+    ("m" "iMenu"       consult-imenu)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      eglot-format-buffer)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q" "Quit"        keyboard-quit)])
+
+(add-to-list
+ 'icejam-language-transient-alist '(php-mode . icejam-php-lang-menu))
+
+(defun icejam-activate-php-mode ()
+  "All things php."
+  (icejam-set-indent 4)
+  (column-enforce-n 80)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'php-mode-hook 'icejam-activate-php-mode)
+
+(provide 'icejam-lang-php)
+;;; icejam-lang-php.el ends here

user-lisp/langs/icejam-lang-purescript.el

@@ -0,0 +1,35 @@
+;;; purescript.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Configuration for purescript.
+
+;;; Code:
+
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function purescript-indentation-mode 'purescript-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(use-package purescript-mode :ensure t :defer t)
+
+(defun icejam-activate-purescript-mode ()
+  "All things Purescript."
+  (icejam-set-indent 2)
+  (column-enforce-n 98)
+
+  ;; Purescript indentation
+  (purescript-indentation-mode t)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)
+
+(provide 'icejam-lang-purescript)
+;;; icejam-lang-purescript.el ends here

user-lisp/langs/icejam-lang-python.el

@@ -0,0 +1,42 @@
+;;; python -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(eval-when-compile
+  (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)
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-python-lang-menu))
+
+(transient-define-prefix icejam-python-lang-menu ()
+  "Python Buffer Commands."
+  [""
+   ["LSP"
+    ("m" "iMenu"       consult-imenu)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      eglot-format-buffer)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q" "Quit"        keyboard-quit)])
+
+;; Add lookup for C-c l transient menu
+(add-to-list
+ 'icejam-language-transient-alist '(python-mode . icejam-python-lang-menu))
+
+;; Python template language
+(use-package jinja2-mode :ensure t :defer t)
+
+(defun icejam-lang-activate-python-mode ()
+  "Activate python mode."
+  (eglot-ensure)
+  (column-enforce-n 99)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)
+
+(provide 'icejam-lang-python)
+;;; icejam-lang-python.el ends here

user-lisp/langs/icejam-lang-ruby.el

@@ -0,0 +1,40 @@
+;;; ruby -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar eglot-server-programs)
+  (defvar ruby-insert-encoding-magic-comment)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
+(use-package ruby-end :ensure t :defer t)
+(use-package rbs-mode :ensure t :defer t)
+
+(add-to-list 'auto-mode-alist '("\\.rb\\'" . ruby-ts-mode))
+
+(defun icejam-activate-ruby-mode ()
+  "All things for ruby mode."
+  (icejam-set-indent 2)
+
+  ;; Disable reek syntax checking permanently
+  (add-to-list (make-local-variable 'flycheck-disabled-checkers) 'ruby-reek 'ruby-rubocop)
+
+  ;; Do not insert magic encoding comment at the begining of each file
+  (setopt ruby-insert-encoding-magic-comment nil)
+
+  ;; Start LSP
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'ruby-ts-mode-hook 'rspec-mode)
+(add-hook 'ruby-ts-mode-hook 'ruby-end-mode)
+(eval-after-load 'rspec-mode '(rspec-install-snippets))
+(add-hook 'ruby-ts-mode-hook 'icejam-activate-ruby-mode)
+
+(provide 'icejam-lang-ruby)
+;;; icejam-lang-ruby.el ends here

user-lisp/langs/icejam-lang-rust.el

@@ -0,0 +1,40 @@
+;;; 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))
+
+(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))
+
+(use-package flycheck-rust
+  :ensure t
+  :defer t
+  :after (rust-mode))
+
+(defun icejam-activate-rust-mode ()
+  "All things for Rust mode."
+  (interactive)
+  (icejam-set-indent 4)
+  (column-enforce-n 99)
+
+  ;; Run LSP
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
+(add-hook 'rust-mode-hook 'flycheck-rust-setup)
+
+(provide 'icejam-lang-rust)
+;;; icejam-lang-rust.el ends here

user-lisp/langs/icejam-lang-sh.el

@@ -0,0 +1,12 @@
+;;; sh -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package fish-mode :ensure t :defer t)
+
+(dolist
+    (ending '("\\.zsh\\'" "\\.zshrc\\'" "\\.envrc\\'" "\\.zshrc\\'"))
+  (add-to-list 'auto-mode-alist (cons ending 'sh-mode)))
+
+(provide 'icejam-lang-sh)
+;;; icejam-lang-sh.el ends here

user-lisp/langs/icejam-lang-web.el

@@ -0,0 +1,35 @@
+;;; web -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(use-package web-mode :ensure t :defer t)
+
+;; Eex Web mode
+(add-to-list 'auto-mode-alist '("\\.eex\\'" . web-mode))
+(add-to-list 'auto-mode-alist '("\\.leex\\'" . web-mode))
+
+;; ERB mode
+(add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
+
+;; Vue JS
+(add-to-list 'auto-mode-alist '("\\.vue\\'" . web-mode))
+
+(setopt web-mode-extra-auto-pairs
+        '(("eex"  . (("<%" "%>")))
+          ("leex"  . (("<%" "%>")))
+          ("erb"  . (("<%" "%>")
+                     ("beg" "end")))))
+
+(defun icejam-activate-web-mode ()
+	"Web mode overrides."
+	;; Indent web mode scripts by 2
+	(setq-local web-mode-script-padding 2)
+	(setq-local web-mode-code-indent-offset 2)
+	(setq-local web-mode-markup-indent-offset 2)
+  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+	(when (string-match-p ".vue" (buffer-file-name))
+    (eglot-ensure)))
+
+(add-hook 'web-mode-hook 'icejam-activate-web-mode)
+
+(provide 'icejam-lang-web)
+;;; icejam-lang-web.el ends here

user-lisp/langs/icejam-lang-ziglang.el

@@ -0,0 +1,33 @@
+;;; ziglang.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; ziglang does a thing.
+
+;;; 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))
+
+(use-package zig-mode :ensure t :defer t)
+
+(defun icejam-activate-zig-mode ()
+  "Goodies for editing zig files."
+
+  ;; Set column width to 100
+  (column-enforce-n 100)
+
+  ;; Set indentation to 4 chars
+  (icejam-set-indent 4)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'zig-mode-hook 'icejam-activate-zig-mode)
+
+(provide 'icejam-lang-ziglang)
+;;; icejam-lang-ziglang.el ends here