chris
/
dotfiles
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Clean up modules

main
Christopher James Hayward 4 years ago
parent
15b5341237
commit
f0a5c3de15
6 changed files with 294 additions and 1123 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 159
      modules/desktop.el
  2. 239
      modules/editor.el
  3. 294
      modules/editor.org
  4. 211
      modules/interface.el
  5. 220
      modules/projects.el
  6. 294
      modules/writing.el

159
modules/desktop.el
View File

@ -1,159 +0,0 @@
;; Once the mail's synchronized, and has indexed with =mu=, it's time to install the required packages for Emacs.
;; + Update every 5 minutes
;; + Scale text for all devices
;; + Sign outbound mail with GPG key
;; + Configure mail account(s)
(use-package mu4e
:load-path "/usr/share/emacs/site-lisp/mu4e"
:custom (mu4e-maildir "~/.cache/mail")
(mu4e-update-interval (* 5 60))
(mu4e-get-mail-command "mbsync -a")
(mu4e-compose-format-flowed t)
(mu4e-change-filenames-when-moving t)
(message-send-mail-function 'smtpmail-send-it)
(mml-secure-openpgp-signers '("37AB1CB72B741E478CA026D43025DCBD46F81C0F"))
(mu4e-compose-signature (concat "Chris Hayward\n"
"https://chrishayward.xyz\n"))
:config
(add-hook 'message-send-hook 'mml-secure-message-sign-pgpmime)
(setq mu4e-contexts
(list
;; Main
;; chris@chrishayward.xyz
(make-mu4e-context
:name "Main"
:match-func
(lambda (msg)
(when msg
(string-prefix-p "/Main" (mu4e-message-field msg :maildir))))
:vars
'((user-full-name . "Christopher James Hayward")
(user-mail-address . "chris@chrishayward.xyz")
(smtpmail-smtp-server . "mail.chrishayward.xyz")
(smtpmail-smtp-service . 587)
(smtpmail-stream-type . starttls))))))
;; Use [[https://github.com/iqbalansari/mu4e-alert][mu4e-alert]] to give us desktop notifications about incoming mail.
(use-package mu4e-alert
:after mu4e
:custom (mu4e-alert-set-default-style 'libnotify)
:config (mu4e-alert-enable-notifications)
(mu4e-alert-enable-mode-line-display))
;; Create a keybinding to open the mail dashboard with =SPC m=.
(dotfiles/leader
"m" '(mu4e :which-key "Mail"))
;; Browser
;; Write out the ~$BROWSER~ environment variable.
(setenv "BROWSER" dotfiles/browser)
;; Methods
;; Define a method to run an external process, allowing us to launch any application on a new process without interferring with Emacs.
(defun dotfiles/run (command)
"Run an external process."
(interactive (list (read-shell-command "λ ")))
(start-process-shell-command command nil command))
;; Apply methods to the current call process to avoid issues with hooks.
(defun dotfiles/run-in-background (command)
(let ((command-parts (split-string command "[ ]+")))
(apply #'call-process `(,(car command-parts) nil 0 nil ,@(cdr command-parts)))))
;; Place keybindings for executing shell commands behind =SPC x=.
;; + Run shell commands with =x=
;; + Run async shell commands with =z=
(dotfiles/leader
"x" '(:ignore t :which-key "Run")
"xx" '(dotfiles/run :which-key "Run")
"xz" '(async-shell-command :which-key "Async"))
;; Displays
;; When the window manager first launches the ~init-hook~ executes, allowing us to define some custom logic.
;; + Display time and date
;; + Display battery info (if available)
;; In my personal configuration, I do not want the battery or time displayed within Emacs when it's not running as desktop environment because that information is typically already available.
(defun dotfiles/init-hook ()
(exwm-workspace-switch-create 1)
(setq display-time-and-date t)
(display-battery-mode 1)
(display-time-mode 1))
;; Using =autorandr= with pre configured profiles, switching screens (AKA hot plugging) is also handled through a hook.
(defun dotfiles/update-display ()
"Update the displays by forcing a change through autorandr."
(dotfiles/run-in-background "autorandr --change --force"))
;; Configuration
;; Connect our custom hooks and configure the input keys, a custom layer for key capture layers.
;; + Enable =randr= support
;; + Pass through to Emacs
;; + =M-x= to Emacs
;; + =C-g= to Emacs
;; + =C-SPC= to Emacs
;; + Bindings with =S= (Super / Win)
;; + Reset =S-r=
;; + Launch =S-&=
;; + Workspace =S-[1..9]=
(use-package exwm
:custom (exwm-workspace-show-all-buffers t)
(exwm-input-prefix-keys
'(?\M-x
?\C-c
?\C-g
?\C-\ ))
(exwm-input-global-keys
`(([?\s-r] . exwm-reset)
,@(mapcar (lambda (i)
`(,(kbd (format "s-%d" i)) .
(lambda ()
(interactive)
(exwm-workspace-switch-create ,i))))
(number-sequence 1 9))))
:config (require 'exwm-randr)
(exwm-randr-enable)
(add-hook 'exwm-init-hook #'dotfiles/init-hook)
(add-hook 'exwm-randr-screen-change-hook #'dotfiles/update-display)
(dotfiles/update-display)
(exwm-enable))

239
modules/editor.el
View File

@ -1,239 +0,0 @@
;; Keys
;; Make the =ESC= key quit (most) prompts, instead of the default =C-g=.
(global-set-key (kbd "<escape>") 'keyboard-escape-quit)
;; Download [[https://github.com/justbur/emacs-which-key][which-key]], a package that displays the current incomplete keybinding input in a mini-buffer, showing available completion options.
(use-package which-key
:diminish which-key-mode
:custom (which-key-idle-delay dotfiles/idle)
:config (which-key-mode))
;; Turn Emacs into Vim with [[https://evil.readthedocs.io/en/latest/index.html][evil-mode]], the extensible VI layer for Emacs.
(use-package evil
:custom (evil-want-integration t) ;; Required for `evil-collection'.
(evil-want-keybinding nil) ;; Same as above
:config (evil-mode 1))
;; Unfortunately the default keybindings are *lacking*, but there is a community curated package [[https://github.com/emacs-evil/evil-collection][evil-collection]], which does a much better job implementing keybindings you would expect to find.
(use-package evil-collection
:after evil
:config (evil-collection-init))
;; Surround text with functions, quotations, and any other symbols using the [[https://github.com/emacs-evil/evil-surround][evil-surround]] package.
(use-package evil-surround
:after evil
:config (global-evil-surround-mode 1))
;; Toggle block comments using [[https://github.com/redguardtoo/evil-nerd-commenter][evil-nerd-commentor]] and =M-;=.
(use-package evil-nerd-commenter
:after evil
:bind ("M-;" . evilnc-comment-or-uncomment-lines))
;; Implement the *leader* key using [[https://github.com/noctuid/general.el][general.el]], letting us easily configure prefixed keybindings in a much cleaner manner than the default methods.
(use-package general
:after evil
:config
(general-create-definer dotfiles/leader
:states '(normal motion)
:keymaps 'override
:prefix dotfiles/leader-key
:global-prefix dotfiles/leader-key-global))
;; Use [[https://github.com/abo-abo/hydra][hydra]] for transient keybindings sharing a common prefix.
(use-package hydra
:defer t)
;; Help
;; Use the built-in ~describe-*~ functionality of Emacs to quickly access documentation for packages, variables, and functions. Run helper functions with =SPC h=.
;; + Packages =p=
;; + Variables =v=
;; + Functions =f=
(dotfiles/leader
"h" '(:ignore t :which-key "Help")
"hp" '(describe-package :which-key "Package")
"hv" '(describe-variable :which-key "Variable")
"hf" '(describe-function :which-key "Function"))
;; Files
;; For file navigation I use =dired=, included with Emacs by default. Dired feels more modern with prioritized icon fonts using [[https://github.com/domtronn/all-the-icons.el][all-the-icons]]. This makes navigation and visually parsing directories much faster, given that file types are quickly identified by their corresponding icons.
(use-package all-the-icons)
;; Integration with =dired= comes from the [[https://github.com/jtbm37/all-the-icons-dired][all-the-icons-dired]] package.
(use-package all-the-icons-dired
:hook (dired-mode . all-the-icons-dired-mode))
;; When opening =dired=, I don't want to have to press =RET= twice to navigate to the current directory. Avoid this with ~dired-jump~, included in the =dired-x= package shipped with =dired= and Emacs.
(require 'dired-x)
;; By default =dired= will create a new buffer everytime you press =RET= over a directory. This leads to unwanted =dired= buffers needing closure. Avoid this behaviour with [[https://github.com/crocket/dired-single][dired-single]], reusing the same dired buffer.
;; + Move up a directory with =h=
;; + Open a single buffer with =l=
(use-package dired-single
:config (evil-collection-define-key 'normal 'dired-mode-map
"h" 'dired-single-up-directory
"l" 'dired-single-buffer))
;; Open a dired buffer with =SPC d=.
(dotfiles/leader
"d" '(dired-jump :which-key "Dired"))
;; Shell
;; While not a traditional terminal emulator, =eshell= provides me with all of the functionality I expect and require from one. Some users may be wanting more, I would recommend they look into =vterm= included in the destkop module. Configure the infamous lambda prompt using [[https://github.com/zwild/eshell-prompt-extras][eshell-prompt-extras]] package.
(use-package eshell-prompt-extras
:custom (eshell-highlight-prompt nil)
(eshell-prefer-lisp-functions nil)
(eshell-prompt-function 'epe-theme-lambda))
;; Open an =eshell= buffer with =SPC e=.
(dotfiles/leader
"e" '(eshell :which-key "Shell"))
;; Source
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/2021-02-13-example-magit.gif]]
;; Another hallmark feature is [[https://github.com/magit/magit][Magit]], a complete git porcelain within Emacs.
(use-package magit
:commands magit-status
:custom (magit-display-buffer-function
#'magit-display-buffer-same-window-except-diff-v1))
;; Work directly with github issues / pull requests using [[https://github.com/magit/forge][Forge]].
;; + Requires a valid ~$GITHUB_TOKEN~
(use-package forge
:after magit)
;; Open the *status* page for the current repository with =SPC g=.
(dotfiles/leader
"g" '(magit-status :which-key "Magit"))
;; Windows
;; Window management with =SPC w=.
;; + Swap with =w=
;; + Close with =c=
;; + Motions with =h,j,k,l=
;; + Split with =s + <MOTION>=
(dotfiles/leader
"w" '(:ignore t :which-key "Window")
"ww" '(window-swap-states :which-key "Swap")
"wc" '(delete-window :which-key "Close")
"wh" '(windmove-left :which-key "Left")
"wj" '(windmove-down :which-key "Down")
"wk" '(windmove-up :which-key "Up")
"wl" '(windmove-right :which-key "Right")
"ws" '(:ignore t :which-key "Split")
"wsj" '(split-window-below :which-key "Down")
"wsl" '(split-window-right :which-key "Right"))
;; Shortcuts
;; Implement shortcut bindings, cherry picked from Doom emacs.
;; + Close buffers with =SPC c=
;; + Find files with =SPC . (period)=
(dotfiles/leader
"." '(find-file :which-key "Files")
"c" '(kill-buffer-and-window :which-key "Close"))
;; Quit emacs with =SPC q=.
;; + Saving =q=
;; + Without =w=
;; + Frame (daemon) =f=
(dotfiles/leader
"q" '(:ignore t :which-key "Quit")
"qq" '(save-buffers-kill-emacs :which-key "Save")
"qw" '(kill-emacs :which-key "Now")
"qf" '(delete-frame :which-key "Frame"))
;; Place runtime tweaks behind =SPC t=.
(dotfiles/leader
"t" '(:ignore t :which-key "Tweaks"))

294
modules/editor.org
View File

@ -0,0 +1,294 @@
#+TITLE: Editor
#+AUTHOR: Christopher James Hayward
#+EMAIL: chris@chrishayward.xyz
#+PROPERTY: header-args:emacs-lisp :tangle editor.el :comments org
#+PROPERTY: header-args :results silent :eval no-export :comments org
#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
Configuration and imrpovements to the editor experience within Emacs. *Vim*[fn:1] user? This module extends the keybindings by implementing *Evil*[fn:2]. *Doom*[fn:3], *Spacemacs*[fn:4]? The all powerful leader key is also implemented right here!
* Keys
Offer =ESC= as an alternative to quit (most) prompts, instead of the default =C-g=.
#+begin_src emacs-lisp
(global-set-key (kbd "<escape>") 'keyboard-escape-quit)
#+end_src
** Completions
Emacs has *a lot of keybindings*, sometimes it's useful to just start mashing keys and see what happens. This behaviour exists in a third-party package called *which-key*[fn:5]. It displays the current incomplete keybinding input in a mini-buffer, showing available completion options with their corresponding keybindings.
#+begin_src emacs-lisp
(use-package which-key
:diminish which-key-mode
:custom (which-key-idle-delay dotfiles/idle)
:config (which-key-mode))
#+end_src
** Turn Emacs into Vim
Emacs has *some strange default keybindings*, they're not like any other editor you've likely ever used. To overcome this nearly show-stopping hurdle, we turn Emacs into Vim[fn:1] with *Evil Mode - The Extensible VI Layer for Emacs*[fn:2].
#+begin_src emacs-lisp
(use-package evil
:custom (evil-want-integration t) ;; Required for `evil-collection'.
(evil-want-keybinding nil) ;; Same as above
:config (evil-mode +1))
#+end_src
While covering substantial ground towards our goal, the default keybindings implemented in *Evil*[fn:2] alone are *lacking* compared to what you would expect from *Vim*[fn:1]. There's, of course, a communicated curated package *evil-collection*[fn:6] that does a much better job implementing the proper keybindings.
#+begin_src emacs-lisp
(use-package evil-collection
:after evil
:config (evil-collection-init))
#+end_src
*** Surround text
Whether it's on purpose, or more likely, you forgot an opening brace; *evil-surround*[fn:7] surrounds highlighted blocks of text with functions, quotations, and any symbol you can input.
#+begin_src emacs-lisp
(use-package evil-surround
:after evil
:config (global-evil-surround-mode 1))
#+end_src
*** Toggle comments
When you're in deep with errors, or just trying some new code, it's useful to be able to toggle large comment sections in a language agnostic manner. In comes *evil-nerd-commentor*[fn:8], with a custom binding to =M-;=. What is =M-= ? Typically that refers to the =Alt= key, called the =Meta= key in Emacs.
#+begin_src emacs-lisp
(use-package evil-nerd-commenter
:after evil
:bind ("M-;" . evilnc-comment-or-uncomment-lines))
#+end_src
** Implementing the leader key
If you're like me and started with Emacs using a framework like *Doom*[fn:3] or *Spacemacs*[fn:4], you probably have a lot of muscle memory for using =SPC= as a leader key. This behaviour is actually not difficult to implement, especially when using *general.el*[fn:9].
+ =SPC= in most situations as a prefix key
+ =C-SPC= when using the [[file:desktop.org][Desktop]] module within an =X= buffer
#+begin_src emacs-lisp
(use-package general
:after evil
:config
(general-create-definer dotfiles/leader
:states '(normal motion)
:keymaps 'override
:prefix dotfiles/leader-key
:global-prefix dotfiles/leader-key-global))
#+end_src
** Transient bindings
Create transient keybindings with a shared prefix through *Hydra*[fn:10]. This is also used by a number of third-party packages as a completion system. An implementation example is available in the *Font* section of the [[file:interface.org][Interface]] module.
+ Defer loading for performance
#+begin_src emacs-lisp
(use-package hydra
:defer t)
#+end_src
Place runtime tweaks behind =SPC t=
#+begin_src emacs-lisp
(dotfiles/leader
"t" '(:ignore t :which-key "Tweaks"))
#+end_src
** Cherry picked shortcuts
Implement shortcut bindings, cherry picked from *Doom*[fn:3].
+ Close buffers with =SPC c=
+ Find files with =SPC , (comma)=
#+begin_src emacs-lisp
(dotfiles/leader
"." '(find-file :which-key "Files")
"c" '(kill-buffer-and-window "Close"))
#+end_src
*** Managing windows
Window management with =SPC w=
+ Swap with =w=
+ Close with =c=
+ Move with =h,j,k,l=
+ Split with =s - <motion>=
#+begin_src emacs-lisp
(dotfiles/leader
"w" '(:ignore t :which-key "Window")
"ww" '(window-swap-states :which-key "Swap")
"wc" '(delete-window :which-key "Close")
"wh" '(windmove-left :which-key "Left")
"wj" '(windmove-down :which-key "Down")
"wk" '(windmove-up :which-key "Up")
"wl" '(windmove-right :which-key "Right")
"ws" '(:ignore t :which-key "Split")
"wsj" '(split-window-below :which-key "Down")
"wsl" '(split-window-right :which-key "Right"))
#+end_src
*** Quitting Emacs
Quit Emacs with =SPC q=
+ Save and quit =q=
+ Quit without saving =w=
+ Exit the Frame (daemon) =f=
#+begin_src emacs-lisp
(dotfiles/leader
"q" '(:ignore t :which-key "Quit")
"qq" '(save-buffers-kill-emacs :which-key "Save")
"qw" '(kill-emacs :which-key "Now")
"qf" '(delete-frame :which-key "Frame"))
#+end_src
* Help
Use the built-in ~describe-*~ functionality of Emacs to quickly access documentation for packages, variables, and functions.
+ Run helper functions with =SPC h=
* Packages =p=
* Variables =v=
* Functions =f=
#+begin_src emacs-lisp
(dotfiles/leader
"h" '(:ignore t :which-key "Help")
"hp" '(describe-package :which-key "Package")
"hv" '(describe-variable :which-key "Variable")
"hf" '(describe-function :which-key "Function"))
#+end_src
* Files
Emacs has some really cool built-in packages, *Dired*[fn:11] is one of them. It's not perfect out of the box though, there's work to do.
** Navigating to the current directory
I don't want to have to press =RET= twice to navigate to the current directory. Avoid this behaviour with ~jump~, included in the =dired-x= package that ships with *Dired*[fn:11].
+ Open a new dired buffer with =SPC d=.
#+begin_src emacs-lisp
(require 'dired-x)
(dotfiles/leader
"d" '(dired-jump :which-key "Dired"))
#+end_src
** Reusing the same buffer
By default *Dired*[fn:11] will create a new buffer every time you press =RET= over a directory. This leads to unwanted buffers all over the place. Avoid this behaviour with *Dired Single*[fn:12], reusing the same dired buffer.
+ Move up a directory with =h=
+ Open a single buffer with =l=
#+begin_src emacs-lisp
(use-package dired-single
:config (evil-collection-define-key 'normal 'dired-mode-map
"h" 'dired-single-up-directory
"l" 'dired-single-buffer))
#+end_src
** Interface tweaks
Dired feels more modern with prioritized icon fonts using *All the Icons*[fn:13]. This makes navigation and visually parsing directories much faster, given that file types are quickly identified by their corresponding icons.
#+begin_src emacs-lisp
(use-package all-the-icons)
#+end_src
Integration with *Dired*[fn:11] comes from the *All the Icons Dired*[fn:14]package.
#+begin_src emacs-lisp
(use-package all-the-icons-dired
:hook (dired-mode . all-the-icons-dired-mode))
#+end_src
* Shell
Another really incredible piece of kit, shipped with Emacs. *Eshell*[fn:15] is a fully POSIX compliant shell written entirely in Emacs Lisp. While not a traditional terminal emulator, it provides me with all of the functionality I expect and require from one. The infamous lambda prompt implemented with the *Eshell Prompt Extras*[fn:16] package.
#+begin_src emacs-lisp
(use-package eshell-prompt-extras
:custom (eshell-highlight-prompt nil)
(eshell-prefer-lisp-functions nil)
(eshell-prompt-function 'epe-theme-lambda))
#+end_src
Open an =eshell= buffer with =SPC e=.
#+begin_src emacs-lisp
(dotfiles/leader
"e" '(eshell :which-key "Shell"))
#+end_src
* Git
#+ATTR_ORG: :width 420px
#+ATTR_HTML: :width 420px
#+ATTR_LATEX: :width 420px
[[../docs/images/2021-02-13-example-magit.gif]]
Yet another hallmark feature of Emacs: *Magit*[fn:17] with the *darling* name, the developer stresses it's supposed to be *Magic* but with *Git*[fn:19]. It's a complete *Git*[fn:19] porcelain within Emacs.
#+begin_src emacs-lisp
(use-package magit
:commands magit-status
:custom (magit-display-buffer-function
#'magit-display-buffer-same-window-except-diff-v1))
#+end_src
Open the *status* page for the current repository with =SPC g=.
#+begin_src emacs-lisp
(dotfiles/leader
"g" '(magit-status :which-key "Magit"))
#+end_src
** GitHub integration
Interact with *Git*[fn:19] forges from *Magit*[fn:17] and Emacs using *Forge*[fn:18], requiring only a *GitHub*[fn:20] token to get started. If you're not sure what *GitHub*[fn:20] is, it's to *Git*[fn:19] what *Porn* is to *PornHub*. No citations!
+ Requires a valid ~$GITHUB_TOKEN~
#+begin_src emacs-lisp
(use-package forge
:after magit)
#+end_src
* Resources
[fn:1] https://vim.org
[fn:2] https://evil.readthedocs.io/en/latest/index.html
[fn:3] https://github.com/hlissner/doom-emacs/
[fn:4] https://spacemacs.org
[fn:5] https://github.com/justbur/emacs-which-key/
[fn:6] https://github.com/emacs-evil/evil-collection
[fn:7] https://github.com/emacs-evil/evil-surround
[fn:8] https://github.com/redguardtoo/evil-nerd-commenter
[fn:9] https://github.com/noctuid/general.el
[fn:10] https://github.com/abo-abo/hydra
[fn:11] https://en.wikipedia.org/wiki/Dired
[fn:12] https://github.com/crocket/dired-single
[fn:13] [[https://github.com/domtronn/all-the-icons.el]]
[fn:14] https://github.com/jtbm37/all-the-icons-dired
[fn:15] https://gnu.org/software/emacs/manual/html_node/eshell/index.html
[fn:16] https://github.com/zwild/eshell-prompt-extras
[fn:17] https://github.com/magit/magit
[fn:18] https://github.com/magit/forge
[fn:19] https://git-scm.com
[fn:20] https://github.com

211
modules/interface.el
View File

@ -1,211 +0,0 @@
;; Ivy
;; Download and configure [[https://oremacs.com/swiper/][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 [[https://github.com/Yevgnen/ivy-rich][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.
;; #+begin_example
;; 5:
;; 4:
;; 3:
;; 2:
;; 1:
;; 156: << CURRENT LINE >>
;; 1:
;; 2:
;; 3:
;; 4:
;; 5:
;; #+end_example
;; 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
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/what-is-emacs-customizable.gif]]
;; Cherry pick a few modules from =doom-emacs=. High quality and modern colour themes are provided in the [[https://github.com/hlissner/emacs-doom-themes][doom-themes]] package.
(use-package doom-themes
:init (load-theme 'doom-moonlight t))
;; [[https://github.com/seagle0128/doom-modeline][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 [[https://github.com/pretty-mode/pretty-mode][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 [[https://github.com/jming422/fira-code-mode][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
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/desktop.png]]
;; 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*")))

220
modules/projects.el
View File

@ -1,220 +0,0 @@
;; Projects
;; :PROPERTIES:
;; :header-args: :tangle modules/projects.el
;; :END:
;; An IDE like experience (or better) can be achieved in Emacs using two *Microsoft* open source initiatives.
;; + [[https://microsoft.github.io/language-server-protocol/][Language Server Protocol]]
;; + [[https://microsoft.github.io/debug-adapter-protocol/][Debug Adapter Protocol]]
;; Add support for language servers with [[https://emacs-lsp.github.io/lsp-mode/][lsp-mode]].
(use-package lsp-mode
:commands (lsp lsp-deferred)
:custom (lsp-idle-delay (* 5 dotfiles/idle)))
;; [[https://emacs-lsp.github.io/lsp-ui/][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))
;; [[https://emacs-lsp.github.io/dap-mode/][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 [[https://projectile.mx][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"))
;; 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 [[https://github.com/zweifisch/ob-http][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++
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/2021-02-13-example-ccls.gif]]
;; Add support for C/C++ languages.
;; + Configure the [[https://github.com/MaskRay/ccls][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))))
;; [[https://www.emacswiki.org/emacs/PythonProgrammingInEmacs][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 [[https://plantuml.com][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"))

294
modules/writing.el
View File

@ -1,294 +0,0 @@
;; Writing
;; :PROPERTIES:
;; :header-args: :tangle modules/writing.el
;; :END:
;; I am using [[https://orgmode.org][org-mode]] extensively for writing projects for different purposes. Most of the improvements are done in the *Core* module for the Literate programming configuration. Encrypt files using symmetric key encryption via PGP. This enables my workflow of storing my personal notes anywhere. Emacs can cache the gpg password if you trust your session.
(setq epa-file-select-keys 2
epa-file-cache-passphrase-for-symmetric-encryption t
epa-file-encrypt-to dotfiles/public-key)
;; Download and install [[https://github.com/integral-dw/org-superstar-mode][org-superstar-mode]] for making headline stars more *super*.
(use-package org-superstar
:after org
:hook (org-mode . org-superstar-mode))
;; Roam
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/2021-02-13-example-roam.png]]
;; Download and install [[https://orgroam.com][org-roam]], a plain text knowledge management system for Emacs.
(use-package org-roam
:hook (after-init . org-roam-mode)
:custom (org-roam-directory org-directory)
(org-roam-encrypt-files t)
(org-roam-capture-templates '())
(org-roam-dailies-capture-templates
'(("d" "Default" entry (function org-roam-capture--get-point)
"* %?"
:file-name "docs/daily/%<%Y-%m-%d>"
:head
"
#+TITLE: %<%Y-%m-%d>
#+AUTHOR: Christopher James Hayward
"))))
;; Place keybindings behind =SPC r=.
;; + Find with =f=
;; + Toggle buffer with =b=
;; + Dailies with =d=
;; + Arbitrary date with =d=
;; + Today with =t=
;; + Tomorrow with =m=
;; + Yesterday with =y=
(dotfiles/leader
"r" '(:ignore t :which-key "Roam")
"rf" '(org-roam-find-file :which-key "Find")
"rb" '(org-roam-buffer-toggle-display :which-key "Buffer")
"rd" '(:ignore t :which-key "Dailies")
"rdd" '(org-roam-dailies-find-date :which-key "Date")
"rdt" '(org-roam-dailies-find-today :which-key "Today")
"rdm" '(org-roam-dailies-find-tomorrow :which-key "Tomorrow")
"rdy" '(org-roam-dailies-find-yesterday :which-key "Yesterday"))
;; Visualize the org-roam database with the server, available when the editor is running at http://localhost:8080
(use-package org-roam-server
:hook (org-roam-mode . org-roam-server-mode))
;; Hugo
;; I use [[https://gohugo.io][Hugo]] for my personal [[https://chrishayward.xyz][website]], which I write in =org-mode= before compiling to =hugo-markdown=. [[https://github.com/kaushalmodi/ox-hugo][ox-hugo]], configured for =one-post-per-file= is my technique for managing my content.
(use-package ox-hugo
:after ox)
;; Posts
;; Add a capture template for creating new blog posts.
(with-eval-after-load 'org-roam
(add-to-list 'org-roam-capture-templates
'("p" "Post" plain (function org-roam-capture--get-point)
"%?"
:file-name "docs/posts/${slug}"
:unnarrowed t
:head
"
#+TITLE: ${title}
#+AUTHOR: Christopher James Hayward
#+DATE: %<%Y-%m-%d>
#+EXPORT_FILE_NAME: ${slug}
#+ROAM_KEY: https://chrishayward.xyz/posts/${slug}/
#+HUGO_BASE_DIR: ../
#+HUGO_AUTO_SET_LASTMOD: t
#+HUGO_SECTION: posts
#+HUGO_DRAFT: true
")))
;; Notes
;; Add a capture template for creating blog posts and notes on other peoples content / published works.
(with-eval-after-load 'org-roam
(add-to-list 'org-roam-capture-templates
'("n" "Notes" plain (function org-roam-capture--get-point)
"%?"
:file-name "docs/notes/${slug}"
:unnarrowed t
:head
"
#+TITLE: ${title}
#+AUTHOR: Christopher James Hayward
#+EXPORT_FILE_NAME: ${slug}
#+ROAM_KEY: https://chrishayward.xyz/notes/${slug}/
#+HUGO_BASE_DIR: ../
#+HUGO_AUTO_SET_LASTMOD: t
#+HUGO_SECTION: notes
#+HUGO_DRAFT: true
")))
;; Slides
;; Produce high quality presentations that work anywhere with =HTML/JS= and the [[https://revealjs.com][reveal.js]] package. [[https://github.com/hexmode/ox-reveal][ox-reveal]], configured to use a =cdn= allows us to produce ones that are not dependent on a local version of =reveal.js=.
(use-package ox-reveal
:after ox
:custom (org-reveal-root "https://cdn.jsdelivr.net/npm/reveal.js"))
;; Create a capture template for creating slides quickly, with our desired configuration.
(with-eval-after-load 'org-roam
(add-to-list 'org-roam-capture-templates
'("s" "Slides" plain (function org-roam-capture--get-point)
"%?"
:file-name "docs/slides/${slug}"
:unnarrowed t
:head
"
#+TITLE: ${title}
#+AUTHOR: Christopher James Hayward
#+EMAIL: chris@chrishayward.xyz
#+REVEAL_ROOT: https://cdn.jsdelivr.net/npm/reveal.js
#+REVEAL_THEME: serif
#+EXPORT_FILE_NAME: ${slug}
#+OPTIONS: reveal_title_slide:nil
#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
")))
;; Agenda
;; #+ATTR_ORG: :width 420px
;; #+ATTR_HTML: :width 420px
;; #+ATTR_LATEX: :width 420px
;; [[./docs/images/2021-02-13-example-agenda.gif]]
;; Override ~org-agenda-file-regexp~ to include =.org.gpg= files.
(unless (string-match-p "\\.gpg" org-agenda-file-regexp)
(setq org-agenda-file-regexp
(replace-regexp-in-string "\\\\\\.org" "\\\\.org\\\\(\\\\.gpg\\\\)?"
org-agenda-file-regexp)))
;; Create a capture template for courses.
(with-eval-after-load 'org-roam
(add-to-list 'org-roam-capture-templates
'("c" "Course" plain (function org-roam-capture--get-point)
"%?"
:file-name "docs/courses/${slug}"
:unnarrowed t
:head
"
#+TITLE: ${title}
#+SUBTITLE:
#+AUTHOR: Christopher James Hayward
#+EMAIL: chris@chrishayward.xyz
#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
")))
;; Configure agenda sources.
(setq org-agenda-files '("~/.emacs.d/docs/"
"~/.emacs.d/docs/courses/"
"~/.emacs.d/docs/daily/"))
;; Open an agenda buffer with =SPC a=.
(dotfiles/leader
"a" '(org-agenda :which-key "Agenda"))
;; Images
;; Capture screenshots with [[https://github.com/tecosaur/screenshot][screenshot.el]].
(use-package screenshot
:commands (screenshot))
;; Create screencasts with =one-frame-per-action= GIF recording via [[https://github.com/takaxp/emacs-gif-screencast][emacs-gif-screencast]].
;; + Pause / Resume
;; + High Quality
;; + Optimized
;; It requires the installation of ~scrot~, ~gifsicle~, and ~convert~ from the =ImageMagick= library.
(use-package gif-screencast
:commands (gif-screencast-start-or-stop gif-screencast-toggle-pause)
:custom (gif-screencast-output-directory (concat dotfiles/home "docs/images/")))
;; Place keybindings behind =SPC s=.
;; + Screenshot with =s=
;; + Screencast with =c=
(dotfiles/leader
"s" '(:ignore t :which-key "Screen")
"ss" '(screenshot :which-key "Screenshot")
"sc" '(gif-screencast-start-or-stop :which-key "Screencast"))
;; Grammar
;; I use [[https://github.com/bnbeckwith/writegood-mode][writegood-mode]] to find common writing problems such as cliches and poor wording. Grammarly for the peons!
(use-package writegood-mode
:after org
:config (writegood-mode))
;; Toggle ~writegood~ mode with =SPC t w=.
(dotfiles/leader
"tw" '(writegood-mode :which-key "Grammar"))
;; Spelling
;; Use the built in =ispell= package to add spell checking features to buffers.
(use-package ispell
:after org
:custom (ispell-dictionary dotfiles/lang))
;; Toggle highlighting within buffers with =SPC t s=.
(dotfiles/leader
"ts" '(flyspell-buffer :which-key "Spelling"))
Write Preview
Loading…
Cancel
Save