.emacs.d/config.org

* Emacs Configuration

Shout out to Harry R. Schwartz; A whole bunch of this config
(including the idea of embeddeding the lot in an Org document) is
yanked from [[https://github.com/hts/dotfiles][his dotfiles repo]].

The rest of this config grabs packages via =use-package=, so that
needs to be set up to install them if they aren't already.

#+begin_src emacs-lisp
  (require 'use-package-ensure)
  (setq use-package-always-ensure t)
#+end_src

** UI

The start-up message gets pretty annoying, so disable that.

#+begin_src emacs-lisp
  (setq inhibit-startup-screen t)
#+end_src

The default window size is just a little too small for my taste.

#+begin_src emacs-lisp
  (when window-system (set-frame-size (selected-frame) 90 48))
#+end_src

Also, the menu-, tool- and scroll-bar are ugly, take up space and I
don't use them.

#+begin_src emacs-lisp
  (menu-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
#+end_src

*** Colour Scheme

Currently using =spacemacs-theme='s light variant, but I prefer a pure
white background to the off-white it has by default.

#+begin_src emacs-lisp
  (use-package spacemacs-theme
	:defer t)
  (setq spacemacs-theme-custom-colors
		'((bg1 . "#ffffff")
		  (comment-bg . "#ffffff")))
  (load-theme 'spacemacs-light t)
#+end_src

*** Font

I am addicted to programming ligatures but Fira Code (my preferred
ligature font) requires some hackery to display properly; this is
defined in [[file:fira-code-mode/fira-code-mode.el][fira-code-mode.el]] so first we load that.

#+begin_src emacs-lisp
  (add-to-list 'load-path "/home/cdo/.emacs.d/fira-code-mode")
  (require 'fira-code-mode)
#+end_src

And then make sure that mode is enabled for any =prog-mode= buffer.

#+begin_src emacs-lisp
  (add-hook 'prog-mode-hook 'fira-code-mode)
#+end_src

** Magit

=magit= is truly a wonderful creation! Only deviations from defaults
here are a keybinding for =magit-status= and a maximum length for the
summary line of commit messages (after which the excess is
highlighted).

#+begin_src emacs-lisp
  (use-package magit
	:bind
	("C-x g" . magit-status)
	:config
	(setq git-commit-summary-max-length 50))
#+end_src

** Language Integrations

Generally, 8-character-wide tabs are not my thing.

#+begin_src emacs-lisp
  (setq-default tab-width 4)
  (setq-default basic-offset 4)
#+end_src

*** C

For C, I like to indent with tabs and align with spaces: this
behaviour is provided by =smart-tabs-mode=. 

#+begin_src emacs-lisp
  (use-package smart-tabs-mode)
  (smart-tabs-insinuate 'c)
#+end_src

I'll generally format my code in BSD style but I also use
=clang-format= a lot, so I have a keybinding to run that.

#+begin_src emacs-lisp
  (setq c-default-style "bsd")
  (use-package clang-format)
  (add-hook 'c-mode-hook
			(lambda ()
			  (define-key c-mode-map (kbd "C-M-f")
				'clang-format-buffer)))
#+end_src

Meson is my build system of choice for C, but I also use CMake a lot.

#+begin_src emacs-lisp
  (use-package meson-mode)
  (use-package cmake-mode)
#+end_src

*** Haskell

My workflow with Haskell is very REPL-based, so I always want
=interactive-haskell-mode= on.

#+begin_src emacs-lisp
  (use-package haskell-mode)
  (require 'haskell-interactive-mode)
  (add-hook 'haskell-mode-hook 'interactive-haskell-mode)
#+end_src

And, of course, that REPL needs to be taking advantage of parallelism!

#+begin_src emacs-lisp
  (require 'haskell-process)
  (set-variable 'haskell-process-args-ghci
				'("-threaded" "+RTS" "-N8" "-RTS"))
#+end_src

*** Idris

The only thing to change from the defaults here is to add a more
convenient way to case-split.

#+begin_src emacs-lisp
  (use-package idris-mode)
  (add-hook 'idris-mode-hook
            (lambda ()
              (define-key idris-mode-map (kbd "C-c SPC")
                'idris-case-split)))
#+end_src

*** Rust

I never really use Rust without Cargo, so always turn on the minor
mode for Cargo in Rust buffers.

#+begin_src emacs-lisp
  (use-package rust-mode)
  (use-package cargo)
  (add-hook 'rust-mode-hook 'cargo-minor-mode)
#+end_src

*** Lisps

Get =racket-mode= for some Racket-specific things, like searching documentation

#+begin_src emacs-lisp
  (use-package racket-mode)
#+end_src

=paredit= is generally very useful for balancing parenthesis so we
want that turned on for all the lisps. Additionally, it's nice to have
an entire expression highlighted when the cursor is on one of its
enclosing parens.

#+begin_src emacs-lisp
  (use-package paredit)
  (setq lispy-mode-hooks
		'(emacs-lisp-mode-hook
		  lisp-mode-hook
		  racket-mode-hook
		  scheme-mode-hook))
  (dolist (hook lispy-mode-hooks)
	(add-hook hook (lambda ()
					 (setq show-paren-style 'expression)
					 (paredit-mode))))
#+end_src

** Org-mode

I use a couple non-standard bits and pieces, but not a whole bunch. I
really like the =<s= to insert a source block thing (which was
deprecated); =org-tempo= brings that back.

#+begin_src emacs-lisp
  (use-package org
	:ensure org-plus-contrib
	:config
	(require 'org-tempo))
#+end_src

Org is better suited as scratch space than Emacs lisp, I'd say.

#+begin_src emacs-lisp
  (setq initial-major-mode 'org-mode)
#+end_src

*** Source Blocks

Pressing tab inside a source block should indent appropriately for its
language.

#+begin_src emacs-lisp
  (setq org-src-tab-acts-natively t)
#+end_src

=babel= lets us evaluate Org documents containing source blocks! I
currently only use it for this very file, so it's only turned on for
Emacs lisp.

#+begin_src emacs-lisp
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)))
#+end_src

*** HTML Exporting

=htmlize= is needed for decent HTML exporting, and there is no need
for all that stuff at the bottom.

#+begin_src emacs-lisp
  (use-package htmlize)
  (setq org-html-postamble nil)
#+end_src