Dotfiles

Immutable GNU Emacs dotfiles. Built for Life, Liberty, and the Open Road.

• 100% Literate

• 100% Immutable

• 100% Reproducible

Init

Here's a complete list of all of the options configurable for each host, and their default values. All variables prefixed with dotfiles/. If you need to make configurations to another variable, consider creating a new option.

(defvar dotfiles/font 
  "Fira Code" 
  "Unified system font family.")

(defvar dotfiles/font-size 
  96 
  "Unified system font size.")

(defvar dotfiles/browser 
  (getenv "BROWSER") 
  "Default system web browser.")

(defvar dotfiles/language 
  (getenv "LANG") 
  "Default system dictionary language.")

(defconst dotfiles/modules-p 
  '(core 
    editor
    ;; email
    desktop
    writing
    website
    capture
    projects
    interface) 
  "All of the available modules.")

(defvar dotfiles/modules 
  dotfiles/modules-p 
  "All of the enabled modules.")

(defvar dotfiles/home 
  user-emacs-directory 
  "Original value of `user-emacs-directory'.")

(defvar dotfiles/cache 
  (expand-file-name "~/.cache/emacs") 
  "Redirection target of `user-emacs-directory'.")

(defvar dotfiles/idle 
  0.0 
  "Delay time before offering suggestions and completions.")

(defvar dotfiles/leader-key 
  "SPC" 
  "All powerful leader key.")

(defvar dotfiles/leader-key-global 
  (concat "C-" dotfiles/leader-key) 
  "Global prefix for the leader key.")

(defvar dotfiles/projects 
  (expand-file-name "~/.local/source/") 
  "Location of source code projects.")

(defvar dotfiles/passwords 
  (expand-file-name "~/.password-store/") 
  "Location of local password store.")

(defvar dotfiles/public-key 
  "37AB1CB72B741E478CA026D43025DCBD46F81C0F" 
  "GPG key to encrypt org files for.")

Hosts

Each host machines configuration is loaded immediately after the options are declared, before any configuration is applied. This allows system to system control while remaining immutable. Override any of the available options configurations in a host file. Here's some examples to get started:

• Termux

• Raspberry

• Acernitro

• Virtualbox

Begin the process by loading any host specific overrides. The host configuration tangles, and loads (if it exist) using the systems name.

(let ((host-file (concat dotfiles/home "/hosts/" system-name ".org")))
  (when (file-exists-p host-file)
    (org-babel-load-file host-file)))

Modules

Breaking down the project into logical units or chapters to keep the code more maintainable and organized. This is also a fundamental requirement to achieve the goal of modularity. Here are all of the available modules, also listed in the variable dotfiles/modules-p.

• Core

• Editor

• Email

• Desktop

• Writing

• Website

• Projects

• Interface

By default all of the modules will load, override the variable dotfiles/modules in a host configuration to override this.

(dolist (m dotfiles/modules)
  (let ((mod-file (concat dotfiles/home "/modules/" (symbol-name m) ".org")))
    (when (file-exists-p mod-file)
      (org-babel-load-file mod-file))))

Projects

An IDE like experience (or better) can be achieved in Emacs using two Microsoft open source initiatives.

• Language Server Protocol

• Debug Adapter Protocol

Add support for language servers with lsp-mode.

(use-package lsp-mode
  :commands (lsp lsp-deferred)
  :custom (lsp-idle-delay (* 5 dotfiles/idle)))

lsp-ui provides UI improvements for lsp-mode.

(use-package lsp-ui
  :after lsp
  :custom (lsp-ui-doc-position 'at-point)
          (lsp-ui-doc-delay 0.500))

Dap-mode adds support for the debug adapter protocol to Emacs.

(use-package dap-mode
  :commands (dap-debug))

Containers

Use docker for running containers. Download and install https://github.com/Silex/docker.el, allowing us to manage containers within Emacs.

(use-package docker
  :commands (docker))

Open the management screen with SPC k.

(dotfiles/leader
  "k" '(docker :which-key "Docker"))

Management

Configure projectile, a project interaction library for Emacs. It provides a nice set of features for operating on a project level without introducing external dependencies.

(use-package projectile
  :custom (projectile-project-search-path '("~/.local/source"))
  :config (projectile-mode))

Completion

Text completion framework via company aka Complete Anything.

http://company-mode.github.io/

• Integrate with lsp-mode

(use-package company
  :after lsp)

(use-package company-lsp
  :after (lsp company)
  :custom (company-backend 'company-lsp))

Passwords

Pass makes managing passwords extremely easy, encrypring them in a file structure and providing easy commands for generating, modify, and copying passwords. password-store.el provides a wrapper for the functionality within Emacs.

(use-package password-store
  :custom (password-store-dir dotfiles/passwords))

Configure keybindings behind SPC p.

• Copy with p

• Rename with r

• Generate with g

(dotfiles/leader
  "p" '(:ignore t :which-key "Passwords")
  "pp" '(password-store-copy :which-key "Copy")
  "pr" '(password-store-rename :which-key "Rename")
  "pg" '(password-store-generate :which-key "Generate"))

Languages

Support for individual languages are implemented here.

Go

Install the gopls language server.

GO111MODULE=on go get golang.org/x/tools/gopls@latest

Set the GOPATH environment variable prior to loading, this allows us to change the default value of $HOME/go to $HOME/.go.

(setenv "GOPATH" (concat (getenv "HOME") "/.go/"))

Additionally, include the bin subdirectory of the $GOPATH in the $PATH variable, adding compiled golang programs.

(setenv "PATH" (concat (getenv "GOPATH") "bin:" (getenv "PATH")))

Finally we can include the go-mode package, integrating it with lsp.

(use-package go-mode
  :hook (go-mode . lsp)
  :custom (lsp-go-gopls-server-path "~/.go/bin/gopls"))

Apply some custom behaviour before saving:

• Format buffer

• Organize imports

(defun dotfiles/go-hook ()
  (add-hook 'before-save-hook #'lsp-format-buffer t t)
  (add-hook 'before-save-hook #'lsp-organize-imports t t))

(add-hook 'go-mode-hook #'dotfiles/go-hook)

Add a golang source code block structure template with <go:

(add-to-list 'org-structure-template-alist '("go" . "src go"))

HTTP

Instead of the popular restclient package, I use ob-http as a lightweight alternative.

(use-package ob-http
  :after org
  :config (org-babel-do-load-languages
            'org-babel-load-languages
            '((http . t))))

C/C++

Add support for C/C++ languages.

• Configure the ccls language server

• Load babel language modules for C/C++

• Create a new structure templates for C/C++

  • <cc for C

  • <cpp for C++

(use-package ccls
  :hook ((c-mode c++-mode objc-mode cuda-mode) .
         (lambda ()
           (require 'ccls)
           (lsp-deferred)))
  :config (add-to-list 'org-structure-template-alist '("cc" . "src C"))
          (add-to-list 'org-structure-template-alist '("cpp" . "src C++"))
          (org-babel-do-load-languages 'org-babel-load-languages '((C . t))))

Python

Install the pyls language server.

pip3 install --user "python-language-server[all]"

Python-mode is an Emacs built in mode.

• Load the babel language module for Python

• Add a python source code block structure template with <py

(use-package python-mode
  :hook (python-mode . lsp-deferred)
  :config (require 'dap-python)
          (add-to-list 'org-src-lang-modes '("python" . python))
          (add-to-list 'org-structure-template-alist '("py" . "src python"))
          (org-babel-do-load-languages 'org-babel-load-languages '((python . t)))
  :custom (python-shell-interpreter "python3") ;; Required if "python" is not python 3.
          (dap-python-executable "python3")    ;; Same as above.
          (dap-python-debugger 'debugpy))

PlantUML

Download and install PlantUML, a text-based markup language for creating UML diagrams.

• Load the babel language module for PlantUML

• Create a structure template with <pl

(use-package plantuml-mode
  :after org
  :custom (plantuml-default-exec-mode 'jar)
          (plantuml-jar-path "~/.local/bin/plantuml.jar")
          (org-plantuml-jar-path (expand-file-name "~/.local/bin/plantuml.jar"))
          (org-startup-with-inline-images t)
  :config (add-to-list 'org-src-lang-modes '("plantuml" . plantuml))
          (add-to-list 'org-structure-template-alist '("pl" . "src plantuml"))
          (org-babel-do-load-languages 'org-babel-load-languages '((plantuml . t))))

Toggle inline images with SPC t i.

(dotfiles/leader
  "ti" '(org-toggle-inline-images :which-key "Images"))

Interface

Bring Emacs out of the eighties

Ivy

Download and configure ivy, a powerful selection menu for Emacs.

(use-package ivy
  :diminish
  :config (ivy-mode 1))

Counsel is a customized set of commands to replace built in completion buffers.

(use-package counsel
  :after ivy
  :custom (counsel-linux-app-format-function #'counsel-linux-app-format-function-name-only)
  :config (counsel-mode 1))

Switch buffers with SPC , (comma).

(dotfiles/leader
  "," '(counsel-switch-buffer :which-key "Buffers"))

Provide more information about each item with ivy-rich.

(use-package ivy-rich
  :after counsel
  :init (ivy-rich-mode 1))

Fonts

Write out to all 3 of Emacs' default font faces.

(set-face-attribute 'default nil :font dotfiles/font :height dotfiles/font-size)
(set-face-attribute 'fixed-pitch nil :font dotfiles/font :height dotfiles/font-size)
(set-face-attribute 'variable-pitch nil :font dotfiles/font :height dotfiles/font-size)

Define a transient keybinding for scaling the text.

(defhydra hydra-text-scale (:timeout 4)
  "Scale"
  ("j" text-scale-increase "Increase")
  ("k" text-scale-decrease "Decrease")
  ("f" nil "Finished" :exit t))

Increase the font size in buffers with SPC t f.

• Increase j

• Decrease k

• Finish f

(dotfiles/leader
  "tf" '(hydra-text-scale/body :which-key "Font"))

Lines

Relative line numbers are important when using VI emulation keys. You can prefix most commands with a number, allowing you to jump up / down by a line count.

  5:
  4:
  3:
  2:
  1:
156: << CURRENT LINE >>
  1:
  2:
  3:
  4:
  5:

https://github.com/emacsmirror/linum-relative

• Integrate with display-line-numbers-mode for performance

(use-package linum-relative
  :commands (linum-relative-global-mode)
  :custom (linum-relative-backend 'display-line-numbers-mode))

Add line numbers to the toggles behind SPC t l.

(dotfiles/leader
  "tl" '(linum-relative-global-mode :which-key "Lines"))

https://github.com/Fanael/rainbow-delimiters

• Colourize nested parenthesis

(use-package rainbow-delimiters
  :hook (prog-mode . rainbow-delimiters-mode))

Themes

Cherry pick a few modules from doom-emacs. High quality and modern colour themes are provided in the doom-themes package.

(use-package doom-themes
  :init (load-theme 'doom-moonlight t))

doom-modeline provides an elegant status bar / modeline.

(use-package doom-modeline
  :custom (doom-modeline-height 16)
  :config (doom-modeline-mode 1))

Load a theme with SPC t t.

(dotfiles/leader
  "tt" '(counsel-load-theme t t :which-key "Theme"))

Pretty

Make programming buffers prettier with pretty-mode, complimentary to the built in prettify-symbols-mode.

(use-package pretty-mode
  :hook (python-mode . turn-on-pretty-mode))

Ligatures

Enable font ligatures via fira-code-mode, perform this action only when Fira Code is the current font.

(when (display-graphic-p)
  (use-package fira-code-mode
    :hook (prog-mode org-mode)))

Toggle global ligature mode with SPC t g.

(dotfiles/leader
  "tg" '(global-fira-code-mode :which-key "Ligatures"))

Dashboard

Present a dashboard when first launching Emacs. Customize the buttons of the navigator:

• Brain @ http://localhost:8080

• Homepage @ https://chrishayward.xyz

• Athabasca @ https://login.athabascau.ca/cas/login

• Bookshelf @ https://online.vitalsource.com

(use-package dashboard
  :custom (dashboard-center-content t)
          (dashboard-set-init-info t)
          (dashboard-set-file-icons t)
          (dashboard-set-heading-icons t)
          (dashboard-set-navigator t)
          (dashboard-startup-banner 'logo)
          (dashboard-projects-backend 'projectile)
          (dashboard-items '((projects . 5) (recents  . 5) (agenda . 10)))
          (dashboard-navigator-buttons `(((,(all-the-icons-fileicon "brain" :height 1.1 :v-adjust 0.0)
                                          "Brain" "Knowledge base"
                                          (lambda (&rest _) (browse-url "http://localhost:8080"))))
                                         ((,(all-the-icons-material "public" :height 1.1 :v-adjust 0.0)
                                          "Homepage" "Personal website"
                                          (lambda (&rest _) (browse-url "https://chrishayward.xyz"))))
                                         ((,(all-the-icons-faicon "university" :height 1.1 :v-adjust 0.0)
                                          "Athabasca" "Univeristy login"
                                          (lambda (&rest _) (browse-url "https://login.athabascau.ca/cas/login"))))
                                         ((,(all-the-icons-faicon "book" :height 1.1 :v-adjust 0.0)
                                          "Bookshelf" "Vitalsource bookshelf"
                                          (lambda (&rest _) (browse-url "https://online.vitalsource.com"))))))
  :config (dashboard-setup-startup-hook))

When running in daemon mode, ensure that the dashboard is the initial buffer.

(setq initial-buffer-choice
      (lambda ()
        (get-buffer "*dashboard*")))