Emacs Configuration
This configuration is no longer maintained, so it has been archived. I used this Emacs configuration in 2018–2021, but I made a rewrite in 2022.
Table of contents
Prerequisites
- Linux or Window Subsystem for Linux
- Nix package manager for installing dependencies
Installation
This configuration depends on some external programs as well as Emacs Lisp packages built by Nix.
At present, a suggested installation procedure is to first install my home.nix and then run mr checkout at your home directory.
In the future, it may support an alternative for trying out.
License
GPL v3.
Some libraries were originally written by other people, and they follow their respective licenses.
Initialization
(when (version< emacs-version "27.1")
(error "Use GNU Emacs version 27.1 or later"))
(let ((local-custom-file "~/local/emacs/custom.el"))
(if (file-exists-p local-custom-file)
(setq custom-file local-custom-file)
(message "%s does not exist, so custom-file is not set"
local-custom-file)))
(when custom-file
(load custom-file nil :nomessage))
(unless (fboundp 'whitespace-cleanup-mode)
(defun whitespace-cleanup-mode (&rest args)
(when (require 'whitespace-cleanup-mode nil t)
(apply #'whitespace-cleanup-mode args))))
(add-to-list 'exec-path (expand-file-name "~/.nix-profile/bin"))
(defconst akirak/to-be-run-as-exwm (member "--exwm" command-line-args))
(defun akirak/exwm-session-p ()
akirak/to-be-run-as-exwm)Configure straight.el
(load-file (expand-file-name "core/straight.el" user-emacs-directory))Install use-package using straight.el
(straight-use-package 'use-package)Use straight.el by default in use-package directives
(setq straight-use-package-by-default t)Benchmarking the startup process
(use-package benchmark-init
:hook
(after-init . benchmark-init/deactivate))Use the latest Git version of Org mode
(require 'cl-lib)
(require 'subr-x)Remove org-mode shipped with Emacs from load-path
(use-package org
:straight (:type built-in)
:config
(require 'org-loaddefs))Recipe overrides
(akirak/straight-use-recipes-from-file
akirak/straight-default-recipes-file)
(setq straight-x-pinned-packages
'(("dracula-theme" . "11391ea531d40fb08c64313bbb86e4d29d7fe1c5")))Load configuration files
(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))
(require 'my/const/system)TODO: Move to lisp/
(add-to-list 'load-path (expand-file-name "extras" user-emacs-directory))Configuration
Prevent a confirmation dialog when the org file is loaded. Don’t forget to revert this variable at the beginning of the Org file.
(setq-default enable-local-variables :all)
(load-file (expand-file-name "core/setup.el" user-emacs-directory))Things to set up before using use-package
(akirak/require 'setup-gc)
(setq-default enable-local-variables :safe)These packages are required in other use-package directives declared in this configuration.
(use-package el-patch
:custom
(el-patch-enable-use-package-integration t))Package-specific configuration files, including snippets, are kept in a separate repository, not in this repository.
(use-package no-littering
:preface
(let* ((var-dir "~/local/emacs/var/"))
(unless (file-directory-p var-dir)
(make-directory var-dir t))
(setq no-littering-var-directory var-dir)))Use the executable path from the shell
(use-package exec-path-from-shell
:disabled t
:if (memq window-system '(mac ns x))
:init
(exec-path-from-shell-initialize))
(use-package use-package-company
;; Originally written by Foltik, but I use my fork
:straight (use-package-company :host github :repo "akirak/use-package-company"))
(use-package info
:straight (:type built-in)
:config
(add-to-list 'Info-directory-list
(expand-file-name "share/info"
(file-name-directory
(string-remove-suffix "/" invocation-directory)))))Keybindings
(use-package which-key
:init
(which-key-mode t)
:config
(which-key-setup-side-window-bottom)
(defmacro akirak/which-key-add-stripped-prefix (prefix)
"Add PREFIX as a stripped prefix to `which-key-replacement-alist'."
`(add-to-list 'which-key-replacement-alist
(quote ((nil . ,prefix) .
(lambda (kb)
(cons (car kb)
(string-remove-prefix ,prefix (cdr kb))))))))
(akirak/which-key-add-stripped-prefix "akirak/")
(akirak/which-key-add-stripped-prefix "helm-org-multi-wiki-create/"))Use general.el to define keybindings. It has made several improvements over bind-key, including a built-in integration with which-key.
This also adds support for :general keyword in use-package
directives.
(use-package general
:config
(general-create-definer akirak/bind-search :prefix "M-s")
(general-create-definer akirak/bind-jump :prefix "M-g")
(general-create-definer akirak/bind-register :prefix "C-x r")
(general-create-definer akirak/bind-help :prefix "<f1>")
(general-create-definer akirak/bind-file-extra :prefix "<f6>")
;; <f7> is currently free
(general-create-definer akirak/bind-f8 :prefix "<f8>")
;; <f9> is reserved for recompile
(general-create-definer akirak/bind-admin :prefix "<f12>"
:prefix-map 'akirak/admin-map)
;; ~C-c~ is reserved for the user.
;; Package developers should not use them for their packages.
(general-create-definer akirak/bind-user :prefix "C-c")
;; bind-mode (C-,) for major-mode-specific commands
(defconst akirak/mode-prefix-key "C-,"
"Prefix for mode-specific keys.")
(general-create-definer akirak/bind-mode :prefix akirak/mode-prefix-key)
;; Use ~<C-return>~ for starting a REPL session
(general-create-definer akirak/bind-mode-repl
:prefix "<C-return>")
;; TODO: I want to change this key to something else
(general-create-definer akirak/bind-customization :prefix "C-x ESC"))
(use-package defrepeater
:general
([remap other-window] (defrepeater #'other-window)
[remap winner-undo] (defrepeater #'winner-undo)
[remap winner-redo] (defrepeater #'winner-redo)
[remap text-scale-increase] (defrepeater #'text-scale-increase)
[remap text-scale-decrease] (defrepeater #'text-scale-decrease)))Default settings
(require 'setup-defaults)
(when (akirak/running-on-crostini-p)
(require 'my/system/platform/crostini))
(require 'setup-gpg)Migrating
In case there are functions that depends on these modules, load them first.
(require 'my/project)
(require 'my/buffer/predicate)
(org-babel-load-file (expand-file-name "main.org" user-emacs-directory))Packages
(use-package dash-docs)
(use-package emacs-everywhere
;; Use my fork until the path issue is fixed
:straight (:host github :repo "akirak/emacs-everywhere" :branch "with-editor-1")
:functions (emacs-everywhere)
:general
(:keymaps 'emacs-everywhere-mode-map
;; Analogous to the post command in most web applications,
;; and it's also bound to mode-aware repl commands, which
;; is irrelevant in text-mode.
"<C-return>" #'emacs-everywhere-finish))
(use-package helm-dash
:custom
(dash-docs-browser-func #'akirak/browse-url))
(use-package discover-my-major
:commands (discover-my-major))
(use-package electric
:straight (:type built-in)
:hook
(text-mode . electric-pair-local-mode))
(use-package epkg)
(use-package helm-tail
:commands (helm-tail))
(use-package org-recent-headings
:disabled t
:after org
:config
(general-add-hook 'org-recent-headings-advise-functions
'(org-multi-wiki-follow-link
org-multi-wiki-visit-entry
akirak/avy-org-heading
org-insert-heading
helm-org-ql-show-marker
helm-org-ql-show-marker-indirect))
(org-recent-headings-mode 1)
(setq org-recent-headings-reject-any-fns
(list (defun akirak/org-recent-headings-reject-journal-date (entry)
(when (featurep 'org-multi-wiki)
(let ((file (org-recent-headings-entry-file entry))
(olp (org-recent-headings-entry-outline-path entry)))
(when-let (plist (org-multi-wiki-entry-file-p file))
(and (eq 'journal (plist-get plist :namespace))
(= 1 (length olp)))))))))
(defun akirak/org-recent-headings-cleanup ()
(interactive)
(let ((m (length org-recent-headings-list))
(start-time (float-time))
(n (progn
(dolist (x org-recent-headings-list)
(condition-case _
(org-recent-headings--entry-marker x)
(error (cl-delete x org-recent-headings-list
:test #'org-recent-headings--equal))))
(length org-recent-headings-list))))
(unless (= m n)
(message "Deleted %d non-existent items from org-recent-headings-list in %.1f s"
(- m n)
(- (float-time) start-time))))
;; Prevent automatic GC toon soon after getting back to work
(garbage-collect))
(run-with-idle-timer 1200 t #'akirak/org-recent-headings-cleanup))
(use-package helm-org-recent-headings
:disabled t
:after (helm org-recent-headings)
:config
;; Modified from `helm-org-recent-headings-source'.
(defvar akirak/helm-org-recent-headings-source
(helm-build-sync-source " Recent Org headings"
:candidates (lambda ()
org-recent-headings-list)
:candidate-number-limit 'org-recent-headings-candidate-number-limit
:candidate-transformer 'helm-org-recent-headings--truncate-candidates
:keymap helm-org-recent-headings-map
:action 'akirak/helm-org-recent-headings-actions)
"Helm source for `org-recent-headings'.")
(defvar akirak/helm-org-recent-headings-actions
(helm-make-actions
"Show entry (default function)" 'org-recent-headings--show-entry-default
"Show entry in real buffer" 'org-recent-headings--show-entry-direct
"Show entry in indirect buffer" 'org-recent-headings--show-entry-indirect
"Insert a link to the heading"
(defun akirak/org-recent-headings-insert-link (entry)
(unless (derived-mode-p 'org-mode)
(user-error "Not in org-mode"))
(let ((marker (org-recent-headings--entry-marker entry)))
(with-current-buffer (marker-buffer marker)
(org-with-wide-buffer
(goto-char marker)
(org-store-link nil 'interactive))))
(org-insert-last-stored-link 1))
"Remove entry" 'helm-org-recent-headings-remove-entries
"Bookmark heading" 'org-recent-headings--bookmark-entry)))
(use-package license-templates)
(use-package project
:config
(add-hook 'project-find-functions
(defun akirak/project-tramp-root (dir)
(-some->> (file-remote-p dir)
(cons 'remote))))
(add-hook 'project-find-functions
(defun akirak/project-syncthing-root (dir)
(-some->> (locate-dominating-file dir ".stfolder")
(cons 'syncthing)))))
(use-package su)
(use-package valign
:disabled t
:hook
(org-mode . valign-mode))
(use-package whole-line-or-region)Modules
(require 'setup-project)
(require 'setup-git-bookmark)
(require 'setup-info)
(require 'setup-unicode)
(require 'setup-mmm)Starting the server
This may fail if there is another Emacs session running a server.
(ignore-errors
(unless (server-running-p)
(server-start)))Commands and keybindings
Basic keybindings
These keybindings basically emulate UNIX shells (i.e. sh, bash, etc.).
I also like to define “dwim” commands, if applicable, to save the keybinding space and key strokes.
C-a
By default, C-a is bound to beginning-of-line.
This command first jump to the indentation and then visits the beginning of line.
(general-def prog-mode-map
"C-a"
(defun akirak/back-to-indentation-or-beginning-of-line ()
(interactive)
(if (or (looking-at "^")
(string-match-p (rx (not (any space)))
(buffer-substring-no-properties
(line-beginning-position)
(point))))
(back-to-indentation)
(beginning-of-line))))In org-mode, I prefer org-beginning-of-line.
(general-def :keymaps 'org-mode-map :package 'org
"C-a" #'org-beginning-of-line)C-e
(general-def :keymaps 'org-mode-map :package 'org
"C-e" #'org-end-of-line)C-h
(general-def
"C-h" 'backward-delete-char)C-w
(general-def
"C-w"
(defun akirak/kill-region-or-backward-kill-word (&optional arg)
"If a region is active, run `kill-region'. Otherwise, run `backward-kill-word'."
(interactive "p")
(if (region-active-p)
(kill-region (region-beginning) (region-end))
(backward-kill-word arg))))
(general-def minibuffer-local-map
"C-w" #'backward-kill-word)
(general-def ivy-minibuffer-map :package 'ivy
"C-w" #'ivy-backward-kill-word)C-u
(general-def minibuffer-local-map
"C-u" #'backward-kill-sentence)
(general-def ivy-minibuffer-map :package 'ivy
"C-u"
(defun ivy-backward-kill-sentence ()
(interactive)
(if ivy--directory
(progn (ivy--cd "/")
(ivy--exhibit))
(if (bolp)
(kill-region (point-min) (point))
(backward-kill-sentence)))))C-r
In minibuffers, C-r should call history.
(general-def ivy-minibuffer-map :package 'ivy
"C-r" 'counsel-minibuffer-history)Key translation and simulation
Since I have bound C-h to backward-delete-char but still use the
help system frequently, I bind M-` to <f1> in
key-translation-map.
(general-def key-translation-map
;; * Obsolete
;; As <menu> (application on Windows keyboards) is hard to reach on some
;; keyboards, I will use <C-tab> instead. This key combination is occupied on
;; web browsers but vacant on most Emacs major modes, so it is safe to use it
;; on non-EXWM buffers.
;; "<C-tab>" (kbd "<menu>")
;; Chromebook don't have physical function keys. They substitute
;; Search + num for function keys, but Search + 1 is hard to press,
;; especially when Search and Ctrl are swapped.
;; This is quite annoying, so I will use M-` as <f1>.
"M-`" (kbd "<f1>"))
(general-def "M-r" (general-simulate-key "C-x r"))Emulate virtual function keys of Chrome OS
Emulate function keys of Chrome OS, i.e. use s-NUM as function
keys.
(define-globalized-minor-mode akirak/emulate-chromeos-fnkey-mode
nil
(lambda ()
(cond
(akirak/emulate-chromeos-fnkey-mode
(dolist (n (number-sequence 1 9))
(define-key key-translation-map
(kbd (format "s-%d" n)) (kbd (format "<f%d>" n))))
(define-key key-translation-map
(kbd "s-0") (kbd "<f10>"))
(define-key key-translation-map
(kbd "s--") (kbd "<f11>"))
(define-key key-translation-map
(kbd "s-=") (kbd "<f12>")))
(t
(dolist (n (number-sequence 0 9))
(define-key key-translation-map
(kbd (format "s-%d" n)) nil))
(define-key key-translation-map
(kbd "s--") nil)
(define-key key-translation-map
(kbd "s-=") nil)))))
(unless (akirak/running-on-crostini-p)
(akirak/emulate-chromeos-fnkey-mode 1))Insert strings/characters
(defmacro akirak/def-insert-date-time-command (name format)
`(defun ,(intern (format "akirak/insert-%s" name)) ()
(interactive)
(insert (format-time-string ,format))))This prefix map will be overridden in org-mode
(general-def :prefix "C-c !"
"8" (akirak/def-insert-date-time-command "yyyymmdd-date" "%Y%m%d")
"f" (akirak/def-insert-date-time-command "iso8601-date" "%F")
"t" (akirak/def-insert-date-time-command "iso8601-datetime" "%FT%X"))Switching buffers
Switching buffers is the most essential operation in Emacs. Most of these commands are bound on C-x.
Helm commands
(general-def
"C-x b"
(defun akirak/switch-to-project-file-buffer (project)
(interactive (list (if current-prefix-arg
'all
(-some-> (project-current)
(project-roots)
(car-safe)))))
(cond
((eq project 'all)
(helm-buffers-list))
(t
(let ((default-directory (or project default-directory)))
(helm :prompt (format "Project %s: " project)
:sources
`(,@(akirak/helm-project-buffer-sources project #'akirak/switch-to-project-file-buffer)
,akirak/helm-source-recent-files))))))
"C-x p"
(defun akirak/find-file-recursively (root)
(interactive (list (or (akirak/project-root default-directory)
(akirak/try-init-project-root)
(user-error "Cannot find the project root"))))
(require 'my/helm/source/file)
(when current-prefix-arg
(akirak/clear-project-file-cache root :sort 'modified))
(let ((default-directory root))
(helm :prompt (format "Browse %s: " root)
:sources
(list akirak/helm-source-project-files
akirak/helm-source-dummy-find-file))))
"C-x d"
(defun akirak/switch-to-dired-buffer ()
"Switch to a directory buffer interactively.
Without a prefix, it displays a list of dired buffers, a list of
directories of live file buffers, and a list of directory
bookmarks.
With a single universal prefix, it displays a list of known Git
repositories.
With two universal prefixes, it displays a list of remote
connection identities of recent files."
(interactive)
(pcase current-prefix-arg
('(4)
(require 'my/helm/source/remote)
(helm :prompt "Remote: "
:sources
'(akirak/helm-source-remote-bookmark
akirak/helm-source-recent-remotes)))
('()
(require 'my/helm/source/dir)
(helm :prompt "Directory/repository: "
:sources
(list (akirak/helm-dired-buffer-source)
akirak/helm-directory-bookmark-source
akirak/helm-open-file-buffer-directories-source
akirak/helm-project-parent-directory-source)))
(_ (user-error "Not matching %s" current-prefix-arg))))
"C-x g"
(defun akirak/browse-git-repository ()
(interactive)
(require 'my/helm/source/dir)
(helm :prompt "Directory/repository: "
:sources
(list akirak/helm-directory-bookmark-as-git-source
akirak/helm-magit-list-repos-source
akirak/helm-toplevel-repos-submodules-source
akirak/helm-remote-repo-dummy-source
akirak/helm-github-following-source)))
"C-x j"
(defun akirak/switch-to-org-buffer ()
(interactive)
(require 'helm-org-ql)
;; (require 'org-recent-headings)
;; (require 'helm-org-recent-headings)
(helm :prompt "Switch to Org: "
:sources
(-non-nil
(list (akirak/helm-indirect-org-buffer-source)
(unless (org-clocking-p)
'akirak/helm-org-planning-items-source)
(helm-org-multi-wiki-recent-entry-source)
(helm-org-multi-wiki-recent-file-source)
akirak/helm-source-bookmark-org))))
"C-x x"
(defun akirak/switch-to-x-buffer (&optional arg)
(interactive "P")
(cond
((akirak/exwm-session-p)
(helm :prompt "Switch to EXWM buffer: "
:sources (akirak/helm-exwm-buffer-source)))
((akirak/windows-subsystem-for-linux-p)
(user-error "Not supported on WSL"))
((eq system-type 'gnu/linux)
;; TODO: Implement it
(cl-assert (executable-find "wmctrl"))
(helm :prompt "X window: "
:sources
(helm-build-sync-source "X windows"
:candidates (-map (lambda (s)
(save-match-data
(when (string-match (rx bol (group (+ (not (any space))))
(+ space)
(group (+ (+ digit)))
(+ space)
(+ (not (any space)))
(+ space)
(group (+ anything)))
s)
(cons (format "%s: %s" (match-string 2 s)
(match-string 3 s))
(match-string 1 s)))))
(process-lines "wmctrl" "-l"))
:action (lambda (wid)
(call-process "wmctrl" nil nil nil "-i" "-a" wid)))))))
"C-x '"
(defun akirak/switch-to-reference-buffer-or-browser ()
(interactive)
(require 'my/helm/source/web)
(helm :prompt "Switch to a reference buffer: "
:default (list (thing-at-point 'symbol)
(buffer-name helm-current-buffer))
:sources (append (list (akirak/helm-reference-buffer-source))
(list helm-source-bookmark-info
helm-source-bookmark-man)
(list (helm-def-source--info-files))
(akirak/helm-web-sources))))
"<f6> <f6>"
(defun akirak/switch-to-recent-file-buffer ()
(interactive)
(if-let (buf (->> (buffer-list)
(-filter (lambda (buf)
(and (buffer-file-name buf)
(not (get-buffer-window buf)))))
(-map (lambda (buf)
(cons buf
(buffer-local-value 'buffer-display-time buf))))
(-filter #'cdr)
(-sort (-on (-compose #'not #'time-less-p) #'cdr))
(car)
(car)))
(if current-prefix-arg
(pop-to-buffer buf)
(switch-to-buffer buf))
(user-error "No recent buffer"))))In the list of project buffers, you can switch to a file list with
M-/.
(general-def
:keymaps 'akirak/helm-project-buffer-map
:package 'my/helm/source/complex
"M-/" (lambda ()
(interactive)
(helm-run-after-quit
(lambda ()
(akirak/find-file-recursively default-directory)))))I haven’t bound any key to this command yet.
(defun akirak/switch-to-scratch-buffer ()
(interactive)
(helm :prompt "Switch to a scratch/REPL buffer: "
:sources
(akirak/helm-scratch-buffer-source)))Browsing contents in specific buffers without leaving the context
(general-def
;; This command lets you browse lines in error buffers.
"C-x t" #'helm-tail)Navigation in buffer
Avy
avy-goto-word-1 was recommended in https://irreal.org/blog/?p=9130, but avy-goto-char-2 looks better on cognitive load.
(general-def
"C-'" #'avy-goto-char-2)
(defun akirak/avy-pre-action-function (operand operation res)
(let ((start (caar res))
(window (cdr res)))
(with-current-buffer (window-buffer window)
(save-excursion
(goto-char start)
(cl-ecase operand
(symbol (let ((begin (if (looking-at (rx symbol-start))
(point)
(re-search-backward (rx symbol-start) nil t)))
(end (save-excursion
(re-search-forward
(rx (group (+? anything)) symbol-end)
nil t))))
(funcall operation begin end))))))))
(cl-defmacro akirak/def-avy-edit-command (name
operand operation
&rest post-action)
(declare (indent 1))
`(defun ,(intern (concat "akirak/avy-" name)) ()
(interactive)
(let ((avy-all-windows t)
(avy-pre-action (-partial #'akirak/avy-pre-action-function
,operand
,operation)))
(save-excursion
(save-window-excursion
(call-interactively #'avy-goto-char-timer)))
,@post-action)))Jump straight to the destination and do a thing
(general-def :prefix "C-;"
"s" `(,(akirak/def-avy-edit-command "mirror-symbol"
'symbol #'copy-region-as-kill)
:wk "mirror symbol"))Page navigation
I will use C-x [ and C-x ] for “page” navigation. These keys
are bound to backward-page and forward-page by default, but
they should be rebound depending on the major mode, since the
notion of page/chunk varies.
(general-def
;; Default
"C-x [" #'backward-page
"C-x ]" #'forward-page)
(general-def :keymaps 'org-mode-map :package 'org
;; [remap backward-page]
[remap forward-page]
(defun akirak/org-narrow-to-next-sibling-subtree ()
(interactive)
(if (buffer-narrowed-p)
(let ((old-level (save-excursion
(goto-char (point-min))
(org-outline-level)))
(end (point-max)))
(goto-char (point-max))
(widen)
(if (re-search-forward org-heading-regexp nil t)
(let ((new-level (org-outline-level)))
(org-narrow-to-subtree)
(org-back-to-heading)
(org-show-subtree)
(cond
((= new-level old-level)
(message "Narrowing to the next sibling"))
((> new-level old-level)
(message "Narrowing to a child"))
((< new-level old-level)
(message "Narrowing to an upper level"))))
(message "No more heading")))
(message "Buffer is not narrowed"))))
(general-def :keymaps 'org-journal-mode-map :package 'org-journal
[remap forward-page] #'org-journal-next-entry
[remap backward-page] #'org-journal-previous-entry)
(general-def :keymaps 'Info-mode-map :package 'info
"h" #'Info-up
[remap forward-page] #'Info-next-preorder
[remap backward-page] #'Info-prev)Help and documentation
Use <f1> as the prefix for help commands
(general-def
[help ?.] #'helpful-at-point)
(general-def :package 'lsp-mode :keymaps 'lsp-mode-map
[help ?.] #'lsp-describe-thing-at-point)
(akirak/bind-help
"M" #'discover-my-major
"xc" #'describe-char
"xf" #'counsel-faces)e.g. M-` M-m -> <f1> ESC m
(akirak/bind-help
"ESC m" #'woman
"ESC i" #'helm-info
"ESC d" #'helm-dash)Dash Docs
(akirak/bind-user
"d" '(nil :wk "doc")
"da" #'dash-docs-activate-docset
"dh" #'helm-dash
"di" #'dash-docs-async-install-docset)Editing
Undo and redo
You still can use the built-in undo command with C-x u
(use-package undo-fu
:general
("C-/" #'undo-fu-only-undo
"C-?" #'undo-fu-only-redo))Editing source code comments in org-mode using outorg
Bind ~C-c ‘~ to outorg, which is the same keybinding as org-edit-special.
(use-package outorg
:commands (outorg-edit-as-org)
:config/el-patch
(el-patch-defun outorg-convert-oldschool-elisp-buffer-to-outshine ()
"Transform oldschool elisp buffer to outshine.
In `emacs-lisp-mode', transform an oldschool buffer (only
semicolons as outline-regexp) into an outshine buffer (with
outcommented org-mode headers)."
(save-excursion
(goto-char (point-min))
(when (outline-on-heading-p)
(outorg-convert-oldschool-elisp-headline-to-outshine))
(while (not (eobp))
(outline-next-heading)
(outorg-convert-oldschool-elisp-headline-to-outshine)))
(el-patch-remove (funcall 'outshine-hook-function))))
(general-def :keymaps 'emacs-lisp-mode-map
"C-c '" #'outorg-edit-as-org)
(general-def :keymaps 'outorg-edit-minor-mode-map :package 'outorg
"C-c '" #'outorg-copy-edits-and-exit)Source navigation
Bind M-s M-s
(akirak/bind-search
"M-s" #'xref-find-apropos)Running external commands
(general-def
"C-x c"
(defun akirak/project-compile ()
(interactive)
(pcase current-prefix-arg
('(64)
(message "Set compilation-auto-jump-to-first-error to %s"
(setq-default compilation-auto-jump-to-first-error
(not compilation-auto-jump-to-first-error))))
;; If two prefixes are given, select the compilation buffer window.
('(16)
(if-let (buffer (or (get-buffer "*compilation*")
(-find (lambda (buf)
(buffer-local-value 'compilation-minor-mode buf))
(buffer-list))))
(if-let (window (get-buffer-window buffer))
(select-window window)
(pop-to-buffer buffer))
(user-error "No compilation buffer")))
('(4)
(akirak/project-find-package-file))
(_
(akirak/project-call-build-command))))
"C-x C"
(defun akirak/helm-shell-command (&optional root)
(interactive)
(require 'my/helm/source/org)
(require 'my/helm/action/org-marker)
(let ((root (or root
(akirak/project-root default-directory)
default-directory)))
(setq akirak/programming-recipe-mode-name "sh"
akirak/helm-org-ql-buffers-files (org-multi-wiki-entry-files 'refs :as-buffers t))
(helm :prompt (format "Execute command (project root: %s): " root)
:sources
(list (helm-make-source "Command" 'akirak/helm-source-org-ql-src-block
:action akirak/helm-org-marker-sh-block-action-list)
(helm-build-dummy-source "Command"
:action
`(("compile"
. (lambda (command)
(akirak/compile command :directory ,root)))
("eshell"
. (lambda (command)
(let ((default-directory ,root))
(eshell-command command)))))))))))Maintenance and development of the config
These commands are used to maintain this Emacs configuration.
(akirak/bind-customization
"" '(nil :wk "customize")
"f" #'customize-face-other-window
"o" #'customize-group-other-window
"l" #'counsel-find-library
"p" '((lambda () (interactive)
(if (featurep 'straight)
(call-interactively 'straight-use-package)
(package-list-packages)))
:wk "packages")
"s" #'customize-set-value
"v" #'customize-variable-other-window)
(general-def
"C-x M-m"
(defun akirak/helm-my-library ()
"Browse the library for this configuration."
(interactive)
(require 'my/helm/source/file)
(let ((default-directory (f-join user-emacs-directory "lisp")))
(helm :prompt (format "Files in %s: " default-directory)
:sources (list (helm-make-source "Files in project"
'akirak/helm-source-project-file)
(helm-build-dummy-source "New file in lisp directory"
:action #'find-file))))))Per-project
(cl-defmacro akirak/run-at-project-root (command &key other-window)
`(defun ,(intern (concat "akirak/project-" (symbol-name command))) ()
(interactive)
(let ((root (akirak/project-root default-directory)))
(when ,other-window
(or (other-window 1)
(split-window-sensibly)))
(let ((default-directory root))
(call-interactively (quote ,command))))))
(cl-defmacro akirak/run-at-vc-root (command &key other-window)
`(defun ,(intern (concat "akirak/vc-root-" (symbol-name command))) ()
(interactive)
(when ,other-window
(or (other-window 1)
(split-window-sensibly)))
(let ((default-directory (vc-root-dir)))
(call-interactively (quote ,command)))))
(cl-defmacro akirak/run-shell-command-silently-at-vc-root (name command)
`(defun ,name ()
(interactive)
(let ((default-directory (or (vc-root-dir)
(magit-toplevel))))
(shell-command ,command))))
(cl-defmacro akirak/make-vc-root-file-command (filename &key regexp name)
`(defun ,(intern (format "akirak/open-%s-at-root" (or name (s-replace "." "-" filename)))) ()
(interactive)
(let* ((default-directory (vc-root-dir))
(file (pcase (if ,regexp
(directory-files default-directory nil ,filename t)
(when (file-exists-p ,filename)
(list ,filename)))
(`(,file) file)
('() (if (and (not regexp)
(yes-or-no-p (format "%s does not exist. Create it?" ,filename)))
filename
(user-error "Aborted")))
(files (completing-read "File: " files)))))
(find-file file))))
(akirak/bind-f8
;; Project.el commands
;; Based on `project-prefix-map' in project.el 0.5.3
"!" #'project-shell-command
"&" #'project-async-shell-command
"f" #'project-find-file
;; "F" #'project-or-external-find-file
"b" #'project-switch-to-buffer
"s" #'project-shell
"d" #'project-dired
;; "v" #'project-vc-dir
"c" (defun akirak/project-or-vc-compile (&optional arg)
(interactive "P")
(if arg
(counsel-compile (vc-root-dir))
(project-compile)))
;; "e" #'project-eshell
;; "k" #'project-kill-buffers
;; "p" #'project-switch-project
;; "g" #'project-find-regexp
;; "G" #'project-or-external-find-regexp
;; "r" #'project-query-replace-regexp
;; Custom project commands
"g" #'deadgrep
"t" (akirak/run-at-project-root vterm :other-window t)
;; Commands run at a vc root
"A" (defun akirak/treemacs-add-vc-root-to-workspace ()
(interactive)
(treemacs-add-project-to-workspace (vc-root-dir)))
"D" (akirak/run-at-vc-root add-dir-local-variable)
"n" '(:wk "nix")
"nd" (akirak/make-vc-root-file-command "default.nix")
"ne" (akirak/run-shell-command-silently-at-vc-root
akirak/project-nix-shell-exit "nix-shell --run exit")
"nf" (akirak/make-vc-root-file-command "flake.nix")
"nr" (akirak/run-at-vc-root nix-repl :other-window t)
"ns" (akirak/make-vc-root-file-command "shell.nix")
"r" (akirak/make-vc-root-file-command "^README\\..+\\'" :regexp t :name "readme")
;; Unused commands
;; "c" (akirak/run-at-project-root compile)
;; "d" #'project-dired
;; "e" (akirak/run-at-project-root ielm :other-window t)
)f12: Administration and external tool integration
Capture
(akirak/bind-admin
;; WIP: Use transient to organize these entry points
"c" '(nil :wk "capture")
"ce"
;; Based on https://www.reddit.com/r/emacs/comments/idz35e/emacs_27_can_take_svg_screenshots_of_itself/
(defun screenshot-svg ()
"Save a screenshot of the current frame as an SVG image.
Saves to a temp file and puts the filename in the kill ring."
(interactive)
(let* ((filename (make-temp-file "Emacs" nil ".svg"))
(data (x-export-frames nil 'svg)))
(with-temp-file filename
(insert data))
(kill-new filename)
(message filename)))
"cE" #'akirak/gif-screencast
"cx" #'org-download-screenshot)Directory/disk
(akirak/bind-admin
"d" '(nil :wk "dir")
"de" #'direnv-allow
"du" #'disk-usage
"dh" #'helm-linux-disks)Emacs
(akirak/bind-admin
)Git
(akirak/bind-admin
"g" '(nil :wk "git")
"gb" #'akirak/git-bookmark-repository
"gc" #'akirak/git-clone-remote-repo
"gl" #'magit-list-repositories
"go" #'akirak/github-owned-repos
"gr" #'commonplace-repos-counsel-rg
"gs" #'akirak/github-starred-repos
"gt" #'akirak/git-module-add-tags
"gu" #'akirak/github-users)Docker
(akirak/bind-admin
"k" '(nil :wk "docker")
"ki" #'docker-images
"kk" #'docker-containers
"kn" #'docker-networks
"kv" #'docker-volumes)Nix
(akirak/bind-admin
"n" '(nil :wk "nix")
"nf" #'akirak/nix-prefetch-url)Misc query commands
(akirak/bind-admin
"q" '(nil :wk "query")
"qc" #'calc)Remote connections (TRAMP)
(akirak/bind-admin
"r" '(nil :wk "remote")
"rk" #'helm-delete-tramp-connection)
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent