IvanMalison/ dotfiles

nix

orgmode

CSS

Shell

Haskell

JavaScript

Perl

literate-programming

window-manager

tiling-window-manager

emacs-configuration

Zsh

Python

Clojure

Scala

dotfiles

xmonad

Emacs

github-pages

travis-ci

Linux

arch-linux

nixos

View on GitHub

Need help with dotfiles?

Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

IvanMalison

127 Stars

16 Forks

3.9K Commits

0 Opened issues

Description

Configuration files for XMonad, Emacs, NixOS, Taffybar and more.

Services available

Need anything else?

Contributors list

Ivan Malison IvanMalison

# 60,250

Haskell

gtk

appindi...

xmonad

3703 commits

Kat katandtonic

# 708,290

CSS

orgmode

Zsh

xmonad

14 commits

Livien Yin livienyin

# 515,590

HTML

orgmode

Zsh

xmonad

8 commits

Readme

-- mode: org; --

Name: dotfiles
Brand: dotfiles
SKU: //IvanMalison/dotfiles
Rating: 2.0675 (127 reviews)

[[https://travis-ci.org/IvanMalison/dotfiles][file:https://travis-ci.org/IvanMalison/dotfiles.svg?branch=master]]

This document is best read at [[http://ivanmalison.github.io/dotfiles/]] or, of course, in emacs, as the internal links that follow are unlikely to work anywhere else (including, for example, at https://github.com/IvanMalison/dotfiles). * About This is my emacs configuration in literate form. It aspires to be like the incredibly well commented literate configurations of [[http://pages.sachachua.com/.emacs.d/Sacha.html][Sacha Chua]] and [[http://doc.rix.si/cce/cce.html][Ryan Rix]], but I haven't quite gotten around to polishing it to the point that those two have. Still, there are definitely a few sections of which I am quite proud, and that others may find to be useful. * Highlights These sections are the ones that have the most potential to be interesting to others: ** How I generate http://ivanmalison.github.io/dotfiles/ *** org-export **** travis-ci [[https://github.com/IvanMalison/dotfiles/tree/master/gen-gh-pages][This directory]] contains a collection of scripts that export this org document to html. This approach is taken (with only a few modifications) from [[https://gist.github.com/domenic/ec8b0fc8ab45f39403dd][here]]. **** githook (The old way) NOTE: I've left this here in case other people have an interest in this method, but I no longer use it.

I wrote a [[https://github.com/IvanMalison/dotfiles/tree/9e56ced1dd70e50e1026aca5af51437e93add026/dotfiles/emacs.d/bin][githook and an installer script]] that automatically update index.html at the root of the repository by running ~org-html-export-to-html~ on my README.org (essentially this document) . These should work no matter where they are placed in a repository. The org-mode file that they target is set [[https://github.com/IvanMalison/dotfiles/blob/16a4f6c3aadef39a45d30c15e8637b40858721ea/dotfiles/emacs.d/bin/util.sh#L4][here]] and should be relatively easy to change. *** [[https://github.com/fniessen/org-html-themes][Read The Org]] I use [[https://github.com/fniessen][fniessen]]'s ReadTheOrg theme which can be found at https://github.com/fniessen/org-html-themes. *** Predictable and Human Readable Heading Links To make it so that internal heading links have names that correspond to the heading text, and don't change when new headings are added to the document, I wrote a custom version of ~org-export-get-reference~.

See how [Use my own default naming scheme for org-headings][this link] takes you to http://ivanmalison.github.io/dotfiles/#usemyowndefaultnamingschemefororgheadings.

In case you haven't noticed, that is where you should go grab the code that does this.

I'm considering turning this snippet in to a package, so please let me know if that is something you are interested in. *** [[Add link icons in headings that lead to themselves][Add link icons in headings that lead to themselves]] This is another pretty nasty hack. This is useful when you are browsing the document and you want to grab a link to the current heading. *** Set Background Color Source Blocks For some reason, org-mode uses all of your currently active fontification when exporting EXCEPT for background color. [[Set Background Color of Source Blocks for Export][This]] modification fixes this. ** [[frame-mode][Custom frame control]] My custom [[frame-mode][frame-mode]] stuff is built to integrate really nicely with xmonad. I think its pretty awesome! ** [[Functions][My functions section]] ...has a bunch of generally useful functions: + [https://github.com/IvanMalison/emit/blob/2e4d788abd68bac538acb06443179b8d5885052e/emit.el#L104][emit-prefix-selector] See [[https://github.com/IvanMalison/emit#prefix-selector][README]] for explantion + [[Font Size][Font Size]] functions and an [[fontsizehydra][Awesome Hydra]] for them + [downloadfile][Download a file into a buffer] + [[editscript][Edit a script on $PATH]] + [[Copy/Yanking][Copy Portions of Buffer File Path Hydra]] and the associated [[Copy/Yank String Functions][Copy String Functions]] + [namedbuild][Named Build of Builder Macros] and [composemacros][A Compose Supporting Macros] + [[Add a blacklist to a major mode]] ** Configuration of My Own Packages - [[term-projectile][term-projectile]] and [[term-manager][term-manager]] - [[org-projectile][org-projectile]] - [[multi-line][multi-line]] - [[github-search][github-search]] - [[flimenu][flimenu]] - [[frame-mode][frame-mode]] - [[tile][tile]] ** [[programminglanguages][Programming Language Configurations]] My programming language major mode configurations can all be found [[programminglanguages][here]]. ** [[org][org-mode]] My [[org][org-mode]] configuration is pretty comprehensive, but not super well commented. * HTML Headers

+HTML_HEAD:

Early The configurations in this section need to occur early in emacs startup for some reason or another. ** Lexical Binding This makes it so that the file that is produced from tangling this file uses lexical scoping. #+BEGINSRC emacs-lisp ;;; -- lexical-binding: t -- (setq-default lexical-binding t) #+ENDSRC ** Security #+BEGIN_SRC emacs-lisp (defvar imalison:secure t)

(defun imalison:use-https-and-tls () (setq tls-checktrust t) (let ((trustfile (replace-regexp-in-string "\\" "/" (replace-regexp-in-string "\n" "" (shell-command-to-string "python -m certifi"))))) (setq tls-program (list (format "gnutls-cli%s --x509cafile %s -p %%p %%h" (if (eq window-system 'w32) ".exe" "") trustfile)))))

(defun imalison:test-security () (interactive) (let ((bad-hosts (loop for bad in `("https://wrong.host.badssl.com/" "https://self-signed.badssl.com/") if (condition-case e (url-retrieve bad (lambda (retrieved) t)) (error nil)) collect bad))) (if bad-hosts (error (format "tls misconfigured; retrieved %s ok" bad-hosts)) (url-retrieve "https://badssl.com" (lambda (_retrieved) t)))))

+END_SRC

+BEGIN_SRC emacs-lisp

(when (equal system-type 'gnu/linux) (setq browse-url-browser-function 'browse-url-generic browse-url-generic-program "xdg-open"))

+END_SRC

Functions ** Join Paths Works in the same way as os.path.join in python #+BEGINSRC emacs-lisp (defun imalison:join-paths (root &rest dirs) (let ((result root)) (cl-loop for dir in dirs do (setq result (concat (file-name-as-directory result) dir))) result)) #+ENDSRC ** Variables #+BEGIN_SRC emacs-lisp (defvar imalison:projects-directory (imalison:join-paths (substitute-in-file-name "$HOME") "Projects"))

(defmacro imalison:compose-argspec (arguments call-arguments &rest funcs) "Build a new function with NAME that is the composition of FUNCS." `(lambda ,arguments (imalison:compose-helper ,funcs ,call-arguments)))

(defmacro imalison:compose-helper (funcs arguments) "Builds funcalls of FUNCS applied to the arg." (if (equal (length funcs) 1) (let ((last-function (car funcs))) ;; This hideous clause is here because it is the only way to ;; handle functions that take &rest args. (when (memq '&rest (imalison:help-function-arglist last-function)) (setq last-function (apply-partially 'apply last-function)))

(,last-function ,@arguments))

(,(car funcs) (imalison:compose-helper ,(cdr funcs) ,arguments))))

(defmacro imalison:compose-macro-fn (&rest args) `(cons 'macro (imalison:compose-fn ,@args)))

(imalison:named-builder imalison:compose) (imalison:named-builder imalison:compose-macro)

+END_SRC

*** Arbitrary arguments at every step

+BEGIN_SRC emacs-lisp

(defun imalison:make-list (thing) (if (listp thing) thing (list thing)))

(defmacro imalison:compose-with-apply (&rest funcs) "Build a new function with NAME that is the composition of FUNCS." `(lambda (&rest args) (imalison:compose-with-apply-helper ,funcs)))

(defmacro imalison:compose-with-apply-helper (funcs) "Builds funcalls of FUNCS applied to the arg." (if (equal (length funcs) 0) (quote args) `(apply ,(car funcs) (imalison:make-list (imalison:compose-with-apply-helper ,(cdr funcs))))))

+END_SRC

*** Simpler unary version

+BEGIN_SRC emacs-lisp

(defmacro imalison:compose-unary (&rest funcs) "Build a new function with NAME that is the composition of FUNCS." `(lambda (arg) (imalison:compose-helper-unary ,funcs)))

(defmacro imalison:compose-helper-unary (funcs) "Builds funcalls of FUNCS applied to the arg." (if (equal (length funcs) 0) 'arg `(funcall ,(car funcs) (imalison:compose-helper-unary ,(cdr funcs)))))

+END_SRC

** With Advice Taken from [[http://emacs.stackexchange.com/questions/16490/emacs-let-bound-advice][here]].

(imalison:advice-add-around-builder imalison:kill-new-around kill-new)

+END_SRC

** Let Around

+BEGIN_SRC emacs-lisp

(defmacro imalison:let-around-fn (orig-func &rest forms) (let* ((orig-interactive-form (interactive-form orig-func)) (docstring-form (format "Call

%s' with bindings: %s." orig-func forms))
         (additional-forms (list docstring-form)))
    (when orig-interactive-form
      (nconc additional-forms (list orig-interactive-form)))

(lambda (&rest args) ,@additional-forms (let ,forms (apply (quote ,orig-func) args)))))

(imalison:named-builder imalison:let-around)

+END_SRC

** Let Around Advice

+BEGIN_SRC emacs-lisp

(defmacro imalison:let-advise-around-fn (&rest forms) `(lambda (orig-func &rest args) (let ,forms (apply orig-func args))))

+END_SRC

** Font Size This was taken from [[http://emacs.stackexchange.com/questions/7583/transiently-adjust-text-size-in-mode-line-and-minibuffer][here]] but it has diverged significantly from the original.

+BEGIN_SRC emacs-lisp

(defvar imalison:default-font-size-pt nil)

(defun imalison:acceptable-default-font-size (value) (and (numberp value) (< value 150) (> value 50)))

;; XXX: hack to get proper default value when default is set to something crazy (defun imalison:set-default-font-size (&rest args) (interactive) (when (and (imalison:acceptable-default-font-size (face-attribute 'default :height)) (not (imalison:acceptable-default-font-size imalison:default-font-size-pt))) (setq imalison:default-font-size-pt (face-attribute 'default :height))))

(advice-add 'set-face-attribute :after 'imalison:set-default-font-size)

(defvar imalison:huge-font-size 280)

(defun imalison:current-font-size () (plist-get (custom-face-attributes-get 'default nil) :height))

(defun imalison:set-font-size (size) (interactive (list (string-to-number (read-string "Enter a font size: ")))) (set-face-attribute 'default nil :height size))

(defun imalison:set-huge-font-size () (interactive) (imalison:set-font-size imalison:huge-font-size))

(cl-defun imalison:modify-font-size (&optional (arg 10)) (interactive "p") (unless imalison:default-font-size-pt (imalison:set-default-font-size)) (imalison:set-font-size (+ (imalison:current-font-size) arg)))

(defun imalison:font-size-incr () (interactive) (imalison:modify-font-size +10))

(defun imalison:font-size-decr () (interactive) (imalison:modify-font-size -10))

(defun imalison:font-size-reset () (interactive) (imalison:set-font-size imalison:default-font-size-pt))

(defun imalison:font-size-80chars () (interactive) (imalison:set-font-size 120))

+END_SRC

** Message Result Builder This macro is useful when writing emacs-lisp. It creates a new interactive command that shows you the result of evaluating a function, with optionally provided arguments.

+BEGIN_SRC emacs-lisp

(defmacro imalison:message-result-builder (new-function-name function-to-call &rest args) `(defun ,new-function-name () (interactive) (message "%s" (apply (quote ,function-to-call) (list ,@args)))))

+END_SRC

This interactive functions allows the user the select a function to invoke using a freshly minted imalison:message-result-builder

+BEGIN_SRC emacs-lisp

(defun imalison:message-result-builder-runtime (function &rest args) (lambda () (interactive) (message "%s" (apply function-to-call args))))

(defun imalison:message-function-result (function) (interactive (find-function-read)) (message "%s" (funcall function)))

+END_SRC

** Custom ~shell-command-on-region~

+BEGIN_SRC emacs-lisp

(defun imalison:copy-shell-command-on-region (start end command) (interactive (list (region-beginning) (region-end) (read-shell-command "Shell command on region: "))) (let ((original-buffer (current-buffer))) (with-temp-buffer (let ((temp-buffer (current-buffer))) (with-current-buffer original-buffer (shell-command-on-region start end command temp-buffer)) (let ((min (point-min)) (max (point-max))) (kill-ring-save min max) (buffer-substring min max))))))

(defun imalison:last-message (&optional num) (or num (setq num 1)) (if (= num 0) (current-message) (save-excursion (set-buffer "Messages") (save-excursion (forward-line (- 1 num)) (backward-char) (let ((end (point))) (forward-line 0) (buffer-substring-no-properties (point) end))))))

(defun imalison:maybe-symbol-name (arg) (if (symbolp arg) (symbol-name arg) arg))

(defun imalison:concat-symbols (&rest args) (intern (mapconcat 'imalison:maybe-symbol-name args "")))

+END_SRC

** Edit a script on PATH <> Note that you'll need to make sure that emacs properly inherits the path variable for this work. Check out my [[exec-path-from-shell][exec-path-from-shell]] config for details.

+BEGIN_SRC emacs-lisp

(defun imalison:get-executables-at-path (filepath) (when (and (file-exists-p filepath) (f-directory? filepath)) (--filter (let ((fullpath (imalison:join-paths filepath it))) (and (file-executable-p fullpath) (not (f-directory? fullpath)))) (directory-files filepath))))

(defun imalison:get-executables-on-path () (mapcan 'imalison:get-executables-at-path (eshell-parse-colon-path (getenv "PATH"))))

(defun imalison:edit-script () (interactive) (find-file (executable-find (ido-completing-read "Select a script to edit: " (imalison:get-executables-on-path)))))

+END_SRC

** Toggle lexical binding in the current buffer

+BEGIN_SRC emacs-lisp

(defun imalison:toggle-lexical-binding () (interactive) (let ((new-binding (not lexical-binding))) (message "Setting lexical-binding to: %s" new-binding) (setq lexical-binding new-binding)))

+END_SRC

** Sync kill ring with copyq

+BEGIN_SRC emacs-lisp

(defun imalison:copyq-get (i) (imalison:shell-command-to-string (format "copyq eval read(%s)" i)))

(defun imalison:copyq-sync () (interactive) (let ((missing-items (cl-loop for i from 0 to (string-to-number (imalison:shell-command-to-string "copyq eval size()")) for item = (imalison:copyq-get i) when (not (member item kill-ring)) collect item))) (setq kill-ring (nconc kill-ring missing-items))))

(when (executable-find "copyq") (run-with-idle-timer 10 nil 'imalison:copyq-sync))

+END_SRC

** helm-zsh-history This was stolen from https://github.com/jwiegley/dot-emacs

+BEGIN_SRC emacs-lisp

(defvar helm-c-source-zsh-history '((name . "Zsh History") (candidates . helm-c-zsh-history-set-candidates) (action . (("Execute Command" . helm-c-zsh-history-action))) (volatile) (requires-pattern . 3) (delayed)))

(defun helm-c-zsh-history-set-candidates (&optional request-prefix) (let ((pattern (replace-regexp-in-string " " ".*" (or (and request-prefix (concat request-prefix " " helm-pattern)) helm-pattern)))) (with-current-buffer (find-file-noselect "~/.zsh_history" t t) (auto-revert-mode -1) (goto-char (point-max)) (loop for pos = (re-search-backward pattern nil t) while pos collect (replace-regexp-in-string "\`:.+?;" "" (buffer-substring (line-beginning-position) (line-end-position)))))))

(defun helm-c-zsh-history-action (candidate) (imalison:named-compile candidate))

(defun helm-command-from-zsh () (interactive) (require 'helm) (helm-other-buffer 'helm-c-source-zsh-history "helm zsh history"))

+END_SRC

*** Use projectile as default directory

+BEGIN_SRC emacs-lisp

(imalison:let-around imalison:projectile-helm-command-from-zsh helm-command-from-zsh (default-directory (projectile-project-root)))

+END_SRC

** Disable hooks

+BEGIN_SRC emacs-lisp

(cl-defmacro imalison:disable-mode-hook (mode-name &optional (disable-value -1)) `(defun ,(imalison:concat-symbols 'imalison:disable- mode-name) () (,mode-name ,disable-value)))

(imalison:disable-mode-hook linum-mode) (imalison:disable-mode-hook nlinum-mode) (imalison:disable-mode-hook yas-minor-mode)

+END_SRC

** Add a blacklist to a major mode Sometimes a major mode's syntax highlighting can take a really long time to load in certain buffers. Usually you can just set a header to tell emacs not to run the major mode, but for cases where you can't always edit the file ahead of time this macro allows you to define a blacklist for your major mode that will prevent the major mode from being enabled on that file.

+begin_src emacs-lisp

(defmacro imalison:add-blacklist-to-major (major-mode-fn-symbol) (let ((blacklist-var-symbol (imalison:concat-symbols major-mode-fn-symbol "-blacklist")) (check-blacklist-symbol (imalison:concat-symbols major-mode-fn-symbol "-check-blacklist"))) `(progn (defvar ,blacklist-var-symbol nil) (defun ,check-blacklist-symbol (mode-fn &rest args) (unless (and (not (equal major-mode (quote ,major-mode-fn-symbol))) (equal nil args) (cl-loop for blacklist-regex in ,blacklist-var-symbol thereis (string-match blacklist-regex (buffer-name)))) (apply mode-fn args))) (advice-add (quote ,major-mode-fn-symbol) :around (quote ,check-blacklist-symbol)))))

+end_src

** Other The stuff in this section is pretty crusty. I don't think its used anywhere, but I keep it around just in case I need it.

+BEGIN_SRC emacs-lisp

(defun random-choice (choices) (nth (random (length choices)) choices))

(defun display-prefix (arg) "Display the value of the raw prefix arg." (interactive "p") (message "%s" arg))

(defun imalison:uuid () (interactive) (s-replace "\n" "" (shell-command-to-string "uuid")))

(defun imalison:disable-smartparens-mode () (smartparens-mode 0))

(defun imalison:insert-uuid () (interactive) (insert (imalison:uuid)))

(defun imalison:compare-int-list (a b) (when (and a b) (cond ((> (car a) (car b)) 1) ((< (car a) (car b)) -1) (t (imalison:compare-int-list (cdr a) (cdr b))))))

(defun get-date-created-from-agenda-entry (agenda-entry) (org-time-string-to-time (org-entry-get (get-text-property 1 'org-marker agenda-entry) "CREATED")))

(defmacro defvar-setq (name value) `(if (boundp (quote ,name)) (setq ,name ,value) (defvar ,name ,value)))

(defun eval-region-or-last-sexp () (interactive) (if (region-active-p) (call-interactively 'eval-region) (call-interactively 'eval-last-sexp)))

(defun undo-redo (&optional arg) (interactive "P") (if arg (undo-tree-redo) (undo-tree-undo)))

(defun up-list-region () (interactive) (up-list) (set-mark-command nil) (backward-sexp))

(defun up-list-back () (interactive) (up-list) (backward-sexp))

(defun frame-exists () (cl-find-if (lambda (frame) (assoc 'display (frame-parameters frame))) (frame-list)))

(defun make-frame-if-none-exists () (let* ((existing-frame (frame-exists))) (if existing-frame existing-frame (make-frame-on-display (getenv "DISPLAY")))))

(defun make-frame-if-none-exists-and-focus () (make-frame-visible (select-frame (make-frame-if-none-exists))))

(defun notification-center (title message) (cl-flet ((encfn (s) (encode-coding-string s (keyboard-coding-system)))) (shell-command (format "osascript -e 'display notification \"%s\" with title \"%s\"'" (encfn message) (encfn title)))))

(defun growl-notify (title message) (shell-command (format "grownotify -t %s -m %s" title message)))

(defun notify-send (title message) (shell-command (format "notify-send -u critical %s %s" title message)))

(defvar notify-function (cond ((eq system-type 'darwin) 'notification-center) ((eq system-type 'gnu/linux) 'notify-send)))

+END_SRC

+BEGIN_SRC emacs-lisp

(emit-prefix-selector imalison:mark-ring helm-mark-ring helm-global-mark-ring)

+END_SRC

** Keyboard Macros *** For editing literate config **** extract-current-sexp-to-src-block This keyboard macro extracts the current sexp to an emacs-lisp source block of its own #+BEGINSRC emacs-lisp (fset 'extract-current-sexp-to-src-block [?\C-a return ?\C-p ?# ?+ ?E ?N ?D ? ?S ?R ?C return ?# ?+ ?B ?E ?G ?I ?N ?_ ?S ?R ?C ? ?e ?m ?a ?c ?s ?- ?l ?i ?s ?p ?\C-a ?\C-p ?\C- ?\C-n ?\C-e ?\M-w ?\C-n ?\C-a ?\C-\M-f return ?\C-y])

#+ENDSRC **** name-source-block-for-use-package-name #+BEGINSRC emacs-lisp (fset 'name-source-block-for-use-package-name [?\C-c ?\' ?\M-< ?\C-s ?u ?s ?e ?- ?p ?a ?c ?k return ?\C-\M-f ?\C-f ?\C- ?\C-\M-f ?\M-w ?\C-c ?\' ?\C-r ?B ?E ?G ?I ?N return ?\C-a ?\C-p ?\C-e return ?* ? ?\C-y]) #+ENDSRC **** extract-and-name-use-package-block #+BEGINSRC emacs-lisp (fset 'extract-and-name-use-package-block [?\C-a return ?\C-p ?# ?+ ?E ?N ?D ?_ ?S ?R ?C return ?# ?+ ?B ?E ?G ?I ?N ?_ ?S ?R ?C ? ?e ?m ?a ?c ?s ?- ?l ?i ?s ?p ?\C-a ?\C-p ?\C- ?\C-n ?\C-e ?\M-w ?\C-n ?\C-a ?\C-\M-f return ?\C-y ?\C-p ?\C-p ?\C-c ?\' ?\M-< ?\C-s ?u ?s ?e ?- ?p ?a ?c ?k return ?\C-\M-f ?\C-f ?\C- ?\C-\M-f ?\M-w ?\C-c ?\' ?\C-r ?B ?E ?G ?I ?N return ?\C-a ?\C-p ?\C-e return ?* ? ?\C-y]) #+END_SRC * Man-mode Man page escape sequences aren't properly handled by emacs pager. This function fixes that, but for now, it needs to be run manually, since I haven't figured out how to detect that a buffer is a man mode buffer.

+BEGIN_SRC emacs-lisp

(use-package man :config (progn (defun imalison:fontify-man-page-buffer () (interactive) (read-only-mode -1) (Man-fontify-manpage) (read-only-mode +1))))

+END_SRC

General ** User Info

+BEGIN_SRC emacs-lisp

(setq user-full-name (replace-regexp-in-string "\n$" "" (shell-command-to-string "git config --get user.name"))) (setq user-mail-address (replace-regexp-in-string "\n$" "" (shell-command-to-string "git config --get user.email")))

+END_SRC

** Sane Defaults

+BEGIN_SRC emacs-lisp -n -r

(global-auto-revert-mode) (show-paren-mode 1) (setq reb-re-syntax 'string) (setq ad-redefinition-action 'accept) (ref:ad-redefinition-action) (setq-default find-file-visit-truename t) (setq large-file-warning-threshold (* 25 1024 1024)) (setq line-move-visual t) (setq require-final-newline t)

+END_SRC

[[(ad-redefinition-action)][This]] is set because [[(y-or-n-p-only)][this alias]] causes annoying messaging at startup. ** System Clipboard

+BEGIN_SRC emacs-lisp

(setq save-interprogram-paste-before-kill t)

+END_SRC

** Line Numbers

+BEGIN_SRC emacs-lisp

(line-number-mode t) (column-number-mode t)

+END_SRC

*** nlinum Disabling line numbers because they are slow as fuck.

+BEGIN_SRC emacs-lisp

(use-package nlinum :disabled t :demand t :config (progn (add-hook 'prog-mode-hook (lambda () (nlinum-mode t))) (defun imalison-nlinum-mode-hook () (when nlinum-mode (setq-local nlinum-format (concat "%" (number-to-string ;; Guesstimate number of buffer lines. (ceiling (log (max 1 (/ (buffer-size) 80)) 10))) "d"))))

(add-hook 'nlinum-mode-hook #'imalison-nlinum-mode-hook)))

+END_SRC

** Backups *** Put them all in one directory

+BEGIN_SRC emacs-lisp

(defconst emacs-tmp-dir (format "%s/%s%s/" temporary-file-directory "emacs" (user-uid))) (setq backup-directory-alist
```
((".*" . ,emacs-tmp-dir)))
(setq auto-save-file-name-transforms
```
((".*" ,emacs-tmp-dir t))) (setq auto-save-list-file-prefix emacs-tmp-dir)
+END_SRC

*** Completely disable backups

+BEGIN_SRC emacs-lisp

(setq backup-inhibited t) (setq make-backup-files nil) (setq auto-save-default nil)

+END_SRC

** Prompts *** No popup frames

+BEGIN_SRC emacs-lisp

(setq ns-pop-up-frames nil) (setq pop-up-frames nil)

+END_SRC

*** boolean (yes-or-no)

+BEGIN_SRC emacs-lisp -n -r

(defadvice yes-or-no-p (around prevent-dialog activate) "Prevent yes-or-no-p from activating a dialog" (let ((use-dialog-box nil)) ad-do-it))

(defadvice y-or-n-p (around prevent-dialog-yorn activate) "Prevent y-or-n-p from activating a dialog" (let ((use-dialog-box nil)) ad-do-it))

;; No prompt for killing a buffer with processes attached. (setq kill-buffer-query-functions (remq 'process-kill-buffer-query-function kill-buffer-query-functions))

(setq inhibit-startup-message t inhibit-startup-echo-area-message t)

;; Make buffer names unique. (setq uniquify-buffer-name-style 'forward)

;; Don't disable commands... (setq disabled-command-function nil)

;; Make forward word understand camel and snake case.

;; Preserve pastes from OS when saving a new item to the kill ;; ring. Why wouldn't this be enabled by default?

(setq-default cursor-type 'box) (setq-default cursor-in-non-selected-windows 'bar)

(when nil ;; Causing too many annoying issues (add-hook 'after-init-hook '(lambda () (setq debug-on-error t))))

;; Make mouse scrolling less jumpy. (setq mouse-wheel-scroll-amount '(1 ((shift) . 1)))

(setq ediff-split-window-function 'split-window-horizontally) (setq ediff-window-setup-function 'ediff-setup-windows-plain)

;; Disable this per major mode or maybe using file size if it causes ;; performance issues? (setq imenu-auto-rescan t) (setq imenu-max-item-length 300)

(put 'narrow-to-region 'disabled nil) (put 'narrow-to-page 'disabled nil)

(setq echo-keystrokes 0.25)

;; text mode stuff: (remove-hook 'text-mode-hook #'turn-on-auto-fill) (add-hook 'text-mode-hook 'turn-on-visual-line-mode) (setq sentence-end-double-space nil)

;; y and n instead of yes and no

+END_SRC

+END_SRC

helpful #+beginsrc emacs-lisp (use-package helpful :bind (("C-h f" . helpful-callable) ("C-h v" . helpful-variable) ("C-h k" . helpful-key))) #+endsrc
Keybindings ** god-mode #+BEGINSRC emacs-lisp (use-package god-mode :disabled t :demand t :config (progn (global-set-key (kbd "") 'god-local-mode))) #+ENDSRC ** bind-key #+BEGINSRC emacs-lisp (use-package bind-key) #+ENDSRC ** which-key #+BEGINSRC emacs-lisp (use-package which-key :config (progn (setq which-key-idle-delay .50) (diminish 'which-key-mode) (which-key-mode))) #+ENDSRC ** hydra #+BEGINSRC emacs-lisp (use-package hydra :demand t :bind (("C-c f" . imalison:hydra-font/body) ("C-c y" . imalison:hydra-yank/body) ("C-c 6" . imalison:compile/body)) :config (progn #+ENDSRC *** Font Settings <> #+BEGINSRC emacs-lisp (defhydra imalison:hydra-font nil "Font Settings" ("-" imalison:font-size-decr "Decrease") ("d" imalison:font-size-decr "Decrease") ("=" imalison:font-size-incr "Increase") ("+" imalison:font-size-incr "Increase") ("i" imalison:font-size-incr "Increase") ("h" imalison:set-huge-font-size "Huge") ("a" imalison:appearance "Set Default Appearance") ("f" set-frame-font "Set Frame Font") ("t" helm-themes "Choose Emacs Theme") ("0" imalison:font-size-reset "Reset to default size") ("8" imalison:font-size-80chars "80 chars 3 columns font size")) #+ENDSRC *** Copy/Yanking #+BEGINSRC emacs-lisp (defhydra imalison:hydra-yank nil "Yank text" ("p" imalison:copy-buffer-file-path "Projectile path") ("b" imalison:copy-current-buffer-name "Buffer Name") ("f" imalison:copy-buffer-file-path-full "Full path") ("n" imalison:copy-buffer-file-name "File name") ("g" imalison:copy-current-git-branch "Git Branch") ("m" imalison:copy-last-message "Last Message")) #+ENDSRC *** Compile #+BEGIN_SRC emacs-lisp (defun imalison:make-test () (interactive) (let ((default-directory (projectile-project-root))) (imalison:named-compile "make test")))

(defun imalison:glide-up () (interactive) (imalison:named-compile "glide up"))

Navigation ** zop-to-char

+BEGIN_SRC emacs-lisp

(use-package zop-to-char :bind ("M-z" . zop-to-char) :init (progn (setq zop-to-char-kill-keys '(?\C-k ?\C-w)) (setq zop-to-char-quit-at-point-keys '(?\r))))

+END_SRC

** helm I use helm for almost all emacs completion

+BEGIN_SRC emacs-lisp -n -r

(use-package helm-config :demand t :diminish helm-mode :straight helm :bind (("M-y" . helm-show-kill-ring) ("M-x" . helm-M-x) ("C-x C-i" . helm-imenu) ("C-h a" . helm-apropos) ("C-c ;" . helm-recentf)) :config (progn (setq helm-split-window-default-side 'same helm-exit-idle-delay 0)

(use-package helm-org :straight nil :defer 10 :config (progn
```
(cl-defun helm-org-headings-in-buffer ()
  (interactive)
  (helm :sources (helm-source-org-headings-for-files
                  (list (projectile-completing-read
                         "File to look at headings from: "
                         (projectile-all-project-files))))
        :candidate-number-limit 99999
        :buffer "*helm org inbuffer*"))))
```
(use-package helm-descbinds :defer 4 :config (helm-descbinds-mode 1))

(use-package helm-ag :bind ("C-c p 1" . imalison:set-helm-ag-extra-options) :preface (progn (defun imalison:set-helm-ag-extra-options () (interactive) (let ((option (read-string "Extra options: " (or helm-ag--extra-options "") 'helm-ag--extra-options-history))) (setq helm-ag--extra-options option)))) :config (progn (setq helm-ag-always-set-extra-option nil)))))

(use-package helm :diminish helm-mode :config (helm-mode +1))

+END_SRC

** helm-projectile

+BEGIN_SRC emacs-lisp

(use-package helm-projectile :defer 1 :commands (helm-projectile-on) :bind (:map helm-projectile-projects-map ("M-s" . imalison:switch-to-project-and-search) ("M-t" . imalison:helm-term-projectile)) :preface (progn (defmacro imalison:do-in-project (project-dir &rest forms) `(noflet ((projectile-project-root (&rest args) ,project-dir)) ,@forms)) (defun imalison:invalidate-cache-and-open-file (_dir) (projectile-invalidate-cache nil) (projectile-find-file))

(defun imalison:switch-to-project-and-search (dir)
  (imalison:do-in-project dir (helm-projectile-ag)))

(defun imalison:helm-term-projectile (dir)
  (imalison:do-in-project dir (term-projectile-forward))))

:config (progn (shut-up (helm-projectile-on)) (helm-delete-action-from-source "Search in Project" helm-source-projectile-projects) (helm-delete-action-from-source "Open term for project" helm-source-projectile-projects) (helm-add-action-to-source "Search in Project" 'imalison:switch-to-project-and-search helm-source-projectile-projects) (helm-add-action-to-source "Open term for project" 'imalison:helm-term-projectile helm-source-projectile-projects) (helm-add-action-to-source "Invalidate Cache and Open File" 'imalison:invalidate-cache-and-open-file helm-source-projectile-projects)))

+END_SRC

** projectile

+BEGIN_SRC emacs-lisp

(use-package projectile :demand t :bind (("C-x f" . projectile-find-file-in-known-projects) ("C-c p f" . imalison:projectile-find-file)) :preface (progn (defun imalison:do-ag-default-directory () (interactive) (helm-do-ag default-directory (car (projectile-parse-dirconfig-file))))

(emit-prefix-selector imalison:do-ag
  helm-projectile-ag
  imalison:do-ag-default-directory
  helm-do-ag)

(emit-prefix-selector imalison:projectile-find-file
  projectile-find-file
  projectile-find-file-other-window)
(imalison:let-around imalison:set-options-do-ag
  imalison:do-ag
  (helm-ag-always-set-extra-option t))
(defun imalison:projectile-make-all-subdirs-projects (directory)
  (cl-loop for file-info in (directory-files-and-attributes directory)
           do (when (nth 1 file-info)
                (write-region "" nil
                              (expand-file-name
                               (concat directory "/"
                                       (nth 0 file-info) "/.projectile")))))))

:config (progn (use-package persp-projectile :commands projectile-persp-switch-project) (define-key projectile-mode-map (kbd "C-c p") 'projectile-command-map)

(projectile-global-mode)
(setq projectile-require-project-root nil)
(setq projectile-enable-caching nil)
(setq projectile-completion-system 'helm)
(add-to-list 'projectile-globally-ignored-files "Godeps")
(diminish 'projectile-mode)
(bind-key* "C-c p s" 'imalison:do-ag)
(bind-key* "C-c p S" 'imalison:set-options-do-ag)
(bind-key* "C-c p f" 'imalison:projectile-find-file)))

(add-hook 'ediff-cleanup-hook 'imalison:purge-ediff-buffers)

(defun imalison:go-testify-show-ediff () (interactive) (let ((buffer (get-buffer-create "Testify JSON")) json-result) (shell-command-on-region (point-min) (point-max) "parsegotestifyforemacs.py" buffer) (with-current-buffer buffer (goto-char (point-min)) (setq json-result (json-read))) (let ((actual-buffer (generate-new-buffer "Testify Actual")) (expected-buffer (generate-new-buffer "Testify Expected"))) (add-to-list 'imalison:testify-ediff-buffers actual-buffer) (add-to-list 'imalison:testify-ediff-buffers expected-buffer) (with-current-buffer actual-buffer (insert (cdr (assoc 'actual json-result))) (with-current-buffer expected-buffer (insert (cdr (assoc 'expected json-result))) (ediff-buffers actual-buffer expected-buffer))))))

(defun imalison:go-testify-show-icdiff () (interactive) (let ((buffer (get-buffer-create "Testify Comparison"))) (shell-command-on-region (point-min) (point-max) "parsegotestifynotequal.py" buffer) (with-current-buffer buffer (fundamental-ansi-mode)) (switch-to-buffer buffer)))

+END_SRC

*** emacs-lisp **** elisp-slime-nav

+BEGIN_SRC emacs-lisp

(use-package elisp-slime-nav :commands elisp-slime-nav-mode :config (diminish 'elisp-slime-nav-mode) :preface (emit-prefix-selector imalison:elisp-slime-nav elisp-slime-nav-find-elisp-thing-at-point elisp-slime-nav-describe-elisp-thing-at-point) :bind (:map elisp-slime-nav-mode-map ("M-." . imalison:elisp-slime-nav)))

+END_SRC

**** Make find-function use display-buffer For some reason ~find-function~ doesn't allow to ~display-buffer~ to do what it's supposed to do, but instead uses its own collection of functions to control where the definition is popped up. This fixes that.

+BEGIN_SRC emacs-lisp

("Package"
                 ,"(use-package \\(.+\\)$" 1))
  (add-to-list 'imenu-generic-expression

("Section" ,(concat ";\{1,4\} =\{10,80\}\n;\{1,4\} \{10,80\}" "$.+$$") 1) t))

+BEGIN_SRC emacs-lisp

(use-package nix-update :after nix)

+END_SRC

*** clojure The following is taken from [[https://github.com/syl20bnr/spacemacs/blob/a650877bea582fed72bbca0dc1f80fcb2ec0e6d5/layers/+lang/clojure/funcs.el#L30][spacemacs]]. It adds fancification to a clojure mode.

+BEGIN_SRC emacs-lisp

(defun imalison:clojure-fancify-symbols (mode) "Pretty symbols for Clojure's anonymous functions and sets, like (λ a), ƒ(+ % 5), and ∈{2 4 6}." (font-lock-add-keywords mode `(("($fn$[\n[[:space:]]" (0 (progn (compose-region (match-beginning 1) (match-end 1) "λ")))) ("($partial$[[[:space:]]" (0 (progn (compose-region (match-beginning 1) (match-end 1) "Ƥ")))) ("($comp$[\n[[:space:]]" (0 (progn (compose-region (match-beginning 1) (match-end 1) "∘")))) ("$#$(" (0 (progn (compose-region (match-beginning 1) (match-end 1) "ƒ")))) ("$#${" (0 (progn (compose-region (match-beginning 1) (match-end 1) "∈")))))))

+END_SRC

+BEGIN_SRC emacs-lisp

(use-package clojure-mode :commands clojure-mode :preface (progn (add-to-list 'magic-mode-alist '("#!.boot\s-$" . clojure-mode)) (add-to-list 'auto-mode-alist '("\.boot\'" . clojure-mode))

  (defun imalison:clojure-mode-hook ()
    ;; (cljr-add-keybindings-with-prefix "C-c C-m")
    ;; This is disabled because seq-25 can't be loaded
    ;; (clj-refactor-mode 1)
    ;;for adding require/use/import statements
    (yas-minor-mode 1))

  (defvar imalison:clojure-level-1-symobls
    '(describe it)))
:config
(progn
  (cl-loop for symbol in imalison:clojure-level-1-symobls
           do (put-clojure-indent symbol 1))
  (add-hook 'clojure-mode-hook 'imalison:clojure-mode-hook)
  (dolist (m '(clojure-mode clojurescript-mode clojurec-mode clojurex-mode))
    (imalison:clojure-fancify-symbols m))))

(use-package js2-mode :commands (js2-mode) :mode "\.js\'" :preface (progn (defvar-setq imalison:identifier-count 0) (defun imalison:console-log-unique () (interactive) (let* ((identifier-string (int-to-string imalison:identifier-count)) (uuid (imalison:uuid))) (insert (format "console.log('%s//////////%s//////////');" identifier-string uuid)) (setq imalison:identifier-count (+ imalison:identifier-count 1)))) (defun imalison:js2-mode-hook () ;; Sensible defaults (setq js2-bounce-indent-p nil js2-indent-level 4 js2-basic-offset 4 js2-highlight-level 3 js2-include-node-externs t js2-mode-show-parse-errors nil js2-mode-show-strict-warnings nil indent-tabs-mode nil js2-indent-switch-body t) ;; (edconf-find-file-hook) ;; Make sure that editorconfig takes precedence ;; (tern-mode t) (when nil (skewer-mode)) ;; TODO: reenable (setq imenu-create-index-function (lambda () (imalison:flatten-imenu-index (js2-mode-create-imenu-index)))))) :init (progn (add-hook 'js2-mode-hook 'imalison:js2-mode-hook) (add-hook 'js2-mode-hook 'js2-imenu-extras-mode)))

(use-package js2-refactor :after js2-mode :config (progn (js2r-add-keybindings-with-prefix "C-c C-m") (add-hook 'js2-mode-hook #'js2-refactor-mode)))

(use-package skewer-mode :commands skewer-mode :config (progn (add-hook 'css-mode-hook #'skewer-css-mode) (add-hook 'html-mode-hook #'skewer-html-mode)))

(use-package tern :commands tern-mode :config (use-package company-tern :config (add-to-list 'company-backends 'company-tern)))

(use-package rust-mode :mode (("\.rs\'" . rust-mode)) :hook (rust-mode . lsp) :preface (progn (defun imalison:rust-mode-hook () (setq rust-format-on-save t))) :config (progn (use-package toml-mode)

;; Add keybindings for interacting with Cargo
(use-package cargo
  :hook (rust-mode . cargo-minor-mode))

(use-package flycheck-rust
  :config (add-hook 'flycheck-mode-hook #'flycheck-rust-setup))
(add-hook 'rust-mode-hook 'imalison:rust-mode-hook)))

+END_SRC

*** haskell

+BEGIN_SRC emacs-lisp

(defvar imalison:use-lsp-haskell nil) (defvar imalison:dfinity nil) (use-package haskell-mode :commands haskell-mode :bind (:map haskell-mode-map ("C-c h" . haskell-hoogle)) :preface (progn (defun imalison:haskell-mode () (turn-on-haskell-indent) (when imalison:dfinity (setq haskell-mode-stylish-haskell-path "brittany" haskell-mode-stylish-haskell-args '("-"))) (message "imalison:use-lsp-haskell: %s" imalison:use-lsp-haskell) (when imalison:use-lsp-haskell (lsp))) (add-hook 'haskell-mode-hook 'imalison:haskell-mode)) :config (progn (setq haskell-hoogle-command "hoogle" haskell-interactive-popup-errors nil haskell-process-auto-import-loaded-modules nil haskell-process-show-overlays nil haskell-stylish-on-save nil haskell-tags-on-save t haskell-indent-offset 2)

(require 'flycheck)
(cl-loop for checker in '(haskell-stack-ghc haskell-ghc haskell-hlint)
         do (delq checker flycheck-checkers))))

(setq helm-org-headings-fontify t)
(setq org-todo-repeat-to-state "TODO")

(setq org-agenda-span 10)
(setq org-agenda-start-day "-2d")
(setq org-columns-default-format
      "%80ITEM(Task) %10Effort(Effort){:} %10CLOCKSUM")
(add-to-list 'org-show-context-detail '(org-goto . lineage))
(add-to-list
 'org-src-lang-modes '("plantuml" . plantuml))
(add-hook 'org-mode-hook 'imalison:load-babel-languages)
(defun imalison:load-babel-languages ()
  (let* ((loaded-ob (or (require 'ob-sh nil t) (require 'ob-shell nil t)))
         (ob-shell-name
          (when loaded-ob
            (intern (substring-no-properties (imalison:maybe-symbol-name loaded-ob) 3))))
         (added-modes (when ob-shell-name ((,ob-shell-name . t)))))     (org-babel-do-load-languages      'org-babel-load-languages      ((python . t)
       (ruby . t)
       (octave . t)
       (sqlite . t)
       (plantuml . t)
       ,@added-modes))))
(setq org-log-into-drawer t
      org-log-reschedule t
      org-log-redeadline t
      org-treat-insert-todo-heading-as-state-change t)
(when nil
  ;; Enable appointment notifications.
  (defadvice org-agenda-to-appt (before wickedcool activate)
    "Clear the appt-time-msg-list."
    (setq appt-time-msg-list nil))
  (appt-activate)
  (defun org-agenda-to-appt-no-message ()
    (shut-up (org-agenda-to-appt)))
  (run-at-time "00:00" 60 'org-agenda-to-appt-no-message))
;; Override the key definition for org-exit
;; TODO why does this cause an error
;; (define-key org-agenda-mode-map "x" #'org-agenda-done)
;; org-mode add-ons
(use-package org-present
  :commands org-present)
(use-package org-pomodoro
  :disabled t)
;; variable configuration
(add-to-list 'org-modules 'org-habit)
(add-to-list 'org-modules 'org-expiry)
(add-to-list 'org-modules 'org-notify)
(setq org-src-fontify-natively t)
(setq org-habit-graph-column 50)
(setq org-habit-show-habits-only-for-today t)
;; My priority system:
;; A - Absolutely MUST, at all costs, be completed by the provided
;;     due date. TODO: implement some type of extreme nagging
;;     system that alerts in an intrusive way for overdue A
;;     priority tasks.
;; B - Should be given immediate attention if the due date is any
;;     time in the next two days. Failure to meet due date would
;;     be bad but not catastrophic.
;; C - The highest priority to which tasks for which failure to
;;     complete on time would not have considerable significant
;;     consequences. There is still significant reason to prefer
;;     the completion of these tasks sooner rather than later.
;; D - Failure to complete within a few days (or ever) of any
;;     deadline would be completely okay. As such, any deadline
;;     present on such a task is necessarily self imposed. Still
;;     probably worth doing
;; E - Potentially not even worth doing at all, but worth taking a
;;     note about in case it comes up again, or becomes more
;;     interesting later.
;; F - Almost certainly not worth attempting in the immediate future.
;;     Just brain dump.
;; Priorities are somewhat contextual within each category. Things
;; in the gtd or work categories are generally regarded as much
;; more important than things with the same priority from the
;; dotfiles category.
;; Items without deadlines or scheduled times of a given priority
;; can be regarded as less important than items that DO have
;; deadlines of that same priority.
(setq org-lowest-priority 69) ;; The character E
(setq org-completion-use-ido t)
(setq org-enforce-todo-dependencies t)
(setq org-deadline-warning-days 0)
(setq org-default-priority ?D)
(setq org-agenda-skip-scheduled-if-done t)
(setq org-agenda-skip-deadline-if-done t)
;;(add-to-list org-agenda-tag-filter-preset "+PRIORITY
:PROPERTIES:
  :CREATED: %U
  :END:")
(imalison:add-to-org-agenda-files
 (list imalison:org-gtd-file imalison:org-habits-file
       imalison:org-calendar-file imalison:org-inbox-file))

(add-to-list 'org-capture-templates
             `("t" "GTD Todo (Linked)" entry (file ,imalison:org-gtd-file)
               (function imalison:make-org-linked-todo-template)))
(add-to-list 'org-capture-templates
             `("g" "GTD Todo" entry (file ,imalison:org-gtd-file)
               (function imalison:make-org-todo-template)))
(add-to-list 'org-capture-templates
             `("y" "Calendar entry (Linked)" entry
               (file ,imalison:org-calendar-file)
               ,(format "%s%s\n%s" "* %? %A" imalison:created-property-string "%^T")))
(add-to-list 'org-capture-templates
             `("c" "Calendar entry" entry
               (file ,imalison:org-calendar-file)
               ,(format "%s\n%s\n%s" "* %?" imalison:created-property-string "%^T")))
(add-to-list 'org-capture-templates
             `("h" "Habit" entry (file ,imalison:org-habits-file)
               "* TODO
SCHEDULED: %^t
:PROPERTIES:
:CREATED: %U
:STYLE: habit
:END:"))
(let ((this-week-high-priority
       ;; The < in the following line has behavior that is opposite
       ;; to what one might expect.
       '(tags-todo "+PRIORITY"DEADLINE>"""
                   ((org-agenda-overriding-header
                     "Upcoming high priority tasks:"))))
      (due-today '(tags-todo
                   "+DEADLINE="|+SCHEDULED=""
                   ((org-agenda-overriding-header
                     "Due today:"))))
      (recently-created '(tags-todo
                          "+CREATED=>"""
                          ((org-agenda-overriding-header "Recently created:")
                           (org-agenda-cmp-user-defined 'org-cmp-creation-times)
                           (org-agenda-sorting-strategy '(user-defined-down)))))
      (next '(todo "NEXT"))
      (started '(todo "STARTED"))
      (missing-deadline
       '(tags-todo "-DEADLINE={.}/!"
                   ((org-agenda-overriding-header
                     "These don't have deadlines:"))))
      (missing-priority
       '(tags-todo "-PRIORITY={.}/!"
                   ((org-agenda-overriding-header
                     "These don't have priorities:")))))
  (setq org-agenda-custom-commands
        `(("M" "Main agenda view"
           ((agenda ""
                    ((org-agenda-overriding-header "Agenda:")
                     (org-agenda-ndays 5)
                     (org-deadline-warning-days 0)))
            ,due-today
            ,next
            ,started
            ,this-week-high-priority
            ,recently-created)
           nil nil)
          ,(cons "A" (cons "High priority upcoming" this-week-high-priority))
          ,(cons "d" (cons "Overdue tasks and due today" due-today))
          ,(cons "r" (cons "Recently created" recently-created))
          ("h" "A, B priority:" tags-todo "+PRIORITY
+END_SRC

**** Load org-config.el
I put some org-mode specific configs in a separate file so that they can be used
separately. This means that I need to load this file in init.el.

+BEGIN_SRC emacs-lisp

(load-file (concat (file-name-directory load-file-name) "org-config.el"))

+END_SRC

**** Use frames

+BEGIN_SRC emacs-lisp

(use-package org
  :config
  (progn
  (setq org-src-window-setup 'current-window)
    (when frame-mode
      (progn
        (setcdr (assoc 'file org-link-frame-setup) 'find-file-other-frame)))))

+END_SRC

**** Disable yasnippet in org-mode

+BEGIN_SRC emacs-lisp

(use-package org
  :straight nil
  :config
  (progn
    (defun imalison:disable-yas ()
      (yas-minor-mode -1))
    (add-hook 'org-mode-hook 'imalison:disable-yas)))

+END_SRC

**** Set Background Color of Source Blocks for Export
This was taken from [[http://emacs.stackexchange.com/questions/3374/set-the-background-of-org-exported-code-blocks-according-to-theme][here]].

+BEGIN_SRC emacs-lisp :tangle org-config.el

(use-package org
  :config
  (progn
    (defun imalison:org-inline-css-hook (exporter)
      "Insert custom inline css to automatically set the
background of code to whatever theme I'm using's background"
      (when (eq exporter 'html)
        (let* ((my-pre-bg (face-background 'default))
               (my-pre-fg (face-foreground 'default)))
          (setq
           org-html-head-extra
           (concat
            org-html-head-extra
            (format "\n"
                    my-pre-bg my-pre-fg))))))
(add-hook 'org-export-before-processing-hook 'imalison:org-inline-css-hook)))

+END_SRC

**** Use my own default naming scheme for org-headings
First we define a function that will generate a sanitized version of the heading
as its link target.

+BEGIN_SRC emacs-lisp :tangle org-config.el

(defun imalison:org-get-raw-value (item)
  (when (listp item)
    (let* ((property-list (cadr item)))
      (when property-list (plist-get property-list :raw-value)))))

(defun imalison:sanitize-name (name)
  (replace-regexp-in-string "[^[:alpha:]]" "" (s-downcase name)))

(defun imalison:generate-name (datum cache)
  (let ((raw-value (imalison:org-get-raw-value datum)))
    (if raw-value
        (imalison:sanitize-name raw-value)
      ;; This is the default implementation from org
      (let ((type (org-element-type datum)))
        (format "org%s%d"
                (if type
                    (replace-regexp-in-string "-" "" (symbol-name type))
                    "secondarystring")
                (incf (gethash type cache 0)))))))

+END_SRC

This function replaces the default naming scheme with a call to
~imalison:generate-name~, and uses a slightly different uniquify approach.

+BEGIN_SRC emacs-lisp :tangle org-config.el

(use-package ox
  :defer t
  :straight nil
  :config
  (defun org-export-get-reference (datum info)
    "Return a unique reference for DATUM, as a string.
DATUM is either an element or an object.  INFO is the current
export state, as a plist.  Returned reference consists of
alphanumeric characters only."
    (let ((type (org-element-type datum))
          (cache (or (plist-get info :internal-references)
                     (let ((h (make-hash-table :test #'eq)))
                       (plist-put info :internal-references h)
                       h)))
          (reverse-cache (or (plist-get info :taken-internal-references)
                             (let ((h (make-hash-table :test 'equal)))
                               (plist-put info :taken-internal-references h)
                               h))))
      (or (gethash datum cache)
          (let* ((name (imalison:generate-name datum cache))
                 (number (+ 1 (gethash name reverse-cache -1)))
                 (new-name (format "%s%s" name (if (< 0 number) number ""))))
            (puthash name number reverse-cache)
            (puthash datum new-name cache)
            new-name)))))

+END_SRC

**** Add link icons in headings that lead to themselves

+BEGIN_SRC emacs-lisp :tangle org-config.el

(use-package ox-html
  :commands (org-html-export-as-html org-html-export-as-html)
  :straight nil
  :preface
  (progn
    (defvar imalison:link-svg-html
      "")
    (defvar imalison:current-html-headline)
    (defun imalison:set-current-html-headline (headline &rest args)
      (setq imalison:current-html-headline headline))
    (defun imalison:clear-current-html-headline (&rest args)
      (setq imalison:current-html-headline nil))
    (defun imalison:org-html-format-heading-function (todo todo-type priority text tags info)
      (let* ((reference (when imalison:current-html-headline
                          (org-export-get-reference imalison:current-html-headline info)))
             ;; Don't do anything special if the current headline is not set
             (new-text (if reference
                           (format "%s %s" text reference imalison:link-svg-html)
                         text)))
        (org-html-format-headline-default-function
         todo todo-type priority new-text tags info))))
  :config
  (progn
    ;; This is set before and cleared afterwards, so that we know when we are
    ;; generating the text for the headline itself and when we are not.
    (advice-add 'org-html-headline :before 'imalison:set-current-html-headline)
    (advice-add 'org-html-headline :after 'imalison:clear-current-html-headline)
    (setq org-html-format-headline-function
          'imalison:org-html-format-heading-function)))

+END_SRC

**** Allow with query params in image extentions

+BEGIN_SRC emacs-lisp :tangle org-config.el

(use-package ox-html
  :defer t
  :straight nil
  :config
  (setq org-html-inline-image-rules
        '(("file" . "\.\(jpeg\|jpg\|png\|gif\|svg\)\(\?.*?\)?\'")
      ("http" . "\\.\\(jpeg\\|jpg\\|png\\|gif\\|svg\\)\\(\\?.*?\\)?\\'")
      ("https" . "\\.\\(jpeg\\|jpg\\|png\\|gif\\|svg\\)\\(\\?.*?\\)?\\'"))))

+END_SRC

**** Use org-tempo to allow inserting templates using e.g. <s

+begin_src emacs-lisp

(use-package org-tempo
  :straight nil
  :after org)

+end_src

**** org-projectile

+BEGIN_SRC emacs-lisp

(use-package org-projectile
  :defer 3
  :config
  (progn
    (setq org-projectile-projects-file
          (imalison:join-paths imalison:org-dir "projects.org")
          org-projectile-capture-template
          (format "%s%s" "* TODO %?" imalison:created-property-string))
    (add-to-list 'org-capture-templates
                 (org-projectile-project-todo-entry
                  :capture-character "l"
                  :capture-heading "Linked Project TODO"))
    (add-to-list 'org-capture-templates
                 (org-projectile-project-todo-entry
                  :capture-character "p"))
    (setq org-confirm-elisp-link-function nil)
    (imalison:add-to-org-agenda-files (org-projectile-todo-files))))

(use-package org-projectile-helm
  :after org-projectile
  :bind (("C-c n p" . org-projectile-helm-template-or-project)))

+END_SRC

**** org-pomodoro

+BEGIN_SRC emacs-lisp

(use-package org-pomodoro
  :after org)

+END_SRC

**** org-super-agenda

+BEGIN_SRC emacs-lisp

(use-package org-super-agenda
  :defer t
  :config
  (progn
    (org-super-agenda-mode +1)
    (setq org-super-agenda-groups
          '((:order-multi (1 (:name "High priority"
                                     :priority> "C")))
            (:order-multi (1 (:name "Done today"
                                    :and (:regexp "State \"DONE\""
                                                  :log t))))))))

+END_SRC

**** helm-org-rifle

+BEGIN_SRC emacs-lisp

(use-package helm-org-rifle
  :bind ("C-c C-h" . helm-org-rifle-agenda-files))

+END_SRC

**** org-notify
 #+BEGIN_SRC emacs-lisp
(use-package org-notify
  :disabled t
  :after org
  :config
  (progn
    (defun imalison:org-notify-notification-handler (plist)
      (sauron-add-event 'org-notify 4 (format "%s, %s.\n" (plist-get plist :heading)
                                              (org-notify-body-text plist))))
(setq org-show-notification-handler 'imalison:org-notify-notification-handler)

(org-notify-add 'default '(:time "1h" :actions imalison:org-notify-notification-handler
                                 :period "2m" :duration 60))
(org-notify-add 'default '(:time "100m" :actions imalison:org-notify-notification-handler
                                 :period "2m" :duration 60))
(org-notify-add 'urgent-second '(:time "3m" :actions (-notify/window -ding)
                                       :period "15s" :duration 10))
(org-notify-add 'minute '(:time "5m" :actions -notify/window
                                :period "100s" :duration 70))
(org-notify-add '12hours
                '(:time "3m" :actions (-notify/window -ding)
                        :period "15s" :duration 10)
                '(:time "100m" :actions -notify/window
                        :period "2m" :duration 60)
                '(:time "12h" :actions -notify/window :audible nil
                        :period "10m" :duration 200))
(org-notify-add '5days
                '(:time "100m" :actions -notify/window
                        :period "2m" :duration 60)
                '(:time "2d" :actions -notify/window
                        :period "15m" :duration 100)
                '(:time "5d" :actions -notify/window
                        :period "2h" :duration 200))
(org-notify-add 'long-20days
                '(:time "2d" :actions -notify/window
                        :period "15m" :duration 60)
                '(:time "5d" :actions -notify/window
                        :period "2h" :duration 60)
                '(:time "20d" :actions -email :period "2d" :audible nil))
(org-notify-add 'long-50days
                '(:time "4d" :actions -notify/window
                        :period "30m" :duration 100)
                '(:time "10d" :actions -notify/window
                        :period "4h" :duration 200)
                '(:time "50d" :actions -email :period "3d" :audible nil))
(org-notify-add 'long-100days
                '(:time "2d" :actions -notify/window
                        :period "1h" :duration 200)
                '(:time "10d" :actions -notify/window
                        :period "10h" :duration 300)
                '(:time "50d" :actions -email :period "3d" :audible nil)
                '(:time "100d" :actions -email :period "5d" :audible nil))
(org-notify-start 10)))

#+END_SRC
**** org-reveal

+BEGIN_SRC emacs-lisp

(use-package ox-reveal
  :defer t
  :commands org-reveal
  :config
  (setq org-reveal-root
      (imalison:join-paths "file://" imalison:projects-directory "reveal.js")))

+END_SRC

**** org-caldav

+BEGIN_SRC emacs-lisp

(use-package org-caldav
  :defer t
  :config
  (progn
    (setq org-caldav-url "https://www.google.com/calendar/dav"
          org-caldav-inbox imalison:org-inbox-file
          org-caldav-files (list imalison:org-calendar-file)
          org-icalendar-timezone "America/Los_Angeles")))

+END_SRC

*** TeX

+BEGIN_SRC emacs-lisp

(use-package tex
  :straight (auctex :host github :repo "raxod502/auctex"
                    :branch "fork/1"
                    :files (:defaults (:exclude "doc/*.texi")))
  :commands TeX-mode
  :preface
  (progn
    (defun imalison:TeX-mode-hook ()
      (turn-on-reftex)
      (TeX-source-correlate-mode +1)
      (TeX-PDF-mode +1)))
  :config
  (progn
    (unbind-key "C-j" TeX-mode-map)
    (TeX-global-PDF-mode)
    (setq TeX-auto-save t
          TeX-parse-self t
          TeX-save-query nil
          TeX-PDF-mode t)
    (TeX-global-PDF-mode t)
    (add-hook 'TeX-mode-hook 'imalison:TeX-mode-hook)))

+END_SRC

**** latex
 #+BEGINSRC emacs-lisp
(use-package latex
  :straight auctex
  :after tex
  :config
  (progn
    (unbind-key "C-j" LaTeX-mode-map)))
 #+ENDSRC
**** auctex-latexmk

+BEGIN_SRC emacs-lisp

(use-package auctex-latexmk
  :config
  (progn
    (setq auctex-latexmk-inherit-TeX-PDF-mode t)
    (auctex-latexmk-setup)))

+END_SRC

**** company-auctex

+BEGIN_SRC emacs-lisp

(use-package company-auctex
  :after tex
  :config
  (company-auctex-init))

+END_SRC

*** markdown-mode

+BEGIN_SRC emacs-lisp

(use-package markdown-mode
  :defer t
  :init
  (progn
    (add-hook 'markdown-mode-hook 'imalison:disable-linum-mode)))

+END_SRC

*** plantuml-mode

+BEGIN_SRC emacs-lisp

(use-package plantuml-mode
  :commands plantuml-mode
  :mode ("\.puml\'" "\.plantuml\'")
  :preface
  (progn
    (cond ((equal system-type 'darwin)
           (let* ((plantuml-dir
                   (s-trim (shell-command-to-string "brew --prefix plantuml")))
                  (filename
                   (when (file-exists-p plantuml-dir)
                     (--first (s-ends-with? ".jar" it) (directory-files plantuml-dir))))
                  (filepath (when filename
                              (imalison:join-paths plantuml-dir filename))))
             (setq plantuml-jar-path filepath
                   org-plantuml-jar-path filepath)))
          ((equal system-type 'gnu/linux)
           (let ((filepath "/opt/plantuml/plantuml.jar"))
             (setq plantuml-jar-path filepath
                   org-plantuml-jar-path filepath))))
    (add-to-list
     'org-src-lang-modes '("plantuml" . plantuml))))

+END_SRC

*** wsd-mode

+BEGIN_SRC emacs-lisp

(use-package wsd-mode
  :commands (wsd-mode))

+END_SRC

*** adoc-mode

+begin_src emacs-lisp

(use-package adoc-mode
  :mode "\.adoc\'")

+end_src

** Utility
*** restclient

+BEGIN_SRC emacs-lisp

(use-package restclient
  :mode (("\.restclient\'" . restclient-mode))
  :config
  (progn
    (use-package company-restclient)))

+END_SRC

*** jq-mode

+BEGIN_SRC emacs-lisp

(use-package jq-mode
  :mode "\.jq\'")

+END_SRC

*** systemd

+BEGIN_SRC emacs-lisp

(use-package systemd
  :commands systemd-mode
  :preface
  (ignore
   (add-to-list 'auto-mode-alist
                '("\.service\'" . systemd-mode))
   (add-to-list 'auto-mode-alist
                '("\.socket\'" . systemd-mode))))

+END_SRC

Source Control ** magit

+BEGIN_SRC emacs-lisp

(use-package magit :commands magit-status :bind (("C-x g" . imalison:magit-status)) :preface (progn (emit-let-around imalison:magit-status-traditional magit-status (magit-display-buffer-function 'magit-display-buffer-traditional)) (emit-prefix-selector imalison:magit-status magit-status imalison:magit-status-traditional) (defun imalison:after-magit-visit-file (&rest args) (when (derived-mode-p 'org-mode) (org-show-context 'magit-goto)))) :config (progn (when frame-mode (setq magit-commit-show-diff t)) (unbind-key "C-j" magit-status-mode-map) (unbind-key "C-j" magit-hunk-section-map) (unbind-key "C-j" magit-file-section-map) (setq magit-last-seen-setup-instructions "1.4.0" magit-display-buffer-function 'magit-display-buffer-same-window-except-diff-v1) (magit-auto-revert-mode)

(add-to-list 'org-show-context-detail '(magit-goto . lineage)) (advice-add 'magit-diff-visit-file :after 'imalison:after-magit-visit-file) (add-hook 'magit-popup-mode-hook 'imalison:disable-show-trailing-whitespace)))

+END_SRC

*** forge

+begin_src emacs-lisp

(use-package forge :after magit)

+end_src

*** magithub I've disabled magithub because it causes magit to be super slow

+BEGIN_SRC emacs-lisp

(use-package magithub :disabled t :after magit)

+END_SRC

** vc

+begin_src emacs-lisp

(use-package vc :config (progn (defun vc-find-revision-of-file (revision) (interactive (list (vc-read-revision "Revision to visit: " (list (imalison:join-paths (magit-toplevel) (car (magit-list-files))))))) (let* ((file (completing-read "Select file to visit: " (magit-revision-files revision))) (full-file (imalison:join-paths (magit-toplevel) file))) (switch-to-buffer (vc-find-revision full-file revision))))))

+end_src

** git-link

+BEGIN_SRC emacs-lisp

(use-package git-link :defer t :config (progn (setq git-link-use-commit t)))

+END_SRC

** magit-gitflow

+BEGIN_SRC emacs-lisp

(use-package magit-gitflow :diminish magit-gitflow-mode :after magit :init (progn (setq magit-gitflow-popup-key "C-k")) :config (progn (add-hook 'magit-mode-hook 'turn-on-magit-gitflow)))

+END_SRC

** git-gutter

+BEGIN_SRC emacs-lisp

(use-package git-gutter :disabled t :config (progn (global-git-gutter-mode +1)))

+END_SRC

** gitolite-clone

+BEGIN_SRC emacs-lisp

(use-package gitolite-clone :defer 4 :preface (progn (defun gitolite-clone-force-refresh () (interactive) (gitolite-clone-get-projects nil nil t))))

+END_SRC

** gitconfig-mode

+BEGIN_SRC emacs-lisp

(use-package gitconfig-mode :mode "\.?gitconfig.?.*\'")

+END_SRC

** gitignore-mode

+BEGIN_SRC emacs-lisp

(use-package gitignore-mode :mode "\.?gitignore.?.*\'")

+END_SRC

** github *** github-search

+BEGIN_SRC emacs-lisp

(use-package github-search :commands (github-search-clone-repo github-search-user-clone-repo) :preface (progn (defun imalison:get-appropriate-path-from-gh-repo-for-go (repo) (require 'go-mode) (imalison:get-go-src "github.com" (oref (oref repo :owner) :login) (oref repo :name)))

(defun imalison:get-projects-directory-target-from-repo (repo) (let ((prospective-path (if (equal (oref repo language) "Go") (imalison:get-appropriate-path-from-gh-repo-for-go repo) (imalison:join-paths imalison:projects-directory (oref repo :name))))) (if (file-exists-p prospective-path) (funcall 'github-search-prompt-for-target-directory repo) prospective-path)))) :config (progn (setq github-search-get-target-directory-for-repo-function 'imalison:get-projects-directory-target-from-repo ;; See https://github.com/sigma/gh.el/issues/102 gnutls-algorithm-priority "NORMAL:-VERS-TLS1.3")))

+END_SRC

*** github-clone

+BEGIN_SRC emacs-lisp

(use-package github-clone :commands (github-clone-add-parent-remote github-clone-add-source-remote github-clone-fork-remote github-clone-add-existing-remote github-clone))

+END_SRC

*** github-notifier This is disabled because it was causing too many issues with my modeline and with excessive http requests to github.

+BEGIN_SRC emacs-lisp

(use-package github-notifier :disabled t :config (progn (advice-add 'github-notifier-update :around 'imalison:shut-up-around) (github-notifier-mode)))

+END_SRC

*** github-browse-file

+BEGIN_SRC emacs-lisp

(use-package github-browse-file :commands github-browse-file)

+END_SRC

*** magit-gh-pulls

+BEGIN_SRC emacs-lisp

(use-package magit-gh-pulls :disabled t :diminish magit-gh-pulls-mode :after magit :config (progn (add-hook 'magit-mode-hook 'turn-on-magit-gh-pulls)))

+END_SRC

*** gist

+BEGIN_SRC emacs-lisp

(use-package gist :commands (gist-region gist-region-private gist-buffer gist-buffer-private gist-region-or-buffer gist-region-or-buffer-private gist-list-user gist-list gist-fetch gist-star gist-unstar gist-list-starred gist-fork))

+END_SRC
Programming ** realgud realgud provides debugging support with many external debuggers in emacs

+BEGIN_SRC emacs-lisp

(use-package realgud :defer 10)

+END_SRC

** emr emr (emacs refactor) provides support for refactoring in many programming languages

+BEGIN_SRC emacs-lisp

(use-package emr :bind (:map prog-mode-map ("M-RET" . emr-show-refactor-menu)) :config (emr-initialize))

+END_SRC

** semantic

+BEGIN_SRC emacs-lisp

(use-package semantic :commands semantic-mode :disabled t :preface (progn (add-hook 'prog-mode-hook 'semantic-mode)))

+END_SRC

** language-server-protocol (lsp)

+BEGIN_SRC emacs-lisp

(use-package lsp-mode :config (progn (setq lsp-prefer-flymake nil) (use-package lsp-ui :config (add-hook 'lsp-mode-hook 'lsp-ui-mode)) (add-hook 'programming-mode-hook 'lsp)))

+END_SRC
Utility ** term The main thing I do here is restore a bunch of keybindings that are eliminated in term-mode. This makes term-mode 1000% more useful (especially having M-x and C-y available).

+BEGIN_SRC emacs-lisp

(use-package term :demand t :preface (progn (defun imalison:avy-term (arg) (interactive "P") (term-line-mode) (imalison:avy arg))

(defun imalison:term-paste (&optional string) (interactive) (process-send-string (get-buffer-process (current-buffer)) (if string string (current-kill 0))))) :bind (:map term-mode-map ("C-c C-k" . imalison:term-char-mode) :map term-raw-escape-map ("M-x" . helm-M-x) ("C-j" . imalison:avy-term) :map term-raw-map ("M-x" . helm-M-x) ("C-j" . imalison:avy-term) ("M-:" . eval-expression) ("C-y" . imalison:term-paste) ("M-y" . helm-show-kill-ring-for-term)) :config (progn (use-package helm-ring :straight nil :defer 1 :config (progn (defvar helm-kill-ring-for-term-actions '(("Yank" . imalison:term-paste) ("Delete" . (lambda (_candidate) (cl-loop for cand in (helm-marked-candidates) do (setq kill-ring (delete cand kill-ring))))))) (defvar helm-source-kill-ring-for-term (helm-build-sync-source "Kill Ring" :init (lambda () (helm-attrset 'last-command last-command)) :candidates #'helm-kill-ring-candidates :filtered-candidate-transformer #'helm-kill-ring-transformer :action 'helm-kill-ring-for-term-actions :persistent-action 'ignore :persistent-help "DoNothing" :migemo t :multiline t))
```
(defun helm-show-kill-ring-for-term ()
  "Preconfigured `helm' for `kill-ring'.
```
It is drop-in replacement of `yank-pop'.

First call open the kill-ring browser, next calls move to next line." (interactive) (let ((enable-recursive-minibuffers t)) (helm :sources helm-source-kill-ring-for-term :buffer "helm kill ring" :resume 'noresume :allow-nest t)))))

(defun imalison:term-char-mode ()
  (interactive)
  (term-char-mode)
  (goto-char (point-max)))
(define-key term-raw-map (kbd "C-h") help-map)
(add-hook 'term-mode-hook 'imalison:disable-linum-mode)
(add-hook 'term-mode-hook 'imalison:disable-yas-minor-mode)
(add-hook 'term-mode-hook 'imalison:disable-show-trailing-whitespace)
(setq term-buffer-maximum-size 0
      term-suppress-hard-newline t)))

+END_SRC

** vterm

+begin_src emacs-lisp

;; (use-package vterm)

+end_src

** term-manager

+BEGIN_SRC emacs-lisp

(use-package term-manager :defer t :preface (progn (defun imalison:set-escape-char (&rest _args) (let (term-escape-char) (term-set-escape-char ?\C-x)))) :config (progn (advice-add 'term-manager-default-build-term :after 'imalison:set-escape-char)))

+END_SRC

** term-projectile

+BEGIN_SRC emacs-lisp

(use-package term-projectile :bind ("C-c 7" . imalison:term-hydra-global/body) :commands (term-projectile-forward term-projectile-backward term-projectile-default-directory-forward term-projectile-default-directory-backward term-projectile-create-new term-projectile-create-new-default-directory) :config (progn (emit-prefix-selector imalison:term term-projectile-forward term-projectile-create-new)

(defvar imalison:term-hydra-original-default-directory)

(defhydra imalison:term-hydra-default-directory
  (:body-pre
   (term-projectile-default-directory-forward-restored))
  "term - default-directory"
  ("s" term-projectile-switch-to)
  ("f" term-projectile-default-directory-forward-restored)
  ("b" term-projectile-default-directory-backward-restored)
  ("c" term-projectile-default-directory-create-new-restored)
  ("d" term-projectile-default-directory-forward-restored)
  ("g" imalison:term-hydra-global/body-restored :exit t)
  ("p" imalison:term-hydra-projectile/body-restored :exit t))
(defhydra imalison:term-hydra-projectile
  (:body-pre
   (progn
     (term-projectile-forward-restored)))
  "term - projectile"
  ("s" term-projectile-switch-to)
  ("f" term-projectile-forward-restored)
  ("b" term-projectile-backward-restored)
  ("c" term-projectile-create-new-restored)
  ("d" imalison:term-hydra-default-directory/body-restored :exit t)
  ("g" imalison:term-hydra-global/body-restored :exit t)
  ("p" term-projectile-forward-restored))
(defhydra imalison:term-hydra-global
  (:body-pre
   (progn (setq imalison:term-hydra-original-default-directory
                default-directory)))
  "term - global"
  ("s" term-projectile-switch-to)
  ("f" term-projectile-global-forward-restored)
  ("b" term-projectile-global-backward-restored)
  ("c" term-projectile-global-create-new-restored)
  ("d" imalison:term-hydra-default-directory/body-restored :exit t)
  ("g" term-projectile-global-forward-restored)
  ("p" imalison:term-hydra-projectile/body-restored :exit t))
(mapcar (lambda (term-projectile-function)
          (defalias (imalison:concat-symbols term-projectile-function '-restored)
            (lambda (&rest args)
              (interactive)
              (let ((default-directory imalison:term-hydra-original-default-directory))
                (apply term-projectile-function args)))))
        '(term-projectile-default-directory-forward
          term-projectile-default-directory-backward
          term-projectile-default-directory-create-new
          term-projectile-forward
          term-projectile-backward
          term-projectile-create-new
          term-projectile-global-forward
          term-projectile-global-backward
          term-projectile-global-create-new
          imalison:term-hydra-global/body
          imalison:term-hydra-projectile/body
          imalison:term-hydra-default-directory/body))))

As a side-effect, a message that is being viewed loses its 'unread' marking if it still had that." (let* ((embedded ;; is it as an embedded msg (ie. message/rfc822 att)? (when (gethash (mu4e-message-field msg :path) mu4e~path-parent-docid-map) t)) (buf (if embedded (mu4e~view-embedded-winbuf) (get-buffer-create mu4e~view-buffer-name)))) ;; note: mu4e~view-mark-as-read will pseudo-recursively call mu4e-view again ;; by triggering mu4e~view again as it marks the message as read (with-current-buffer buf (switch-to-buffer buf) (setq mu4e~view-msg msg) ;;(or embedded (not (mu4e~view-mark-as-read msg))) (when (or (mu4e~view-mark-as-read msg) t) (let ((inhibit-read-only t)) (erase-buffer) (mu4e~delete-all-overlays) (insert (mu4e-view-message-text msg)) (goto-char (point-min)) (mu4e~fontify-cited) (mu4e~fontify-signature) (mu4e~view-make-urls-clickable) (mu4e~view-show-images-maybe msg) (setq mu4e~view-buffer buf mu4e~view-headers-buffer headersbuf) (when embedded (local-set-key "q" 'kill-buffer-and-window)) (mu4e-view-mode))))))

(require 'smtpmail)

;; alternatively, for emacs-24 you can use:
(setq message-send-mail-function 'smtpmail-send-it
      smtpmail-stream-type 'starttls
      smtpmail-default-smtp-server "smtp.gmail.com"
      smtpmail-smtp-server "smtp.gmail.com"
      smtpmail-smtp-service 587)))

(use-package hackernews :commands hackernews)

+END_SRC

Appearance ** Basic Config #+BEGINSRC emacs-lisp (setq inhibit-startup-screen t) (blink-cursor-mode -1) #+ENDSRC ** Themes Ensure all themes that I use are installed: #+BEGIN_SRC emacs-lisp (use-package solarized-theme :defer t :init (progn (setq solarized-high-contrast-mode-line t)))

(defvar-setq packages-appearance '(monokai-theme zenburn-theme base16-theme molokai-theme moe-theme tango-2-theme gotham-theme sublime-themes rainbow-delimiters waher-theme ample-theme material-theme zerodark-theme color-theme-modern leuven-theme spacemacs-theme gruvbox-theme forest-blue-theme flatland-theme afternoon-theme cyberpunk-theme))

** Whitespace Setup

Make whitespace-mode use just basic coloring:

+BEGIN_SRC emacs-lisp

(setq whitespace-style '(spaces tabs newline space-mark tab-mark newline-mark))

+END_SRC

Set the character used to represent spaces to ·, and the character used for tabs to be ▷.

+BEGIN_SRC emacs-lisp

(setq whitespace-display-mappings '((space-mark 32 [183] [46]) (tab-mark 9 [9655 9] [92 9])))

+END_SRC

** Colorize Compliation Buffers This automatically applies ansi-color interpretation of terminal escape sequences to compilation buffers.

+BEGIN_SRC emacs-lisp

(defun imalison:colorize-compilation-buffer () (let ((was-read-only buffer-read-only)) (unwind-protect (progn (when was-read-only (read-only-mode -1)) (ansi-color-apply-on-region (point-min) (point-max))) (when was-read-only (read-only-mode +1)))))

(add-hook 'compilation-filter-hook 'imalison:colorize-compilation-buffer)

+END_SRC

(defvar imalison:appearance-setup-done nil)

(defun imalison:appearance-setup-hook (&rest args) (unless imalison:appearance-setup-done (unless (member imalison:dark-theme custom-enabled-themes) (load-theme imalison:dark-theme t)) (apply 'imalison:appearance args) (setq imalison:default-font-size-pt (face-attribute 'default :height)) (setq imalison:appearance-setup-done t)))

(if (daemonp) (add-hook 'after-make-frame-functions 'imalison:appearance-setup-hook) (add-hook 'after-init-hook 'imalison:appearance-setup-hook))

+END_SRC

Post Init Custom #+BEGINSRC emacs-lisp (when (file-exists-p custom-after-file) (load custom-after-file)) (when (file-exists-p machine-custom) (load machine-custom)) #+ENDSRC