ryuslash/dotfiles
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
dotfiles/emacs/.emacs.d/init.org

1711 lines
47 KiB
Org Mode
Raw Blame History

#+TITLE: Tom-Emacs Interface
#+STARTUP: content
#+MACRO: key @@html:<kbd>$1</kbd>@@@@ascii:`$1'@@
This is my personal Emacs configuration. The name was inspired by
"Ghost in the Shell 2: Man-Machine Interface" and Ryan Rix's "Complete
Computing Environment".
* Preamble
These are some settings that need to be taken care of before the
rest.
** Lexical binding
To start off, first I need to enable lexical binding. It offers
better performance in some circumstances and enables me to use cool
things such as closures.
#+BEGIN_SRC emacs-lisp :padline no
;; -*- lexical-binding: t; -*-
#+END_SRC
** Load path
Emacs' load path is where it looks to find Emacs Lisp files when
confronted with a ~load~ or ~require~ form. Most of my packages are
managed through the package manager, but not all of them.
*** Mode-specific configuration directory
Add the directory with my mode-specific configuration files to the
load path.
#+BEGIN_SRC emacs-lisp
(add-to-list 'load-path (locate-user-emacs-file "init/"))
#+END_SRC
*** Vendor directory
Add all my vendored packages to the load path.
#+BEGIN_SRC emacs-lisp
(eval-and-compile
(mapc (lambda (d) (add-to-list 'load-path d))
(directory-files
(locate-user-emacs-file "vendor-lisp/") t "^[^.]")))
#+END_SRC
*** Site lisp
Setup everything so that any autoloads in =site-lisp/= get loaded
and can be used.
#+BEGIN_SRC emacs-lisp
(eval-and-compile
(add-to-list 'load-path (locate-user-emacs-file "site-lisp/"))
(let ((loaddefs (locate-user-emacs-file "site-lisp/site-autoloads.el")))
(when (file-exists-p loaddefs)
(load loaddefs))))
#+END_SRC
** Helper functions
Some things are best abstracted into special functions and/or
macros so as not to make the setting itself too verbose.
I have some helper functions stored away in a separate file.
#+BEGIN_SRC emacs-lisp
(require 'oni-helpers)
#+END_SRC
** Package configuration
Since Emacs 24 there has been a package manager in Emacs. A lot of
packages have been added to a number of package repositories.
*** Load the package manager
Require package.el since I immediately start using its variables
and functions anyway, no need to delay loading.
#+BEGIN_SRC emacs-lisp
(require 'package)
#+END_SRC
*** Add package archives
The default package archive has some pretty neat packages, but the
Melpa package archive is much more popular because it doesn't
require copyright assignment to upload packages to it and it is
well integrated with git.
I add these archives both at compile-time and run-time because I
install missing packages at compile-time. If the archives aren't
added then, the packages can't be installed.
**** Add Melpa
Add the Melpa package archive because I like living on the
bleeding edge.
#+BEGIN_SRC emacs-lisp
(eval-and-compile
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/")))
#+END_SRC
**** Add org
Add the org package archive because it hosts the latest org
development release, and as stated above, I like living on the
bleeding edge.
#+BEGIN_SRC emacs-lisp
(eval-and-compile
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/")))
#+END_SRC
*** Initialize the package manager
Initialize package.el so that packages can be loaded and used.
This also needs to be done at both run-time and compile-time so
packages can be installed at compile-time.
#+BEGIN_SRC emacs-lisp
(eval-and-compile (package-initialize))
#+END_SRC
*** Install missing packages
Refresh the package contents so packages can be installed from all
configured archives. Don't do this at run-time because it slows
down the process too much. Afterwards
#+BEGIN_SRC emacs-lisp
(eval-when-compile
(let* ((not-installed (seq-remove 'package-installed-p
package-selected-packages))
(available (seq-filter (lambda (p)
(assq p package-archive-contents))
not-installed))
(difference (- (length not-installed) (length available))))
(when (> difference 0)
(silently "Refresh packages"
(package-refresh-contents)))
(when available
(mapc (lambda (p) (package-install p t)) available))))
#+END_SRC
* General settings
These settings are generally not associated with a specific mode,
but affect how the core of Emacs behaves.
** Files
There are a lot of files that Emacs uses to keep track of things. I
usually prefer to keep them all in one place together, instead of
spreading them around the filesystem. With exceptions of course.
*** Backups
I don't like having every directory filled with "filename~" files.
So instead of saving backup files to the same directory, save them
to a special one instead.
#+BEGIN_SRC emacs-lisp
(setq backup-directory-alist `((".*" . ,(oni:data-location "backup-files/"))))
#+END_SRC
*** Auto saves
I prefer to keep all autosave files in a single directory so they
don't clog up my filesystem so much.
**** Auto save files
Usually these files get deleted, but sometimes they don't, and I
don't think they look pretty. Add it to the end of the list
because the default value stores auto-saves for remote files in
/tmp, which is fine by me.
#+BEGIN_SRC emacs-lisp
(add-to-list 'auto-save-file-name-transforms
`(".*" ,(oni:data-location "auto-save-files/") t) :append)
#+END_SRC
**** Auto save indexes
Place the files which contain the indexes of auto save files in a
similar directory.
#+BEGIN_SRC emacs-lisp
(setq auto-save-list-file-prefix (oni:data-location "auto-save-list/.saves-"))
#+END_SRC
*** Additional file type mappings
Load =*.js= files with [[JavaScript IDE mode]]. ~js2-mode~ is a better
JavaScript mode than plain old ~js-mode~.
#+BEGIN_SRC emacs-lisp
(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
#+END_SRC
** Global Keybindings
Bind expand-region, which functions a lot like a better
~mark-sexp~.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "C-M-SPC") 'er/expand-region)
#+END_SRC
Using multiple cursors can be really handy when you have the same
edits to make on multiple levels.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "M-+") 'mc/mark-next-like-this)
#+END_SRC
I've been looking for something like Embrace for a long time. I
really like the =surround.vim= module for vim (which I've only used
as =evil-surround= in =evil-mode=). Though because Emacs is not a
moded editor like vim, it's hard to find the right way to do
things.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "C-c (") 'embrace-commander)
#+END_SRC
*** Hydra
Hydra is an interesting way of managing keybindings, I want to
experiment.
Add a hydra for org.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "C-c o") 'oni-hydra-org/body)
#+END_SRC
Add a hydra for magit.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "C-c m") 'oni-hydra-magit/body)
#+END_SRC
* Typographic style
Emacs being a text editor has options on how to handle your text.
** Whitespace
Even though whitespace technically isn't seen, it can still be an
eyesore and highly annoying, you must always keep it well in check.
*** Remove trailing whitespace before saving
I hate it when trailing whitespace is left around a file. I've
been using this for years, and apart from having some trouble
working with people who don't pay attention to it, it has worked
flawlessly.
#+BEGIN_SRC emacs-lisp
(require 'destroy-trailing-whitespace)
(global-destroy-trailing-whitespace-mode)
#+END_SRC
*** Make sure there is a newline at the end of the file
Having a final newline at the end of the file is always a good
idea. Some programs just don't work without it and others produce
some strange results. Github diffs are an example.
#+BEGIN_SRC emacs-lisp
(setq require-final-newline t)
#+END_SRC
*** Tabs
Unless absolutely necessary, I really don't want any tabs in my
code.
**** Don't use tabs for indentation
Generally I prefer using spaces over tabs. Especially for
lisp-like languages.
#+BEGIN_SRC emacs-lisp
(setq-default indent-tabs-mode nil)
#+END_SRC
**** Display tabs as 4 columns wide
A tab-width of 8 is too wide for me, and 2 is too narrow. 4 is
just right.
#+BEGIN_SRC emacs-lisp
(setq-default tab-width 4)
#+END_SRC
*** Sentences end with a single space
I'm not an American, and I don't follow American grammatical rules
when I write. I have always ended my sentences with a single space
and I'm sure I'll always keep doing that.
#+BEGIN_SRC emacs-lisp
(setq sentence-end-double-space nil)
#+END_SRC
** User Interface
Emacs' user interface is very configurable, from themes to hiding
unnecessary elements.
*** Inhibit startup screen
I've been using Emacs long enough not to need the startup screen
anymore. I don't see it on my PC where I start Emacs in daemon
mode, but on my laptop I always start it normally, so it gets in
the way.
#+BEGIN_SRC emacs-lisp
(setq inhibit-startup-screen t)
#+END_SRC
*** Font
Set the default font to a more pleasing one, in my opinion, with a
better size as well.
#+BEGIN_SRC emacs-lisp
(add-to-list 'default-frame-alist '(font . "Fantasque Sans Mono-15"))
#+END_SRC
*** Internal border
For aesthetics I like to have a thick border on the inside of my
Emacs window. I have the same border in URxvt, but I haven't found
out how to add it to Conkeror yet.
#+BEGIN_SRC emacs-lisp
(add-to-list 'default-frame-alist '(internal-border-width . 15))
#+END_SRC
*** Menu bar
I don't use the menu bar, so it just takes up space.
#+BEGIN_SRC emacs-lisp
(menu-bar-mode -1)
#+END_SRC
*** Tool bar
I don't use the tool bar, so it just takes up space.
#+BEGIN_SRC emacs-lisp
(tool-bar-mode -1)
#+END_SRC
*** Scroll bar
I don't use the scroll bar to either navigate my buffers or see
whereabouts I am, so they just take up space.
#+BEGIN_SRC emacs-lisp
(scroll-bar-mode -1)
#+END_SRC
*** Cursor
Use a bar cursor instead of a box.
#+BEGIN_SRC emacs-lisp
(setq-default cursor-type '(bar . 2))
#+END_SRC
*** Long lines
By default Emacs wraps long lines around to the next line when
they reach the far end of the window. However I prefer to have
them truncated instead.
#+BEGIN_SRC emacs-lisp
(setq-default truncate-lines t)
#+END_SRC
*** Suspend
The {{{key(C-z)}}} key in a terminal suspends the current
application to the background and lets you do other things on the
command line without having to fully close the application. In GUI
Emacs this minimizes the current frame. I have no place for it to
minimize to (no task bar or anything), so this just freezes my
frame. To prevent this from happening I unbind the {{{key(C-z)}}}
key.
#+BEGIN_SRC emacs-lisp
(global-unset-key (kbd "C-z"))
#+END_SRC
*** Don't ask for yes or no
One of the more annoying things can be when Emacs starts asking
for confirmation and you have to type in =yes= or =no=. I get that
this is to prevent you from accidentally performing an action, but
just =y= or =n= has since 2008 not made me accidentally perform
any action I didn't mean to.
#+BEGIN_SRC emacs-lisp
(defalias 'yes-or-no-p 'y-or-n-p)
#+END_SRC
*** Show any matching parenthesis
When working in Lisp code (but other code as well) it can be very
handy to see which parenthesis the one near the cursor matches.
#+BEGIN_SRC emacs-lisp
(show-paren-mode)
#+END_SRC
* Theme
Load my personal theme. I sometimes change it to a different theme,
but for some reason I always come crawling back to it.
#+BEGIN_SRC emacs-lisp
(add-to-list 'custom-theme-load-path
(concat user-emacs-directory "vendor-lisp/yoshi-theme"))
(load-theme 'yoshi :no-confirm)
#+END_SRC
Load my personal SVG mode-line theme.
#+BEGIN_SRC emacs-lisp
(require 'svg-mode-line-themes)
(require 'oni-smt)
(smt/enable)
(smt/set-theme 'oni-smt)
#+END_SRC
Because SVG mode-line themes doesn't include the box around the
mode-line, remove it (my personal theme adds it as padding).
#+BEGIN_SRC emacs-lisp
(set-face-attribute 'mode-line nil :box nil)
(set-face-attribute 'mode-line-inactive nil :box nil)
#+END_SRC
* Diminish
I really don't need to see some of the minor modes.
#+BEGIN_SRC emacs-lisp
(require 'diminish)
#+END_SRC
* Ivy
Ivy is a completing read implementation that offers choises
vertically. I'm surprised how much I like it. I've tried Swiper
before and I didn't like that so much.
Since I immediately use and enable Ivy, there's no need to autoload
it, so require it to keep the byte-compiler quiet.
#+BEGIN_SRC emacs-lisp
(require 'ivy)
#+END_SRC
Don't show that ivy is enabled in the mode-line. It's enabled
globally and I'll notice it from other things anyway (like it
showing up).
#+BEGIN_SRC emacs-lisp
(diminish 'ivy-mode)
#+END_SRC
Enable Ivy.
#+BEGIN_SRC emacs-lisp
(ivy-mode)
#+END_SRC
* Counsel
Counsel is a group of functions that use Ivy to specialize on
certain built-in commands, such as {{{key(M-x)}}}.
Since I enable Counsel mode immediately, there's no point in leaving
it to be autoloaded. Requiring it keeps the byte-compiler happy.
#+BEGIN_SRC emacs-lisp
(require 'counsel)
#+END_SRC
Hide dotfiles in ~counsel-find-file~.
#+BEGIN_SRC emacs-lisp
(setq counsel-find-file-ignore-regexp
(rx (or (and bos ".")
(and ".zwc" eos))))
#+END_SRC
Enable Counsel.
#+BEGIN_SRC emacs-lisp
(counsel-mode)
#+END_SRC
Don't show that counsel is enabled in the mode-line. It's enabled
globally and I'll notice whenever I press {{{key(M-x)}}} for
example.
#+BEGIN_SRC emacs-lisp
(diminish 'counsel-mode)
#+END_SRC
* Bookmarks
Save bookmarks in my data directory so my ~user-emacs-directory~ is
less cluttered.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'bookmark))
(setq bookmark-default-file (oni:data-location "bookmarks"))
#+END_SRC
* Personal info
Set some personal info for, for example, Gnus to use.
#+BEGIN_SRC emacs-lisp
(setq user-full-name "Tom Willemse"
user-mail-address "tom@ryuslash.org")
#+END_SRC
* Automatic alignment
Emacs has some powerful automatic alignment features.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'align))
#+END_SRC
** CSS
Align CSS files like so:
#+BEGIN_SRC css
body { color: #ffffff; }
.some-class { background-color: #ffffff; }
#some-id { width: 200px; }
.some-more-class {
color: #ffffff;
background-color: #ffffff;
width: 200px;
}
#+END_SRC
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'align
;; Keep these in order. They are each added to the _front_ of the
;; list and are applied in order. Changing their order will change
;; the results.
(add-to-list 'align-rules-list
`(css-closing-brace
(regexp . ,(rx (group (0+ whitespace)) "}" eol))
(group . (1))
(modes . '(scss-mode css-mode))))
(add-to-list 'align-rules-list
`(css-colons
(regexp . ,(rx bol
(0+ whitespace)
(1+ (any (?a . ?z) ?- ?$))
":"
(group (0+ whitespace))
(0+ nonl)
";"
eol))
(group . (1))
(modes . '(scss-mode css-mode))
(repeat . t)))
(add-to-list 'align-rules-list
`(css-opening-brace
(regexp . ,(rx bol
(0+ whitespace)
(0+ (any ?# ?. ?, ?\s ?& ?: ?-
(?a . ?z) (?A . ?Z) (?0 . ?9)))
(any (?a . ?z) (?A . ?Z) (?0 . ?9))
(group (0+ whitespace))
"{"
(0+ nonl)))
(group . (1))
(modes . '(scss-mode css-mode)))))
#+END_SRC
** PHP
In PHP code it's nice to have any ~=>~ aligned.
#+BEGIN_SRC php
<?php
array(
'foo' => 'bar',
'frob' => 'baz'
);
?>
#+END_SRC
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'align
(add-to-list 'align-rules-list
`(php-array-arrow
(regexp . ,(rx any (group whitespace) "=>" any))
(group . (1))
(modes . '(php-mode web-mode))
(repeat . t))))
#+END_SRC
* Url browsing
Use Firefox to open URLs.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'browse-url))
(with-eval-after-load 'browse-url
(setq browse-url-browser-function 'browse-url-firefox))
#+END_SRC
* Minibuffer
Enable Electric pair mode in the minibuffer. I tried Paredit for a
little while, but I forgot that it isn't always only lisp that I'm
entering in the minibuffer.
#+BEGIN_SRC emacs-lisp
(add-hook 'minibuffer-setup-hook 'electric-pair-local-mode)
#+END_SRC
* Shackle
Shackle is an abstraction over ~display-buffer-alist~.
#+BEGIN_SRC emacs-lisp
(require 'shackle)
(shackle-mode)
#+END_SRC
* Libraries
- [[file:init/oni-shr-init.org][shr]]
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'shr (load "oni-shr-init"))
#+END_SRC
* Minor modes
- [[file:init/oni-company-init.org][Company mode]] :: A better auto completion system than auto
complete.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'company (load "oni-company-init"))
#+END_SRC
** Paredit
Paredit is an awesome minor-mode to have when you write in any
lisp-like languages. It can feel rather strict and uncomfortable at
first, but once you get the hang of using it, you won't want to
live without it.
Don't show that paredit is enabled, it should be obvious from the
effects it has. This will save some precious real-estate on my mode
line.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'paredit
(diminish 'paredit-mode))
#+END_SRC
** Electric indent mode
By default ~electric-indent-mode~ is enabled globally, but I prefer
to enable it locally where I need it.
#+BEGIN_SRC emacs-lisp
(electric-indent-mode -1)
#+END_SRC
Since Emacs 24 ~electric-indent-mode~ switches the behavior of the
{{{key(C-j)}}} and {{{key(RET)}}} keys. I prefer the original
situation because my muscle-memory still remembers to use
{{{key(C-j)}}} for newline-and-indent behaviour.
#+BEGIN_SRC emacs-lisp
(defun oni:switch-newline-keys ()
"Switch the C-j and RET keys in the local buffer."
(if electric-indent-mode
(progn
(local-set-key (kbd "C-j") 'newline)
(local-set-key (kbd "RET") 'electric-newline-and-maybe-indent))
(local-unset-key (kbd "C-j"))
(local-unset-key (kbd "RET"))))
(add-hook 'electric-indent-local-mode-hook #'oni:switch-newline-keys)
#+END_SRC
** Flycheck
Flycheck lets me see (compiler) errors, warnings and info messages
while writing code.
When developing packages with Cask, some special care needs to be
taken to ensure the checkers work correctly.
#+BEGIN_SRC emacs-lisp
(add-hook 'flycheck-mode-hook 'flycheck-cask-setup)
#+END_SRC
I disable the pylint and pyflakes checkers because they don't seem
to add much except noise when used together with flake8. Also
pylint seems hell-bent on making Python written like a
statically-typed langauge.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'flycheck
(mapc (lambda (c) (delq c flycheck-checkers))
'(python-pylint python-pyflakes)))
#+END_SRC
Also show which columns messages appear in.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'flycheck
(setq flycheck-highlighting-mode 'columns))
#+END_SRC
Show the error message at point in a tooltip.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'flycheck
(require 'flycheck-pos-tip)
(flycheck-pos-tip-mode))
#+END_SRC
Shorten the flycheck mode line lighter.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'flycheck
(setq flycheck-mode-line-prefix "✓"))
#+END_SRC
** Auto revert mode
ARev isn't very descriptive, and fairly wide. Use a font-awesome
icon instead.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'autorevert
(diminish 'auto-revert-mode
(propertize (concat " " (char-to-string #xf021))
'face '(:family "Font Awesome" :height 0.75))))
#+END_SRC
** Auto fill mode
"Fill" is fine as a mode-line lighter, but I prefer something
shorter.
#+BEGIN_SRC emacs-lisp
(diminish 'auto-fill-function
(propertize (concat " " (char-to-string #xf149))
'face '(:family "Font Awesome" :height 0.75)))
#+END_SRC
** Diff highlight mode
Show the state of lines added, changed and removed since the last
commit.
#+BEGIN_SRC emacs-lisp
(require 'diff-hl)
(global-diff-hl-mode)
#+END_SRC
Add p4 options for diff-hl to fix diff highlighting in Perforce projects.
#+BEGIN_SRC emacs-lisp
(defun oni:with-diff-hl-p4-args (orig-fun &rest args)
(let ((p4-lowlevel-diff-switches '("-du0")))
(apply orig-fun args)))
(with-eval-after-load 'vc-p4
(add-function :around (symbol-function 'diff-hl-changes-buffer)
#'oni:with-diff-hl-p4-args))
#+END_SRC
** Isearch
Replace the Isearch mode line lighter with a magnifying glass icon.
#+BEGIN_SRC emacs-lisp
(diminish 'isearch-mode
(propertize (concat " " (char-to-string #xf002))
'face '(:family "Font Awesome" :height 0.75)))
#+END_SRC
** Projectile
Projectile is, thus far, the best project module for Emacs.
Set the known projects file before loading projectile because
projectile loads the known projects as it's loading, not after.
#+BEGIN_SRC emacs-lisp
(setq projectile-known-projects-file
(oni:data-location "projectile-bookmarks.eld"))
#+END_SRC
Since I'm just going to use it anyway, require it immediately.
#+BEGIN_SRC emacs-lisp
(require 'projectile)
#+END_SRC
I don't like that projectile tries to take up so much space in my
mode-line, so I try to make it a little shorter.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'projectile
(setq projectile-mode-line
'(:eval
(if (file-remote-p default-directory)
" P"
(let ((name (projectile-project-name)))
(if (string= "-" name)
""
(format " P[%s]" name)))))))
#+END_SRC
Store projectile files in my data dir.
#+BEGIN_SRC emacs-lisp
(setq projectile-cache-file
(oni:data-location "projectile.cache"))
#+END_SRC
Enable it globally so I can always switch to/from projects.
#+BEGIN_SRC emacs-lisp
(projectile-mode)
#+END_SRC
Use Ivy for projectile completions.
#+BEGIN_SRC emacs-lisp
(setq projectile-completion-system 'ivy)
#+END_SRC
Add ~yarn.lock~ as a possible root file for Projectile.
#+BEGIN_SRC emacs-lisp
(add-to-list 'projectile-project-root-files "yarn.lock")
#+END_SRC
** Server mode
Diminish server mode with a nice icon.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'server
(diminish 'server-buffer-clients
(propertize (concat " " (char-to-string #xf233))
'face '(:family "Font Awesome" :height 0.75))))
#+END_SRC
** Slime
Slime is crucial for developing Common Lisp programs. Set the
available Lisp implementations and the default implementation to
use.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'slime
(setq slime-lisp-implementations
'((sbcl ("sbcl" "--noinform") :coding-system utf-8-unix)
(clisp ("clisp") :coding-system utf-8-unix)))
(setq slime-default-lisp 'sbcl)
(slime-setup '(slime-fancy slime-company)))
#+END_SRC
* Major modes
Configuration for major modes is specified in dedicated
configuration files.
- [[file:init/js-mode.org][js-mode]] :: JavaScript mode is used by me for json files. js2-mode
doesn't work very nicely with json, always showing syntax
errors.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'js (load "oni-js-mode-init"))
#+END_SRC
- [[file:init/php-mode-init.org][php-mode]] :: I use PHP mode for files that only contain PHP code,
no HTML or anything.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'php-mode (load "oni-php-mode-init"))
#+END_SRC
- [[file:init/sh-mode-init.org][sh-mode]] :: Used for most types of shell scripting (bash, zsh,
etc.).
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'sh-mode (load "oni-sh-mode-init"))
#+END_SRC
- [[file:init/oni-css-mode-init.org][css-mode]] :: CSS and SCSS mode are used for stylesheets!
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'css-mode (load "oni-css-mode-init"))
#+END_SRC
- [[file:init/oni-emacs-lisp-mode-init.org][emacs-lisp-mode]] :: Emacs lisp is what powers all this Emacs
awesomeness.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'elisp-mode (load "oni-emacs-lisp-mode-init"))
#+END_SRC
- [[file:init/oni-scheme-init.org][scheme-mode]] :: Scheme is an awesome lisp variant.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'scheme (load "oni-scheme-init"))
#+END_SRC
- [[file:init/oni-compilation-init.org][compilation-mode]] :: Major mode for various compilation processes.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'compile (load "oni-compilation-init"))
#+END_SRC
- [[file:init/oni-java-init.org][java-mode]] :: Major mode for the Java programming language.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'cc-mode (load "oni-java-init"))
#+END_SRC
** Inferior Emacs lisp mode (ielm)
Enable paredit mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'ielm-mode-hook 'paredit-mode)
#+END_SRC
** Mbsync configuration mode
I wrote a simple major-mode for editing my =.mbsyncrc= file. I
might release it as a package, but for now I keep it with the rest
of my configuration.
Since it isn't installed by package.el, I need to specify the
autoload myself.
#+BEGIN_SRC emacs-lisp
(autoload 'mbsync-conf-mode "mbsync-conf-mode"
"Major mode for editing mbsync configuration files."
:interactive)
#+END_SRC
I also need to add it to the ~auto-mode-alist~ so =.mbsyncrc= is
opened with mbsync conf mode.
#+BEGIN_SRC emacs-lisp
(add-to-list 'auto-mode-alist '("\\.mbsyncrc\\'" . mbsync-conf-mode))
#+END_SRC
** Msmtprc mode
I wrote a simple major-mode for editing my =.msmtprc= file. I might
release it as a package, but for now I keep it with the rest of my
configuration.
Since it isn't installed by package.el, I need to specify the
autoload myself.
#+BEGIN_SRC emacs-lisp
(autoload 'msmtprc-mode "msmtprc-mode"
"Major mode for editing msmtp configuration files."
:interactive)
#+END_SRC
I also need to add it to the ~auto-mode-alist~ so =.msmtprc= is
opened with msmtprc mode.
#+BEGIN_SRC emacs-lisp
(add-to-list 'auto-mode-alist '("\\.msmtprc\\'" . msmtprc-mode))
#+END_SRC
** Git commit mode
Enable ~electric-quote-local-mode~ to easily type nice-looking
quotes while writing commits.
#+BEGIN_SRC emacs-lisp
(add-hook 'git-commit-mode-hook 'electric-quote-local-mode)
#+END_SRC
** Python mode
Enable electric pair mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'python-mode-hook 'electric-pair-local-mode)
#+END_SRC
Enable syntax and style checking with flycheck.
#+BEGIN_SRC emacs-lisp
(add-hook 'python-mode-hook 'flycheck-mode)
#+END_SRC
** Web mode
Web mode is a good general-purpose web template mode. It works well
with many template languages and PHP as well.
Enable a specialized whitespace mode for web mode that shows tabs
at the beginning of a line.
#+BEGIN_SRC emacs-lisp
(add-hook 'web-mode-hook 'oni-whitespace-only-tabs-mode)
#+END_SRC
** Makefile mode
Show tabs in Makefiles. Tabs are required at the beginning of any
non-continuation line in a recipe. I don't use it for indenting,
however.
#+BEGIN_SRC emacs-lisp
(add-hook 'makefile-mode-hook 'oni-whitespace-only-tabs-mode)
#+END_SRC
Enable electric pairing.
#+BEGIN_SRC emacs-lisp
(add-hook 'makefile-mode-hook 'electric-pair-local-mode)
#+END_SRC
** Clojure mode
Install extra font-locking for clojure.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'clojure-mode
(require 'clojure-mode-extra-font-locking))
#+END_SRC
Enable paredit mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'clojure-mode-hook 'paredit-mode)
#+END_SRC
Enable rainbow delimiters.
#+BEGIN_SRC emacs-lisp
(add-hook 'clojure-mode-hook 'rainbow-delimiters-mode)
#+END_SRC
Use the clojure repl as the inferior lisp mode.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'inf-lisp))
(defun oni:clojure-set-inferior-lisp ()
(setq inferior-lisp-program "lein repl"))
#+END_SRC
Add a little more font locking still, and some indentation. This is
included in the Clojure for the Brave and True configuration.
#+BEGIN_SRC emacs-lisp
(add-hook 'clojure-mode-hook 'oni-clojure-add-font-lock)
(add-hook 'clojure-mode-hook 'oni-clojure-add-indent)
#+END_SRC
** Cider mode
Cider is like Slime for Common Lisp. This configuration is copied
from the one provided by Clojure for the Brave and True.
Go right to the REPL buffer when it's finished connecting
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'cider
(setq cider-repl-pop-to-buffer-on-connect t))
#+END_SRC
When there's a cider error, show its buffer and switch to it.
#+BEGIN_SRC emacs-lisp
(setq cider-show-error-buffer t
cider-auto-select-error-buffer t)
#+END_SRC
Where to store the cider history.
#+BEGIN_SRC emacs-lisp
(setq cider-repl-history-file
(oni:data-location "cider-history"))
#+END_SRC
Wrap when navigating history.
#+BEGIN_SRC emacs-lisp
(setq cider-repl-wrap-history t)
#+END_SRC
Enable paredit in your REPL.
#+BEGIN_SRC emacs-lisp
(add-hook 'cider-repl-mode-hook 'paredit-mode)
#+END_SRC
** C Mode
Enable electric pair mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'c-mode-hook 'electric-pair-local-mode)
#+END_SRC
Enable electric indent mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'c-mode-hook 'electric-indent-local-mode)
#+END_SRC
** Lisp mode
Enable paredit mode for Common Lisp programming.
#+BEGIN_SRC emacs-lisp
(add-hook 'lisp-mode-hook 'paredit-mode)
#+END_SRC
Enable rainbow-delimiters mode for Common Lisp programming.
#+BEGIN_SRC emacs-lisp
(add-hook 'lisp-mode-hook 'rainbow-delimiters-mode)
#+END_SRC
Enable company mode for Common Lisp programmind.
#+BEGIN_SRC emacs-lisp
(add-hook 'lisp-mode-hook 'company-mode)
#+END_SRC
** JavaScript IDE mode
:PROPERTIES:
:header-args: :tangle "init/oni-js2-init.el"
:END:
Since ~js2-mode~ isn't loaded when Emacs starts put the
configuration in a different file so that it doesn't cause a
slowdown in startup time.
#+BEGIN_SRC emacs-lisp :tangle yes
(with-eval-after-load 'js2-mode (load "oni-js2-init"))
#+END_SRC
Keep the byte-compiler happy by requiring ~js2-mode~, by this time
it will have been loaded anyway.
#+BEGIN_SRC emacs-lisp
(require 'js2-mode)
#+END_SRC
Silence warnings about trailing commas in JavaScript code. I usually
write code that goes through Babel or something similar and doesn't
actually die when a trailing comma is present. Also this should
really be handled by a linter such as eslint.
#+BEGIN_SRC emacs-lisp
(setq js2-strict-trailing-comma-warning nil)
#+END_SRC
Enable ~subword-mode~ because a lot of JavaScript identifiers look
either like =someIdentifier= or =SomeClassName=.
#+BEGIN_SRC emacs-lisp
(add-hook 'js2-mode-hook 'subword-mode)
#+END_SRC
Enable ~flycheck-mode~ to run syntax checkers such as eslint.
#+BEGIN_SRC emacs-lisp
(add-hook 'js2-mode-hook 'flycheck-mode)
#+END_SRC
Set the default indentation to 2 spaces.
#+BEGIN_SRC emacs-lisp
(setq js2-basic-offset 2)
#+END_SRC
Enable company mode for completions.
#+BEGIN_SRC emacs-lisp
(add-hook 'js2-mode-hook 'company-mode)
#+END_SRC
Enable Fill Column Indicator mode to remind me where not to let the
code go past.
#+BEGIN_SRC emacs-lisp
(add-hook 'js2-mode-hook 'fci-mode)
#+END_SRC
** HTML mode
Enable electric pairing so I don't have to worry about closing =<=
and ="= and such.
#+BEGIN_SRC emacs-lisp
(add-hook 'html-mode-hook 'electric-pair-local-mode)
#+END_SRC
** CMake mode
:PROPERTIES:
:header-args: :tangle "init/oni-cmake-init.el"
:END:
#+BEGIN_SRC emacs-lisp :tangle yes
(with-eval-after-load 'cmake-mode (load "oni-cmake-init"))
#+END_SRC
Turn on extra font locking for function arguments etc.
#+BEGIN_SRC emacs-lisp
(add-hook 'cmake-mode-hook 'cmake-font-lock-activate)
#+END_SRC
Enable company mode for completions.
#+BEGIN_SRC emacs-lisp
(add-hook 'cmake-mode-hook 'company-mode)
#+END_SRC
Enable electric pairing.
#+BEGIN_SRC emacs-lisp
(add-hook 'cmake-mode-hook 'electric-pair-local-mode)
#+END_SRC
** C++
:PROPERTIES:
:header-args: :tangle "init/oni-cpp-init.el"
:END:
#+BEGIN_SRC emacs-lisp :tangle yes
(with-eval-after-load 'cc-mode (load "oni-cpp-init"))
#+END_SRC
Enable electric pairing.
#+BEGIN_SRC emacs-lisp
(add-hook 'c++-mode-hook 'electric-pair-local-mode)
#+END_SRC
Enable syntax checking using flycheck.
#+BEGIN_SRC emacs-lisp
(add-hook 'c++-mode-hook 'flycheck-mode)
#+END_SRC
Enable completions using company-mode.
#+BEGIN_SRC emacs-lisp
(add-hook 'c++-mode-hook 'company-mode)
#+END_SRC
Show the right margin of any C++ file.
#+BEGIN_SRC emacs-lisp
(add-hook 'c++-mode-hook 'fci-mode)
#+END_SRC
* Applications
- [[file:init/dired-init.org][Dired]] :: The Emacs file manager. Very powerful, and I don't use it
enough /yet/.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'dired (load "oni-dired-init"))
#+END_SRC
- [[file:init/oni-magit-init.org][Magit]] :: The Emacs git interface. By now I think I may know magit
better than the git cli.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'magit (load "oni-magit-init"))
#+END_SRC
- [[file:init/ediff-init.org][Ediff]] :: A reall diff application.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'ediff (load "oni-ediff-init"))
#+END_SRC
- [[file:init/oni-eshell-init.org][Eshell]] :: The best shell on the planet.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'eshell (load "oni-eshell-init"))
#+END_SRC
- [[file:init/oni-slack-init.org][Slack]] :: A slack client for Emacs.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'slack (load "oni-slack-init"))
#+END_SRC
- [[file:init/oni-circe-init.org][Circe]] :: A very nice and clean IRC client for Emacs.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'circe (load "oni-circe-init"))
#+END_SRC
** Linewise user-interface
This is the library used by Circe and Slack to display messages.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'lui))
#+END_SRC
Put the time stamp in lui buffers in the right margin. This gives
the text some extra room.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'lui
(setq lui-time-stamp-position 'right-margin))
#+END_SRC
Remove the "[]" from the time stamp, it's not really necessary.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'lui
(setq lui-time-stamp-format "%H:%M"))
#+END_SRC
Give the right margin just enough room to show the time-stamps, no
more, no less.
#+BEGIN_SRC emacs-lisp
(defun oni:set-circe-margin-width ()
(setq right-margin-width 5))
(add-hook 'lui-mode-hook #'oni:set-circe-margin-width)
#+END_SRC
Fix the wrap prefix so that text at the prompt is aligned properly.
#+BEGIN_SRC emacs-lisp
(defun oni:set-lui-prompt-wrap-prefix ()
(setq wrap-prefix " "))
(add-hook 'lui-mode-hook #'oni:set-lui-prompt-wrap-prefix)
#+END_SRC
Enable visual line mode in lui buffers so my text doesn't go
off-screen.
#+BEGIN_SRC emacs-lisp
(add-hook 'lui-mode-hook 'visual-line-mode)
#+END_SRC
Turn off filling in lui buffers. I use visual-line mode instead.
#+BEGIN_SRC emacs-lisp
(setq lui-fill-type nil)
#+END_SRC
** Jabber
I like using XMPP to talk to people, jabber.el is very good at
this.
#+BEGIN_SRC emacs-lisp
(eval-when-compile (require 'jabber))
#+END_SRC
Add my account.
#+BEGIN_SRC emacs-lisp
(setq jabber-account-list
`((,(concat "ryuslash@dukgo.com/" (system-name))
(:connection-type . starttls))))
#+END_SRC
Store any persistent data in the data directory.
#+BEGIN_SRC emacs-lisp
(setq jabber-avatar-cache-directory (oni:data-location "jabber/avatars/")
jabber-history-dir (oni:data-location "jabber/hist/"))
#+END_SRC
Change the default prompts.
#+BEGIN_SRC emacs-lisp
(setq jabber-chat-buffer-format "+%n"
jabber-chat-foreign-prompt-format "%t %n "
jabber-chat-local-prompt-format "%t %n "
jabber-chat-delayed-time-format "%H:%M"
jabber-groupchat-buffer-format "++%n"
jabber-groupchat-prompt-format "%t %n ")
#+END_SRC
Don't show avatars, publish or retrieve avatars.
#+BEGIN_SRC emacs-lisp
(setq jabber-chat-buffer-show-avatar nil
jabber-vcard-avatars-publish nil
jabber-vcard-avatars-retrieve nil)
#+END_SRC
Don't fill long lines in jabber chat buffers, but use visual line
mode.
#+BEGIN_SRC emacs-lisp
(setq jabber-chat-fill-long-lines nil)
(add-hook 'jabber-chat-mode-hook 'visual-line-mode)
#+END_SRC
Don't send notifications about chat states.
#+BEGIN_SRC emacs-lisp
(setq jabber-chatstates-confirm nil)
#+END_SRC
Colorize text in multi-user chats.
#+BEGIN_SRC emacs-lisp
(setq jabber-muc-colorize-local t
jabber-muc-colorize-foreign t)
#+END_SRC
Enable recording history.
#+BEGIN_SRC emacs-lisp
(setq jabber-history-enabled t
jabber-use-global-history nil)
#+END_SRC
Clean up the default view of the roster buffer.
#+BEGIN_SRC emacs-lisp
(setq jabber-roster-show-bindings nil
jabber-show-offline-contacts nil)
(add-hook 'jabber-roster-mode-hook 'oni-jabber-set-roster-mode-line)
#+END_SRC
Use libnotify to send jabber notifications.
#+BEGIN_SRC emacs-lisp
(add-hook 'jabber-alert-message-hooks 'jabber-message-libnotify)
(add-hook 'jabber-alert-muc-hooks 'jabber-muc-libnotify)
#+END_SRC
Don't echo presence changes in the mode line, show them in the
relevant buffer instead.
#+BEGIN_SRC emacs-lisp
(with-eval-after-load 'jabber-alert
(remove-hook 'jabber-alert-presence-hooks 'jabber-presence-echo))
(add-hook 'jabber-alert-presence-hooks 'oni-jabber-show-status-in-buffer)
#+END_SRC
Set the default directory to my home directory for jabber chat
buffers.
#+BEGIN_SRC emacs-lisp
(defun oni:set-default-directory ()
(setq default-directory "~/"))
(add-hook 'jabber-chat-mode-hook 'oni:set-default-directory)
#+END_SRC
** Gnus
:PROPERTIES:
:header-args: :tangle "init/oni-gnus-init.el"
:END:
Gnus is the very extensible Emacs news reader, which just happens
to also function very well as a mail reader. Since it is so
extensible and also configurable the configuration for it tends to
get big, so I split it into a separate file.
#+BEGIN_SRC emacs-lisp :tangle yes
(with-eval-after-load 'gnus (load "oni-gnus-init"))
#+END_SRC
Configuring Gnus is actually configuring a handful of packages, so
I require them all when Gnus is loaded so the byte compiler won't
yell at me.
#+BEGIN_SRC emacs-lisp
(require 'gnus)
(require 'gnus-msg)
(require 'mail-source)
(require 'message)
(require 'nnfolder)
(require 'sendmail)
#+END_SRC
I don't like having a lot of files spread around in my =.emacs.d=
directory, so put all of Gnus', Message's and nnfolder's data in
=.emacs.d/data=.
#+BEGIN_SRC emacs-lisp
(setq gnus-directory (locate-user-emacs-file "data/News")
gnus-article-save-directory gnus-directory
gnus-cache-directory gnus-directory
gnus-kill-files-directory gnus-directory)
(setq mail-source-directory (locate-user-emacs-file "data/Mail")
message-directory mail-source-directory
nnfolder-directory mail-source-directory)
#+END_SRC
Use msmtp to send my messages.
#+BEGIN_SRC emacs-lisp
(setq send-mail-function 'send-mail-send-it
message-send-mail-function 'message-send-mail-with-sendmail
sendmail-program "/usr/bin/msmtp")
#+END_SRC
I've been using Gnus for a while now and I don't think I fit the
profile of a novice anymore. Turning this off will stop Gnus from
asking me if I'm sure I want to delete a certain message, I do this
a lot because expiring messages seems to take too long for my
tastes.
#+BEGIN_SRC emacs-lisp
(setq gnus-novice-user nil)
#+END_SRC
Add a keybinding to the Gnus summary mode to easily delete
messages.
#+BEGIN_SRC emacs-lisp
(defun oni-gnus-delete-forward (&optional n)
"Delete the article under point and move to the next one.
Do this N times."
(interactive "p")
(dotimes (_ (or n 1))
(gnus-summary-delete-article)
(gnus-summary-next-subject 1)))
(define-key gnus-summary-mode-map (kbd "M-d") #'oni-gnus-delete-forward)
#+END_SRC
Change the format of how each line for a group in the Group buffer
is displayed. This shows the group name, the select method, group
subscription status, the process mark (whatever that is), whether
there is a summary buffer open for that group, number of unread
articles and the number of ticked articles.
#+BEGIN_SRC emacs-lisp
(setq gnus-group-line-format "%P%(%20G%): %-10s %S%p%B %5y %5T\n")
#+END_SRC
*** Mail accounts
I mostly use two email accounts.
**** ryuslash.org
Set my main email account as the primary select method for Gnus.
#+BEGIN_SRC emacs-lisp
(setq gnus-select-method
'(nnmaildir "ryuslash" (directory "~/documents/mail/ryuslash/")))
#+END_SRC
When sending mail from the ryuslash inbox, use the ryuslash msmtp
account.
#+BEGIN_SRC emacs-lisp
(add-to-list 'gnus-posting-styles
'(".*"
(address "tom@ryuslash.org")
(eval (setq message-sendmail-extra-arguments
'("-a" "ryuslash")))))
#+END_SRC
**** gmail.com
Add my other personal email as a secondary select method.
#+BEGIN_SRC emacs-lisp
(add-to-list 'gnus-secondary-select-methods
'(nnmaildir "gmail"
(directory "~/documents/mail/gmail/")))
#+END_SRC
When sending mail from the gmail account, use the gmail msmtp
accound and set the proper email address.
#+BEGIN_SRC emacs-lisp
(add-to-list 'gnus-posting-styles
'("gmail:"
(name "Tom Willemse")
(address "ryuslash@gmail.com")
(eval (setq message-sendmail-extra-arguments
'("-a" "gmail")))))
#+END_SRC
** Org mode
:PROPERTIES:
:header-args: :tangle "init/oni-org-init.el"
:END:
Since Org mode is a big package and I end up customizing it /a lot/
I always keep its settings in a separate file since it might be
awhile before org-mode is loaded.
#+BEGIN_SRC emacs-lisp :tangle yes
(with-eval-after-load 'org (load "oni-org-init"))
#+END_SRC
To keep the byte-compiler from complaining, require any libraries
that are used by my configuration when this file is loaded.
#+BEGIN_SRC emacs-lisp
(require 'org)
(require 'org-bullets)
(require 'org-capture)
#+END_SRC
Fontify source code blocks in Org mode natively, meaning that they
should be fontified using the major mode specified in the source
block language.
#+BEGIN_SRC emacs-lisp
(setq org-src-fontify-natively t)
#+END_SRC
Follow the link at point when {{{key(RET)}}} is pressed.
#+BEGIN_SRC emacs-lisp
(setq org-return-follows-link t)
#+END_SRC
Automatically fill paragraphs while editing text.
#+BEGIN_SRC emacs-lisp
(add-hook 'org-mode-hook 'auto-fill-mode)
#+END_SRC
Show pretty bullets instead of the default asterisk characters.
#+BEGIN_SRC emacs-lisp
(add-hook 'org-mode-hook 'org-bullets-mode)
#+END_SRC
** Grep
Make searching for "js" include ~*.js~, ~*.jsx~ and ~*.json~ files.
#+BEGIN_SRC emacs-lisp
(add-to-list 'grep-files-aliases '("js" . "*.js *.jsx *.json"))
#+END_SRC
Make searching for "css" include ~*.css~, ~*.less~, ~*.sass~ and
~*.scss~ files.
#+BEGIN_SRC emacs-lisp
(add-to-list 'grep-files-aliases '("css" . "*.css *.less *.sass *.scss"))
#+END_SRC
* Custom
Put the customize settings in a different file so that Emacs doesn't
have to modify this file whenever something changes through
customize. I put this into my init file last so any settings made in
there *can* overwrite the ones in the rest of the file, not that I
usually like to do that.
#+BEGIN_SRC emacs-lisp
(setq custom-file (concat user-emacs-directory "custom.el"))
(load custom-file)
#+END_SRC
Reference in a new issue View git blame Copy permalink