*** xcape
Make short press on left control behave as Escape (=<>=):
#+name: home-manager-section
#+begin_src nix
{
services.xcape = {
enable = pkgs.stdenv.isLinux;
mapExpression = {
Control_L = "Escape";
};
};
}
#+end_src
*** Emacs quail
Emacs has built-in capability to change keyboard layout (for insert state only), which is triggered by =C-\=. In order to work properly, Emacs needs to know my keyboard layout.
#+begin_src emacs-lisp
(use-package quail
:ensure nil ; built-in
:config
(add-to-list 'quail-keyboard-layout-alist
'("workman" . "\
\
1!2@3#4$5%6^7&8*9(0)-_=+`~ \
qQdDrRwWbBjJfFuUpP;:[{]}\\| \
aAsShHtTgGyYnNeEoOiI'\" \
zZxXmMcCvVkKlL,<.>/? \
"))
(quail-set-keyboard-layout "workman"))
#+end_src

* Network
** NetworkManager
(~<>~)
#+name: nixos-section
#+begin_src nix
{
networking = {
hostName = name;

networkmanager = {
enable = true;
wifi.powersave = false;
};

# disable wpa_supplicant
wireless.enable = false;
};

users.extraUsers.rasen.extraGroups = [ "networkmanager" ];
}
#+end_src

Install network manager applet for user. (~<>~)
#+name: home-manager-section
#+begin_src nix
{
home.packages = pkgs.lib.linux-only [ pkgs.networkmanagerapplet ];
}
#+end_src

Auto-start ~nm-applet~ (emacs-lisp)
#+begin_src emacs-lisp
(rasen/autostart "nm-applet")
#+end_src
** SSH
(~<>~)
#+name: nixos-section
#+begin_src nix
{
services.openssh = {
enable = true;
passwordAuthentication = false;
};
}
#+end_src
*** Mosh
[[https://mosh.mit.edu/][Mosh (mobile shell)]] is a cool addition to ssh.
#+name: nixos-section
#+begin_src nix
{
programs.mosh.enable = true;
}
#+end_src
** dnsmasq
Use [[http://www.thekelleys.org.uk/dnsmasq/doc.html][dnsmasq]] as a DNS cache.

(~<>~)
#+name: nixos-section
#+begin_src nix
{
services.dnsmasq = {
enable = true;

# These are used in addition to resolv.conf
servers = [
"8.8.8.8"
"8.8.4.4"
];

extraConfig = ''
interface=lo
bind-interfaces
listen-address=127.0.0.1
cache-size=1000

no-negcache
'';
};
}
#+end_src
** Firewall
Enable firewall. This blocks all ports for ingress traffic and pings.

(~<>~)
#+name: nixos-section
#+begin_src nix
{
networking.firewall = {
enable = true;
allowPing = false;

connectionTrackingModules = [];
autoLoadConntrackHelpers = false;
};
}
#+end_src
* Services
** Locate
Update [[https://linux.die.net/man/1/locate][locate]] database daily.
#+name: nixos-section
#+begin_src nix
{
services.locate = {
enable = true;
localuser = "rasen";
};
}
#+end_src
** Gitolite
#+name: nixos-section
#+begin_src nix
{
services.gitolite = {
enable = true;
user = "git";
adminPubkey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHH15uiQw3jBbrdlcRb8wOr8KVltuwbHP/JOFAzXFO1l/4QxnKs6Nno939ugULM7Lu0Vx5g6FreuCOa2NMWk5rcjIwOzjrZnHZ7aoAVnE7H9scuz8NGnrWdc1Oq0hmcDxdZrdKdB6CPG/diGWNZy77nLvz5JcX1kPLZENPeApCERwR5SvLecA4Es5JORHz9ssEcf8I7VFpAebfQYDu+VZZvEu03P2+5SXv8+5zjiuxM7qxzqRmv0U8eftii9xgVNC7FaoRBhhM7yKkpbnqX7IeSU3WeVcw4+d1d8b9wD/sFOyGc1xAcvafLaGdgeCQGU729DupRRJokpw6bBRQGH29 rasen@omicron";
};
}
#+end_src
** Syncthing
I use Syncthing to sync my org-mode files to my phone.

#+name: nixos-section
#+begin_src nix
{
services.syncthing = {
enable = true;
user = "rasen";
dataDir = "/home/rasen/.config/syncthing";
configDir = "/home/rasen/.config/syncthing";
openDefaultPorts = true;
};
}
#+end_src

On Darwin:
#+name: darwin-section
#+begin_src nix
{
environment.systemPackages = [ pkgs.syncthing ];
}
#+end_src
** Backup
I use borg for backups.

#+name: machine-omicron
#+begin_src nix
(let
commonOptions = {
# repo = "borg@10.13.0.3:.";
repo = "/run/media/ext-data/borg";
removableDevice = true;

encryption.mode = "keyfile-blake2";
encryption.passCommand = "cat /root/secrets/borg";
compression = "auto,lzma,9";
doInit = false;
environment = { BORG_RSH = "ssh -i /root/.ssh/borg"; };
# UTC timestamp
dateFormat = "-u +%Y-%m-%dT%H:%M:%S";

prune.keep = {
daily = 7;
weekly = 4;
monthly = 12;
yearly = -1;
};
};
in {
services.borgbackup.jobs."all" = commonOptions // {
archiveBaseName = "${config.networking.hostName}";
paths = [
"/var/lib/gitolite/"
"/home/rasen/backup/"
"/home/rasen/.ssh/"
"/home/rasen/.gnupg/"
"/home/rasen/.password-store/"
"/home/rasen/dotfiles/"
"/home/rasen/org/"
"/home/rasen/syncthing/"

# Mail
"/home/rasen/Mail/"
"/home/rasen/.mbsync/"
];
exclude = [
# Scanning notmuch takes too much time and doesn't make much
# sense as it is easily replicable
"/home/rasen/Mail/.notmuch"
];
};

# Start backup on boot if missed one while laptop was off
systemd.timers.borgbackup-job-all.timerConfig = {
Persistent = lib.mkForce true;
};
})
#+end_src

Mount external drive when needed.
#+name: nixos-section
#+begin_src nix
{
# Prepare mount point
system.activationScripts = {
ensure-ext-data = {
text = ''
mkdir -p /run/media/ext-data
'';
deps = [];
};
};

fileSystems."/run/media/ext-data" = {
device = "/dev/disk/by-uuid/63972645-dbc8-4543-b854-91038b2da6cb";
fsType = "ext4";
options = [
"noauto" # do not mount on boot
"nofail"
"x-systemd.automount" # mount when needed
"x-systemd.device-timeout=1ms" # device should be plugged already—do not wait for it
"x-systemd.idle-timout=5m" # unmount after 5 min of inactivity
];
};
}
#+end_src
** direnv
*** direnv + lorri
direnv allows having per-directory environment configuration. You can think of automatic virtualenv, but it's more general and supports unloading.

(~<>~)
#+name: home-manager-section
#+begin_src nix
{
programs.direnv.enable = true;
programs.direnv.nix-direnv.enable = true;
services.lorri.enable = pkgs.stdenv.isLinux;
}
#+end_src

# Enable Emacs integration. (emacs-lisp)
# #+begin_src emacs-lisp
# (use-package direnv
# :after exec-path-from-shell
# :config
# (direnv-mode))
# #+end_src

Better (?) direnv integration via [[https://github.com/purcell/envrc][purcell/envrc]]. (emacs-lisp)
#+begin_src emacs-lisp
(use-package envrc
:after exec-path-from-shell
:hook (after-init . envrc-global-mode))
#+end_src
** VirtualBox
#+name: nixos-section
#+begin_src nix
{
virtualisation.virtualbox.host.enable = true;
users.extraGroups.vboxusers.members = ["rasen"];
}
#+end_src
* Hardware
** Do not suspend on AC
#+name: nixos-section
#+begin_src nix
{
services.logind = {
lidSwitchDocked = "ignore";
lidSwitchExternalPower = "ignore";
};
}
#+end_src
** Autorandr
Configure EXWM to use autorandr. (emacs-lisp)
#+begin_src emacs-lisp
(use-package exwm-randr
:after exwm
:config
(setq exwm-workspace-number 2)
(setq exwm-randr-workspace-output-plist '(0 "eDP-1"
1 "DP-1"
1 "DP-3"))

(add-hook 'exwm-randr-screen-change-hook
(defun rasen/autorandr ()
(interactive)
(rasen/start-command "autorandr -c" "*autorandr*")))

(exwm-randr-mode))
#+end_src

(~<>~)
#+name: home-manager-section
#+begin_src nix
{
programs.autorandr = {
enable = true;
profiles =
let
omicron = "00ffffffffffff004d104a14000000001e190104a51d11780ede50a3544c99260f505400000001010101010101010101010101010101cd9180a0c00834703020350026a510000018a47480a0c00834703020350026a510000018000000fe0052584e3439814c513133335a31000000000002410328001200000b010a202000cc";
work = "00ffffffffffff004d108d1400000000051c0104a52213780ea0f9a95335bd240c5157000000010101010101010101010101010101014dd000a0f0703e803020350058c210000018000000000000000000000000000000000000000000fe00464e564452804c513135364431000000000002410328011200000b010a202000ee";
home-monitor = "00ffffffffffff0010acc0a042524530031c010380351e78eae245a8554da3260b5054a54b00714f8180a9c0a940d1c0e10001010101a36600a0f0701f80302035000f282100001a000000ff004438565846383148304552420a000000fc0044454c4c205032343135510a20000000fd001d4c1e8c1e000a202020202020018802032ef15390050402071601141f1213272021220306111523091f07830100006d030c001000003c200060030201023a801871382d40582c25000f282100001e011d8018711c1620582c25000f282100009e04740030f2705a80b0588a000f282100001e565e00a0a0a02950302035000f282100001a0000000000000000008a";
home-monitor-2 = "00ffffffffffff004c2d767135305943341f0103804024782a6115ad5045a4260e5054bfef80714f810081c081809500a9c0b300010108e80030f2705a80b0588a0078682100001e000000fd0030901eff8f000a202020202020000000fc004c53323841473730304e0a2020000000ff0048345a524330303236380a2020017f02034bf14761103f04035f762309070783010000e305c0006b030c001000b83c200020016dd85dc401788053003090c354056d1a0000020f3090000461045a04e6060501615a00e30f4100565e00a0a0a029503020350078682100001a6fc200a0a0a055503020350078682100001a0000000000000000000000000000000037";
work-monitor = "00ffffffffffff0010acc2d0545741312c1b010380351e78eaad75a9544d9d260f5054a54b008100b300d100714fa9408180d1c00101565e00a0a0a02950302035000e282100001a000000ff004d59334e44374234314157540a000000fc0044454c4c205032343138440a20000000fd0031561d711c000a202020202020010302031bb15090050403020716010611121513141f2065030c001000023a801871382d40582c45000e282100001e011d8018711c1620582c25000e282100009ebf1600a08038134030203a000e282100001a7e3900a080381f4030203a000e282100001a00000000000000000000000000000000000000000000000000000000d8";
in {
"omicron" = {
fingerprint = {
eDP-1 = omicron;
};
config = {
eDP-1 = {
enable = true;
primary = true;
position = "0x0";
mode = "3200x1800";
rate = "60.00";
};
};
};
"omicron-home" = {
fingerprint = {
eDP-1 = omicron;
DP-1 = home-monitor;
};
config = {
eDP-1.enable = false;
DP-1 = {
enable = true;
primary = true;
position = "0x0";
mode = "3840x2160";
rate = "60.00";
};
};
};
"omicron-home-2" = {
fingerprint = {
eDP-1 = omicron;
DP-1 = home-monitor-2;
};
config = {
eDP-1.enable = false;
DP-1 = {
enable = true;
primary = true;
position = "0x0";
mode = "3840x2160";
rate = "60.00";
};
};
};
"omicron-home-monitor" = {
fingerprint = {
DP-1 = home-monitor;
};
config = {
DP-1 = {
enable = true;
primary = true;
position = "0x0";
mode = "3840x2160";
rate = "60.00";
};
};
};
omicron-home-monitor-2 = {
fingerprint = {
DP-1 = home-monitor-2;
};
config = {
DP-1 = {
enable = true;
primary = true;
position = "0x0";
mode = "3840x2160";
rate = "60.00";
};
};
};
};
};
}
#+end_src
** Screen brightness
=xbacklight= stopped working recently. =acpilight= is a drop-in replacement.
#+name: nixos-section
#+begin_src nix
{
hardware.acpilight.enable = true;
environment.systemPackages = [ pkgs.acpilight ];
users.extraUsers.rasen.extraGroups = [ "video" ];
}
#+end_src

For Home Manager–managed hosts.
#+name: home-manager-section
#+begin_src nix
{
home.packages = pkgs.lib.linux-only [ pkgs.acpilight ];
}
#+end_src

Bind it to keys (emacs-lisp).
#+begin_src emacs-lisp
(rasen/exwm-input-set-key (kbd "")
(lambda () (interactive) (rasen/start-command "xbacklight -inc 10")))
(rasen/exwm-input-set-key (kbd "")
(lambda () (interactive) (rasen/start-command "xbacklight -dec 10")))
#+end_src
** Redshift
Redshift adjusts the color temperature of the screen according to the position of the sun.

Blue light blocks [[https://en.wikipedia.org/wiki/Melatonin][melatonin]] (sleep harmone) secretion, so you feel less sleepy when you stare at computer screen.
Redshift blocks some blue light (making screen more red), which should improve melatonin secretion and restore sleepiness (which is a good thing).

#+name: nixos-section
#+begin_src nix
{
services.redshift = {
enable = true;
};
location.provider = "geoclue2";
}
#+end_src
** PipeWire
Use PipeWire as audio server.
#+name: nixos-section
#+begin_src nix
{
# PipeWire requires pulseaudio to be disabled.
hardware.pulseaudio.enable = false;

security.rtkit.enable = true;
services.pipewire = {
enable = true;
alsa.enable = true;
alsa.support32Bit = true;
pulse.enable = true;

media-session.config.bluez-monitor.rules = [
{
# Matches all cards
matches = [ { "device.name" = "~bluez_card.*"; } ];
actions = {
"update-props" = {
"bluez5.reconnect-profiles" = [ "hfp_hf" "hsp_hs" "a2dp_sink" ];
# mSBC is not expected to work on all headset + adapter combinations.
"bluez5.msbc-support" = true;
# SBC-XQ is not expected to work on all headset + adapter combinations.
"bluez5.sbc-xq-support" = true;
};
};
}
{
matches = [
# Matches all sources
{ "node.name" = "~bluez_input.*"; }
# Matches all outputs
{ "node.name" = "~bluez_output.*"; }
];
actions = {
"node.pause-on-idle" = false;
};
}
];
};
}
#+end_src

=pavucontrol= is PulseAudio Volume Control—a nice utility for controlling pulseaudio settings. (~<>~)
#+name: home-manager-section
#+begin_src nix
{
home.packages = pkgs.lib.linux-only [ pkgs.pavucontrol ];
}
#+end_src

#+begin_src emacs-lisp
(defun rasen/pavucontrol ()
(interactive)
(rasen/switch-start "Pavucontrol" "pavucontrol"))
#+end_src

Bind volume control commands. (emacs-lisp)
#+begin_src emacs-lisp
(rasen/exwm-input-set-key (kbd "")
(lambda () (interactive) (rasen/start-command "amixer set Master toggle")))
(rasen/exwm-input-set-key (kbd "")
(lambda () (interactive) (rasen/start-command "amixer set Master 2%+")))
(rasen/exwm-input-set-key (kbd "")
(lambda () (interactive) (rasen/start-command "amixer set Master 2%-")))
#+end_src
** Bluetooth
I have a bluetooth headset, so this enables bluetooth audio in NixOS.

(~<>~)
#+name: nixos-section
#+begin_src nix
{
hardware.bluetooth.enable = true;
}
#+end_src
** ADB
I need to access my Android device. (~<>~)
#+name: nixos-section
#+begin_src nix
{
services.udev.packages = [ pkgs.android-udev-rules ];
programs.adb.enable = true;
users.users.rasen.extraGroups = ["adbusers"];
}
#+end_src
** fwupd
fwupd is a service that allows applications to update firmware. (~<>~)
#+name: nixos-section
#+begin_src nix
{
services.fwupd.enable = true;
}
#+end_src

Execute the following command to update firmware.
#+begin_src sh :tangle no
fwupdmgr get-updates
#+end_src
* Browsers
Firefox is default, Chrome for backup.
#+name: home-manager-section
#+begin_src nix
{
home.packages = pkgs.lib.linux-only [
pkgs.firefox
pkgs.google-chrome
];
}
#+end_src
** Tridactyl
Tridactyl is a Firefox plugin that provides Vim-like bindings.

Here is my config. (~<>~)
#+name: tridactylrc
#+begin_src fundamental :tangle no
" drop all existing configuration
sanitize tridactyllocal tridactylsync

bind J scrollline -10
bind K scrollline 10
bind j scrollline -2
bind k scrollline 2
#+end_src

Link tridactyl config to the place the tridactyl can find it. (~<>~)
#+name: home-manager-section
#+begin_src nix
{
xdg.configFile."tridactyl/tridactylrc".text = ''
<>
'';
}
#+end_src
** Edit text in browser
I use [[https://github.com/GhostText/GhostText][GhostText]] firefox extension.

~atomic-chrome~ Emacs extension is compatible with it. (emacs-lisp)
#+begin_src emacs-lisp
(use-package atomic-chrome
:config
(setq atomic-chrome-default-major-mode 'markdown-mode)
(setq atomic-chrome-buffer-open-style 'frame)
(atomic-chrome-start-server))
#+end_src
* Evil-mode
** General
#+begin_src emacs-lisp
(use-package evil
:disabled t
:custom
(evil-undo-system 'undo-redo)
:config
<>
(evil-mode 1))
#+end_src

Swap =.= and =;=.
#+name: evil-config
#+begin_src emacs-lisp :tangle no
(general-def 'normal
";" #'evil-repeat
"." nil
"C-;" #'evil-repeat-pop
"C-." nil)

(general-def 'motion
"." #'evil-repeat-find-char
";" nil
"g." #'goto-last-change
"g;" nil)
#+end_src

#+name: evil-config
#+begin_src emacs-lisp :tangle no
(s-leader-def
";" #'eval-expression)
#+end_src

Close other window.
#+begin_src emacs-lisp
(defun rasen/quit-other ()
(interactive)
(other-window 1)
(quit-window))

(s-leader-def
"q" #'rasen/quit-other)
#+end_src

Move to beginning/end of line with =H= and =L= respectively.
#+name: evil-config
#+begin_src emacs-lisp :tangle no
(defun rasen/smart-move-beginning-of-line (arg)
"Move point back to indentation of beginning of line.

Move point to the first non-whitespace character on this line.
If point is already there, move to the beginning of the line.
Effectively toggle between the first non-whitespace character and
the beginning of the line.

If ARG is not nil or 1, move forward ARG - 1 lines first. If
point reaches the beginning or end of the buffer, stop there."
(interactive "^p")
(setq arg (or arg 1))

;; Move lines first
(when (/= arg 1)
(let ((line-move-visual nil))
(forward-line (1- arg))))

(let ((orig-point (point)))
(back-to-indentation)
(when (= orig-point (point))
(move-beginning-of-line 1))))

(general-def 'motion
"H" #'rasen/smart-move-beginning-of-line
"L" #'evil-end-of-line)
#+end_src

Save buffer with =SPC SPC=.
#+begin_src emacs-lisp
(defun rasen/save-buffer (arg)
"Save current buffer. With PREFIX, save all buffers."
(interactive "P")
(if arg
(save-some-buffers)
(save-buffer)))

(with-eval-after-load "evil"
(s-leader-def 'normal
"SPC" #'rasen/save-buffer)
(s-leader-def
"s-SPC" #'save-some-buffers))
#+end_src
** Swap k and j
With workman layout, =j= is located on qwerty =y= and =k=---on qwerty =n=; thus =j= is higher than =k=, and it is not convenient to press lower key for going up. Just swap them.
#+name: evil-config
#+begin_src emacs-lisp :tangle no
(general-def 'motion
"k" #'evil-next-visual-line
"j" #'evil-previous-visual-line
"gk" #'evil-next-line
"gj" #'evil-previous-line)

(general-def 'operator
"k" #'evil-next-line
"j" #'evil-previous-line
"gk" #'evil-next-visual-line
"gj" #'evil-previous-visual-line)

(general-def 'motion
"C-h" #'windmove-left
"C-k" #'windmove-down
"C-j" #'windmove-up
"C-l" #'windmove-right)

(general-swap-key nil 'motion
"C-w j" "C-w k")
#+end_src
** evil-numbers
I use Vim's =C-a= and =C-x= (increment/decrement number at point) a lot.
=evil-numbers= provides that functionality for evil.
#+begin_src emacs-lisp
(use-package evil-numbers
:after evil
:general
('normal
"C-a" #'evil-numbers/inc-at-pt
"C-x" #'evil-numbers/dec-at-pt))
#+end_src

Now, remap =C-x= to =RET=. (Because =C-x= is used for decrementing numbers.)
#+name: evil-config
#+begin_src emacs-lisp
(general-def 'motion
"RET" (lookup-key (current-global-map) (kbd "C-x")))
;; Unmap it from magit
(general-def magit-file-mode-map
"C-x" nil)
#+end_src
** evil-collection
evil-collection is a collection of evil bindings for different modes.

These variables need to be set before evil loads (which seems to be required by =general=) or shortly after. So the following needs to be placed before general:
#+name: before-general
#+begin_src emacs-lisp
(setq evil-want-integration t
evil-want-keybinding nil)
#+end_src

#+begin_src emacs-lisp
(require 'warnings)
(add-to-list 'warning-suppress-types '(evil-collection))

(use-package evil-collection
:disabled t
:after (evil)
:init
(setq evil-want-integration t
evil-want-keybinding nil)
:config
(defun rasen/rotate-keys (_mode mode-keymaps &rest _rest)
;; (evil-collection-translate-key 'normal mode-keymaps
;; "k" "j"
;; "j" "k"
;; "gk" "gj"
;; "gj" "gk"
;; (kbd "C-j") (kbd "C-k")
;; (kbd "C-k") (kbd "C-j")
;; (kbd "M-j") (kbd "M-k")
;; (kbd "M-k") (kbd "M-j")
;; "." ";"
;; ";" ".")
)
(add-hook 'evil-collection-setup-hook #'rasen/rotate-keys)

(setq evil-collection-mode-list
'(dired
compile
flycheck
help
js2-mode
;; notmuch bindings aren't that cool and are less efficient than native
;; keymap
;; notmuch
magit
forge
python
racer
restclient
tide
typescript-mode
vterm
which-key
xref))

(setq evil-collection-magit-use-y-for-yank t
evil-collection-magit-state 'normal)

(evil-collection-init)

;; Evilify magit-blame.
(general-def 'normal magit-blame-read-only-mode-map
"k" #'evil-next-visual-line
"j" #'evil-previous-visual-line
"C-k" #'magit-blame-next-chunk
"C-j" #'magit-blame-previous-chunk
"gk" #'magit-blame-next-chunk-same-commit
"gj" #'magit-blame-previous-chunk-same-commit)

(general-def magit-blame-read-only-mode-map "SPC" nil) ;; expose my leader

(general-def
:states `(,evil-collection-magit-state visual)
:keymaps 'magit-status-mode-map
"C-j" #'magit-section-backward-sibling
"C-k" #'magit-section-forward-sibling
"gj" #'magit-section-backward
"gk" #'magit-section-forward
"j" #'evil-previous-visual-line
"k" #'evil-next-visual-line))
#+end_src
** evil-surrond
#+begin_src emacs-lisp
(use-package evil-surround
:disabled t
:config
(global-evil-surround-mode t))
#+end_src
** calc
#+begin_src emacs-lisp
(use-package calc ; built-in
:general
(leader-def 'motion
"=" #'quick-calc
"+" #'calc)
('motion
"g =" #'quick-calc
"g +" #'calc))
#+end_src
** Evilify compile mode
#+begin_src emacs-lisp
(use-package compile ; built-in
:config
(setq compilation-scroll-output t))
#+end_src

And evil commands to go to navigate errors.
#+name: evil-config
#+begin_src emacs-lisp :tangle no
(leader-def 'motion
"," #'previous-error
"." #'next-error)
(general-def 'motion
"M-," #'previous-error
"M-." #'next-error)
#+end_src
** Evilify minibuffer
Not really "evilify."
#+begin_src emacs-lisp
(general-def 'minibuffer-local-map
;; Finish input with C-e ("e" in Workman is qwerty's "k")
"C-e" #'exit-minibuffer)
#+end_src
** Evilify shell mode
Default bindings for ~RET~ prevent many of my commands from working. Remap ~RET~ to ~C-RET~.
#+begin_src emacs-lisp
(general-def 'shell-mode-map
"RET" nil
"" #'comint-send-input)
#+end_src
** lispyville
#+begin_src emacs-lisp
(use-package lispyville
:disabled t
:hook
((clojure-mode emacs-lisp-mode lisp-mode scheme-mode) . lispyville-mode)
:config
(lispyville-set-key-theme
'(operators
c-w
;; < and >
slurp/barf-cp
(atom-movement t)
commentary
;; wrap with M-(, M-[, or M-{
wrap
additional
;; M-o open below list, M-O open above list
additional-insert))

;; override drag directions
(lispyville--define-key 'normal
(kbd "M-j") #'lispyville-drag-backward
(kbd "M-k") #'lispyville-drag-forward))
#+end_src
** scheme
#+begin_src emacs-lisp
(use-package scheme
:config
(put 'module 'scheme-indent-function 'defun))
#+end_src
* Org-mode
** General
#+begin_src emacs-lisp
(use-package org
:mode ("\\.org$" . org-mode)
:general
("C-c l" #'org-store-link)
(s-leader-def
"c" #'org-capture
"a" #'org-agenda

"o" #'org-clock-out
"l" #'org-clock-in-last
"j" #'org-clock-goto)
(leader-def 'normal 'org-mode-map
"t" #'rasen/org-todo
"s" #'org-schedule
"d" #'org-deadline
"i" #'org-clock-in

"T" #'rasen/org-do-today

"w" #'rasen/org-refile-hydra/body
"r" #'org-archive-subtree-default)
(leader-def 'motion 'org-agenda-map
"t" #'rasen/org-agenda-todo)
('normal 'org-mode-map "RET n s" #'org-narrow-to-subtree)
('(insert normal) 'org-mode-map
"C-c ," #'org-time-stamp-inactive)
('org-mode-map
;; tabs
"M-l" nil
"M-h" nil)
:gfhook 'flyspell-mode
:init
<>
:config
<>
)
#+end_src

Do not indent inside tasks
#+name: org-config
#+begin_src emacs-lisp
(setq org-adapt-indentation nil)
#+end_src

Do not indent org-babel blocks.
#+name: org-config
#+begin_src emacs-lisp
(setq org-edit-src-content-indentation 0)
#+end_src

Do not indent tags.
#+name: org-config
#+begin_src emacs-lisp
(setq org-tags-column 0)
#+end_src

When entering tags, offer tags from all agenda files. (This is the closes to global tag tracking I could find.))
#+name: org-config
#+begin_src emacs-lisp
(setq org-complete-tags-always-offer-all-agenda-tags t)
#+end_src

#+name: org-config
#+begin_src emacs-lisp
(setq org-ellipsis "…")
#+end_src

By default, show all of org file. (This can be changed on a per-file basis with ~#+STARTUP:~.)
#+name: org-config
#+begin_src emacs-lisp
(setq org-startup-folded nil)
#+end_src

Make the table header float if scrolled out of view.
#+name: org-config
#+begin_src emacs-lisp
(setq org-table-header-line-p t)
#+end_src

Hide emphasis markers (asterisks and slashes).
#+name: org-config
#+begin_src emacs-lisp
(setq org-hide-emphasis-markers t)
#+end_src

Allow emphasis marks to follow ndash/mdash, and proper quotes.
#+name: org-config
#+begin_src emacs-lisp
;; allow ndash/mdash (–, —), and proper quotes (’, “, ”) before/after
;; emphasis markers.
;;
;; (copy-modified from original `org-emphasis-regexp-components' definition)
(org-set-emph-re 'org-emphasis-regexp-components
'("-–—[:space:]('\"’“”{"
"-–—[:space:].,:!?;'\"’“”)}\\["
"[:space:]"
"."
1))
#+end_src

Open pdfs in external viewer:
#+name: org-config
#+begin_src emacs-lisp
(add-to-list 'org-file-apps
`("\\.pdf\\'" . ,(if (eq system-type 'darwin)
"open %s"
"zathura %s")))
#+end_src

Use =whitespace-mode= in Org (but don't show too long lines).
#+name: org-config
#+begin_src emacs-lisp
(add-hook 'org-mode-hook (lambda ()
(setq-local whitespace-style '(face
tab-mark
empty
trailing))
(whitespace-mode t)))
#+end_src

My directory for org files.
#+name: org-config
#+begin_src emacs-lisp
(setq rasen/org-directory "~/org")
#+end_src

My helper to find all org files in a directory.
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-files-in-dir (dir)
(f-files dir
(lambda (file) (or (f-ext? file "org")
(and (f-ext? file "gpg")
(f-ext? (f-no-ext file) "org"))))
nil))
#+end_src

Package for =f-files= and =f-ext?= functions.
#+name: org-init
#+begin_src emacs-lisp
(use-package f
:commands (f-files f-ext? f-no-ext))
#+end_src
** Todo
A special function that marks the task as done yesterday if prefix is supplied (useful for habits).
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-todo (&optional arg)
"As `org-todo' but calls `org-todo-yesterday' when ARG is non-nil."
(interactive "P")
(if arg
(org-todo-yesterday)
(org-todo)))

(defun rasen/org-agenda-todo (&optional arg)
"As `org-agenda-todo' but calls `org-agenda-todo-yesterday' when ARG is non-nil."
(interactive "P")
(if arg
(org-agenda-todo-yesterday)
(org-agenda-todo)))
#+end_src

Use the following states: =TODO= =NEXT= =DONE= =CANCELED= =WAIT=.
#+name: org-config
#+begin_src emacs-lisp
(setq-default org-todo-keywords
'((sequence "TODO(t)" "NEXT(n!)" "|" "DONE(d!)")
(sequence "BUILD(b!)" "|")
(sequence "|" "CANCELED(c!)")
(sequence "WAIT(w!)" "|")))
(setq-default org-use-fast-todo-selection t)
#+end_src

When repeated task is finished, go back to =TODO= state.
#+name: org-config
#+begin_src emacs-lisp
(setq-default org-todo-repeat-to-state "NEXT")
#+end_src

Log state changes to "LOGBOOK" drawer.
#+name: org-config
#+begin_src emacs-lisp
(setq-default org-log-into-drawer t)
#+end_src

Save =CLOSED= timestamp when task is done.
#+name: org-config
#+begin_src emacs-lisp
(setq org-log-done t)
#+end_src

Disable force-logging repeated tasks because otherwise you’ll get duplicated log lines.
#+name: org-config
#+begin_src emacs-lisp
(setq org-log-repeat nil)
#+end_src

Fontify the whole line for done tasks.
#+name: org-config
#+begin_src emacs-lisp
(setq org-fontify-done-headline t)
#+end_src

Import =org-expiry= for =org-expiry-insert-created=---this inserts =CREATED= property.
#+name: org-config
#+begin_src emacs-lisp
(require 'org-expiry)
(setq org-expiry-inactive-timestamps t)
;; The next line was required but it fails with error now. Still works
;; somehow.
;; (org-expiry-insinuate)
#+end_src

Schedule task for today and mark it NEXT.
I use this a lot during daily planning.
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-do-today (&optional arg)
"Schedule task for today and mark it NEXT.

If prefix is supplied, select different scheduled time."
(interactive "P")
(org-schedule nil (unless arg "."))
(org-todo "NEXT"))
#+end_src

A command to fold everything except =NEXT= items.
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-occur-next ()
(interactive)
(let ((org-highlight-sparse-tree-matches nil))
(org-occur (concat "^" org-outline-regexp " *" "NEXT" "\\>"))))

(general-def '(motion normal) 'org-mode-map
"z n" #'rasen/org-occur-next)
#+end_src

Disable highlighting for org-occur.
#+name: org-config
#+begin_src emacs-lisp
(setq org-highlight-sparse-tree-matches nil)
#+end_src
** Highlight projects
Fontify all headlines with the =:PROJECT:= tag.
#+name: org-config
#+begin_src emacs-lisp
(defface rasen/org-project-face
'((t :weight bold))
"Face for org-mode projects.")

(font-lock-add-keywords 'org-mode
`((,(concat "^\\*+ \\(.*\\) :\\(" org-tag-re ":\\)*PROJECT:.*$")
(0 'rasen/org-project-face prepend)))
t)
#+end_src

Note that the face is overridden in [[*Color theme][Color theme]] section.
** Clocking
Remove clocks with 0 duration.
#+name: org-config
#+begin_src emacs-lisp
(setq-default org-clock-out-remove-zero-time-clocks t)
#+end_src

Save more last clocks.
#+name: org-config
#+begin_src emacs-lisp
(setq-default org-clock-history-length 10)
#+end_src
** Capture
I use an extension that adds page url to the title (used for page tracking). Strip it down here
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/strip-url-from-title (title)
(message "stripping: %s" title)
(replace-regexp-in-string
" @ [^ ]*$"
""
(replace-regexp-in-string " \\[[^]]*\\]\\[[^]]*\\]$" "" title)))
#+end_src

My capture templates.
#+name: org-config
#+begin_src emacs-lisp
(setq rasen/org-refile-file (concat rasen/org-directory "/refile-" system-name ".org"))
(setq org-capture-templates
`(("u"
"Task: Read this URL"
entry
(file rasen/org-refile-file)
,(concat "* TODO %(rasen/strip-url-from-title \"%:description\")\n"
":PROPERTIES:\n"
":CREATED: %U\n"
":END:\n"
"%:link\n")
:immediate-finish t)

("w"
"Capture web snippet"
entry
(file rasen/org-refile-file)
,(concat "* %(rasen/strip-url-from-title \"%:description\")\n"
":PROPERTIES:\n"
":CREATED: %U\n"
":SOURCE_URL: %:link\n"
":END:\n"
"#+begin_quote\n"
"%i\n"
"#+end_quote\n"
"%?\n")
:immediate-finish t)

("j" "Journal entry" plain
(file+datetree+prompt "~/org/journal.org")
,(concat
;; %U does not work here because timestamp is hijacked by
;; %file+datetime+prompt
"%(format-time-string (org-time-stamp-format t t))"
"\n"))

("t" "todo" entry (file rasen/org-refile-file)
"* TODO %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :clock-in t :clock-resume t :clock-resume t)

("T" "today" entry (file rasen/org-refile-file)
"* NEXT %?\nSCHEDULED: %t\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :clock-in nil :clock-resume t)

("m" "meeting" entry (file rasen/org-refile-file)
"* %? :meeting:\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :clock-in t :clock-resume t)

("n" "note" entry (file rasen/org-refile-file)
"* %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n")

("l" "link" entry (file rasen/org-refile-file)
"* %a\n:PROPERTIES:\n:CREATED: %U\n:END:\n"
:immediate-finish t)))

(defun rasen/org-capture-link ()
(interactive)
(org-capture nil "l"))
#+end_src

Enable org-protocol.
#+name: org-config
#+begin_src emacs-lisp
(require 'org-protocol)
#+end_src

=%l= in org-capture fails with multiline context, so use only the first line as a context.
#+name: org-config
#+begin_src emacs-lisp
(setq org-context-in-file-links 1)
#+end_src

*** org-capture keybindings
Instanly go into insert mode on capture.
#+name: org-config
#+begin_src emacs-lisp
;; (add-hook 'org-capture-mode-hook 'evil-insert-state)
#+end_src

#+name: org-config
#+begin_src emacs-lisp
(general-def
:keymaps 'org-capture-mode-map
:states 'normal
"'" #'org-capture-finalize)
(leader-def 'normal 'org-capture-mode-map
"w" #'org-capture-refile)
#+end_src
** Capturing images
#+begin_src emacs-lisp
(use-package org-download
:config
(setq org-download-method 'directory)
;; Do not prepend heading name to the file path
(setq-default org-download-heading-lvl nil)
;; "download" screenshots from clipboard
(setq org-download-screenshot-method "xclip -selection clipboard -t image/png -o > %s")

;; Prefix downloaded files with tsid.
(setq org-download-file-format-function
(defun rasen/org-download-file-format (filename)
(concat (rasen/tsid) "-" filename))))
#+end_src
** datetree
An interactive command to jump to a specific datetree entry in the current buffer. I used this as a lightweight way to keep a journal.
#+begin_src emacs-lisp
;; adapted from org-capture module

(defun rasen/org-datetree-entry (arg)
"Add a date-tree entry in the current file. Interactive version."
(interactive "P")
(let ((d (calendar-gregorian-from-absolute
(if arg
;; Current date, possibly corrected for late night
;; workers.
(org-today)
(progn;; Prompt for date.
(let ((prompt-time (org-read-date
nil t nil "Date for tree entry:")))
(cond ((and (or (not (boundp 'org-time-was-given))
(not org-time-was-given))
(not (= (time-to-days prompt-time) (org-today))))
;; Use 00:00 when no time is given for another
;; date than today?
(apply #'encode-time 0 0
org-extend-today-until
(cl-cdddr (decode-time prompt-time))))
((string-match "\\([^ ]+\\)--?[^ ]+[ ]+\\(.*\\)"
org-read-date-final-answer)
;; Replace any time range by its start.
(apply #'encode-time
(org-read-date-analyze
(replace-match "\\1 \\2" nil nil
org-read-date-final-answer)
prompt-time (decode-time prompt-time))))
(t prompt-time))
(time-to-days prompt-time)))))))
(org-datetree-find-date-create d)))
#+end_src
** cliplink
#+begin_src emacs-lisp
(use-package org-cliplink
:config
;; I don't like titles clipping at 80. I'd rather get the full title
;; and edit it manually.
(setq org-cliplink-max-length 200))
#+end_src
** Refile
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-refile-files ()
(rasen/org-files-in-dir rasen/org-directory))

;; non-nil values work bad with ivy
(setq-default org-refile-use-outline-path 'file)
(setq-default org-outline-path-complete-in-steps nil)

;; Allow refiling to projects and honeypots only. The rest of refiling
;; is handled by hydra.
(setq org-refile-targets
'((org-agenda-files . (:tag . "honeypot"))
(org-agenda-files . (:tag . "PROJECT"))))
(add-to-list 'org-tags-exclude-from-inheritance "honeypot")
#+end_src

Setting ~org-refile-use-outline-path~ to ~'file~ prepends the file names to refile targets but also has a side effect of allowing refiling to the top level of these files. Patch ~org-refile-get-targets~ to disable that.
#+name: org-config
#+begin_src emacs-lisp
(el-patch-defun org-refile-get-targets (&optional default-buffer)
"Produce a table with refile targets."
(let ((case-fold-search nil)
;; otherwise org confuses "TODO" as a kw and "Todo" as a word
(entries (or org-refile-targets '((nil . (:level . 1)))))
targets tgs files desc descre)
(message "Getting targets...")
(with-current-buffer (or default-buffer (current-buffer))
(dolist (entry entries)
(setq files (car entry) desc (cdr entry))
(cond
((null files) (setq files (list (current-buffer))))
((eq files 'org-agenda-files)
(setq files (org-agenda-files 'unrestricted)))
((and (symbolp files) (fboundp files))
(setq files (funcall files)))
((and (symbolp files) (boundp files))
(setq files (symbol-value files))))
(when (stringp files) (setq files (list files)))
(cond
((eq (car desc) :tag)
(setq descre (concat "^\\*+[ \t]+.*?:" (regexp-quote (cdr desc)) ":")))
((eq (car desc) :todo)
(setq descre (concat "^\\*+[ \t]+" (regexp-quote (cdr desc)) "[ \t]")))
((eq (car desc) :regexp)
(setq descre (cdr desc)))
((eq (car desc) :level)
(setq descre (concat "^\\*\\{" (number-to-string
(if org-odd-levels-only
(1- (* 2 (cdr desc)))
(cdr desc)))
"\\}[ \t]")))
((eq (car desc) :maxlevel)
(setq descre (concat "^\\*\\{1," (number-to-string
(if org-odd-levels-only
(1- (* 2 (cdr desc)))
(cdr desc)))
"\\}[ \t]")))
(t (error "Bad refiling target description %s" desc)))
(dolist (f files)
(with-current-buffer (if (bufferp f) f (org-get-agenda-file-buffer f))
(or
(setq tgs (org-refile-cache-get (buffer-file-name) descre))
(progn
(when (bufferp f)
(setq f (buffer-file-name (buffer-base-buffer f))))
(setq f (and f (expand-file-name f)))
(el-patch-remove
(when (eq org-refile-use-outline-path 'file)
(push (list (and f (file-name-nondirectory f)) f nil nil) tgs)))
(when (eq org-refile-use-outline-path 'buffer-name)
(push (list (buffer-name (buffer-base-buffer)) f nil nil) tgs))
(when (eq org-refile-use-outline-path 'full-file-path)
(push (list (and (buffer-file-name (buffer-base-buffer))
(file-truename (buffer-file-name (buffer-base-buffer))))
f nil nil) tgs))
(org-with-wide-buffer
(goto-char (point-min))
(setq org-outline-path-cache nil)
(while (re-search-forward descre nil t)
(beginning-of-line)
(let ((case-fold-search nil))
(looking-at org-complex-heading-regexp))
(let ((begin (point))
(heading (match-string-no-properties 4)))
(unless (or (and
org-refile-target-verify-function
(not
(funcall org-refile-target-verify-function)))
(not heading))
(let ((re (format org-complex-heading-regexp-format
(regexp-quote heading)))
(target
(if (not org-refile-use-outline-path) heading
(mapconcat
#'identity
(append
(pcase org-refile-use-outline-path
(`file (list
(and (buffer-file-name (buffer-base-buffer))
(file-name-nondirectory
(buffer-file-name (buffer-base-buffer))))))
(`full-file-path
(list (buffer-file-name
(buffer-base-buffer))))
(`buffer-name
(list (buffer-name
(buffer-base-buffer))))
(_ nil))
(mapcar (lambda (s) (replace-regexp-in-string
"/" "\\/" s nil t))
(org-get-outline-path t t)))
"/"))))
(push (list target f re (org-refile-marker (point)))
tgs)))
(when (= (point) begin)
;; Verification function has not moved point.
(end-of-line)))))))
(when org-refile-use-cache
(org-refile-cache-put tgs (buffer-file-name) descre))
(setq targets (append tgs targets))))))
(message "Getting targets...done")
(delete-dups (nreverse targets))))
#+end_src
*** Refiling with hydras
Adapted from [[https://mollermara.com/blog/Fast-refiling-in-org-mode-with-hydras/][Fast refiling in org-mode with hydras | Josh Moller-Mara]]. Extended to support refiling by outline path.
#+name: org-config
#+begin_src emacs-lisp
(require 'hydra)

(defun rasen/concat (sequence separator)
(mapconcat 'identity sequence separator))

(defun rasen/org-refile-exact (file path &optional arg)
"Refile to a specific location.

With a `C-u' ARG argument, jump to that location."
(let* ((pos (and path (org-find-olp (cons file path))))
(rfloc (list (rasen/concat path "/") file nil pos)))

(if (and (eq major-mode 'org-agenda-mode)
;; Don't use org-agenda-refile if we're just jumping
(not (and arg (listp arg))))
(org-agenda-refile nil rfloc)
(org-refile arg nil rfloc))))

(defun rasen/refile (file path &optional arg)
"Refile to PATH in FILE. Clean up org-capture if it's activated.

With a `C-u` ARG, just jump to the headline."
(interactive "P")
(let ((is-capturing (and (boundp 'org-capture-mode) org-capture-mode)))
(cond
((and arg (listp arg)) ;Are we jumping?
(rasen/org-refile-exact file path arg))

;; Are we in org-capture-mode?
(is-capturing
(rasen/org-capture-refile-but-with-args file path arg))

(t
(rasen/org-refile-exact file path arg)))

(when (or arg is-capturing)
(setq hydra-deactivate t))))

(defun rasen/org-capture-refile-but-with-args (file path &optional arg)
"Copied from `org-capture-refile' since it doesn't allow passing arguments. This does."
(unless (eq (org-capture-get :type 'local) 'entry)
(error
"Refiling from a capture buffer makes only sense for `entry'-type templates"))
(let ((pos (point))
(base (buffer-base-buffer (current-buffer)))
(org-capture-is-refiling t)
(kill-buffer (org-capture-get :kill-buffer 'local)))
(org-capture-put :kill-buffer nil)
(org-capture-finalize)
(save-window-excursion
(with-current-buffer (or base (current-buffer))
(org-with-wide-buffer
(goto-char pos)
(rasen/org-refile-exact file path arg))))
(when kill-buffer (kill-buffer base))))

(defmacro rasen/make-refile-hydra (hydraname name &rest options)
(declare (indent defun))
`(defhydra ,hydraname (:foreign-keys run :exit t)
,name

,@(mapcar (lambda (x)
(let ((key (nth 0 x))
(name (nth 1 x))
(file (nth 2 x))
(path (nthcdr 3 x)))
(if (stringp file)
`(,key (rasen/refile ,file ',path current-prefix-arg) ,name)
`(,key ,file ,name))))
options)

("q" nil "cancel")))

(rasen/make-refile-hydra rasen/org-refile-hydra-someday "Someday"
("u" "Uniorg" "~/org/plan.org" "Someday/Maybe" "Uniorg")
("n" "Notes" "~/org/plan.org" "Someday/Maybe" "Notes")
("a" "Writing" "~/org/plan.org" "Someday/Maybe" "Writing / website")
("c" "Computer" "~/org/plan.org" "Someday/Maybe" "Computer")
("r" "Reading" "~/org/plan.org" "Someday/Maybe" "Reading")
("s" "Misc" "~/org/plan.org" "Someday/Maybe" "Misc"))

(rasen/make-refile-hydra rasen/org-refile-hydra "Refile"
("p" "Projects" "~/org/plan.org" "Projects")

("n" "To do" "~/org/plan.org" "To do")
("s" "Someday" rasen/org-refile-hydra-someday/body)
("t" "Tickler" "~/org/plan.org" "Tickler")
("W" "Waiting" "~/org/plan.org" "Waiting")
("r" "Resources" "~/org/resources.org")
("b" "Books" "~/org/books.org")

("w" "select"
(if (eq major-mode 'org-agenda-mode)
(org-agenda-refile current-prefix-arg)
(org-refile current-prefix-arg))))

(leader-def 'normal 'org-mode-map "w" #'rasen/org-refile-hydra/body)
(leader-def 'motion 'org-agenda-mode-map "w" #'rasen/org-refile-hydra/body)
(leader-def 'normal 'org-capture-mode-map "w" #'rasen/org-refile-hydra/body)
#+end_src
*** Refile last but *before* archive
I like my archive sibling to be the last child. The default org-refile ignores that at refiles all entries *after* archive.

So here is a little patch to refile before archive sibling if it is present.
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-goto-last-child ()
"Goto the last child, even if it is invisible.
Return t when a child was found. Otherwise don't move point and return nil."
(when (org-goto-first-child)
(while (org-goto-sibling))
t))

(defun rasen/org-goto-last-archive ()
(and (rasen/org-goto-last-child)
(string= org-archive-sibling-heading (org-get-heading t t t t))
(member org-archive-tag (org-get-tags))
(point)))

(require 'org-archive) ; for org-archive-sibling-heading

(el-patch-feature org)
(el-patch-defun org-refile (&optional arg default-buffer rfloc msg)
"Move the entry or entries at point to another heading.

The list of target headings is compiled using the information in
`org-refile-targets', which see.

At the target location, the entry is filed as a subitem of the
target heading. Depending on `org-reverse-note-order', the new
subitem will either be the first or the last subitem.

If there is an active region, all entries in that region will be
refiled. However, the region must fulfill the requirement that
the first heading sets the top-level of the moved text.

With a `\\[universal-argument]' ARG, the command will only visit the target \
location
and not actually move anything.

With a prefix `\\[universal-argument] \\[universal-argument]', go to the \
location where the last
refiling operation has put the subtree.

With a numeric prefix argument of `2', refile to the running clock.

With a numeric prefix argument of `3', emulate `org-refile-keep'
being set to t and copy to the target location, don't move it.
Beware that keeping refiled entries may result in duplicated ID
properties.

RFLOC can be a refile location obtained in a different way. It
should be a list with the following 4 elements:

1. Name - an identifier for the refile location, typically the
headline text
2. File - the file the refile location is in
3. nil - used for generating refile location candidates, not
needed when passing RFLOC
4. Position - the position in the specified file of the
headline to refile under

MSG is a string to replace \"Refile\" in the default prompt with
another verb. E.g. `org-copy' sets this parameter to \"Copy\".

See also `org-refile-use-outline-path'.

If you are using target caching (see `org-refile-use-cache'), you
have to clear the target cache in order to find new targets.
This can be done with a `0' prefix (`C-0 C-c C-w') or a triple
prefix argument (`C-u C-u C-u C-c C-w')."
(interactive "P")
(if (member arg '(0 (64)))
(org-refile-cache-clear)
(let* ((actionmsg (cond (msg msg)
((equal arg 3) "Refile (and keep)")
(t "Refile")))
(regionp (org-region-active-p))
(region-start (and regionp (region-beginning)))
(region-end (and regionp (region-end)))
(org-refile-keep (if (equal arg 3) t org-refile-keep))
pos it nbuf file level reversed)
(setq last-command nil)
(when regionp
(goto-char region-start)
(beginning-of-line)
(setq region-start (point))
(unless (or (org-kill-is-subtree-p
(buffer-substring region-start region-end))
(prog1 org-refile-active-region-within-subtree
(let ((s (point-at-eol)))
(org-toggle-heading)
(setq region-end (+ (- (point-at-eol) s) region-end)))))
(user-error "The region is not a (sequence of) subtree(s)")))
(if (equal arg '(16))
(org-refile-goto-last-stored)
(when (or
(and (equal arg 2)
org-clock-hd-marker (marker-buffer org-clock-hd-marker)
(prog1
(setq it (list (or org-clock-heading "running clock")
(buffer-file-name
(marker-buffer org-clock-hd-marker))
""
(marker-position org-clock-hd-marker)))
(setq arg nil)))
(setq it
(or rfloc
(let (heading-text)
(save-excursion
(unless (and arg (listp arg))
(org-back-to-heading t)
(setq heading-text
(replace-regexp-in-string
org-link-bracket-re
"\\2"
(or (nth 4 (org-heading-components))
""))))
(org-refile-get-location
(cond ((and arg (listp arg)) "Goto")
(regionp (concat actionmsg " region to"))
(t (concat actionmsg " subtree \""
heading-text "\" to")))
default-buffer
(and (not (equal '(4) arg))
org-refile-allow-creating-parent-nodes)))))))
(setq file (nth 1 it)
pos (nth 3 it))
(when (and (not arg)
pos
(equal (buffer-file-name) file)
(if regionp
(and (>= pos region-start)
(<= pos region-end))
(and (>= pos (point))
(< pos (save-excursion
(org-end-of-subtree t t))))))
(error "Cannot refile to position inside the tree or region"))
(setq nbuf (or (find-buffer-visiting file)
(find-file-noselect file)))
(if (and arg (not (equal arg 3)))
(progn
(pop-to-buffer-same-window nbuf)
(goto-char (cond (pos)
((org-notes-order-reversed-p) (point-min))
(t (point-max))))
(org-show-context 'org-goto))
(if regionp
(progn
(org-kill-new (buffer-substring region-start region-end))
(org-save-markers-in-region region-start region-end))
(org-copy-subtree 1 nil t))
(with-current-buffer (setq nbuf (or (find-buffer-visiting file)
(find-file-noselect file)))
(setq reversed (org-notes-order-reversed-p))
(org-with-wide-buffer
(if pos
(progn
(goto-char pos)
(setq level (org-get-valid-level (funcall outline-level) 1))
(goto-char
(if reversed
(or (outline-next-heading) (point-max))
(or (el-patch-add (save-excursion (rasen/org-goto-last-archive)))
(save-excursion (org-get-next-sibling))
(org-end-of-subtree t t)
(point-max)))))
(setq level 1)
(if (not reversed)
(goto-char (point-max))
(goto-char (point-min))
(or (outline-next-heading) (goto-char (point-max)))))
(unless (bolp) (newline))
(org-paste-subtree level nil nil t)
(cond
((not org-log-refile))
(regionp
(org-map-region
(lambda nil
(org-add-log-setup 'refile nil nil 'time))
(point)
(+
(point)
(- region-end region-start))))
(t
(org-add-log-setup 'refile nil nil org-log-refile)))
(and org-auto-align-tags
(let ((org-loop-over-headlines-in-active-region nil))
(org-align-tags)))
(let ((bookmark-name (plist-get org-bookmark-names-plist
:last-refile)))
(when bookmark-name
(with-demoted-errors
(bookmark-set bookmark-name))))
;; If we are refiling for capture, make sure that the
;; last-capture pointers point here
(when (bound-and-true-p org-capture-is-refiling)
(let ((bookmark-name (plist-get org-bookmark-names-plist
:last-capture-marker)))
(when bookmark-name
(with-demoted-errors
(bookmark-set bookmark-name))))
(move-marker org-capture-last-stored-marker (point)))
(when (fboundp 'deactivate-mark) (deactivate-mark))
(run-hooks 'org-after-refile-insert-hook)))
(unless org-refile-keep
(if regionp
(delete-region (point) (+ (point) (- region-end region-start)))
(org-preserve-local-variables
(delete-region
(and (org-back-to-heading t) (point))
(min (1+ (buffer-size)) (org-end-of-subtree t t) (point))))))
(when (featurep 'org-inlinetask)
(org-inlinetask-remove-END-maybe))
(setq org-markers-to-move nil)
(message "%s to \"%s\" in file %s: done" actionmsg
(car it)
file)))))))
#+end_src
** Archive
#+name: org-config
#+begin_src emacs-lisp
;; (setq-default org-archive-default-command 'org-archive-to-archive-sibling)
(setq-default org-archive-default-command #'org-archive-subtree)
#+end_src
** Agenda
Set my org files location.
#+name: org-config
#+begin_src emacs-lisp
(setq org-directory "~/org"
org-default-notes-file rasen/org-refile-file
org-agenda-files (cons "~/org/roam/fluxon/index.org" (rasen/org-files-in-dir "~/org")))
#+end_src

Show agenda as the only window and restore window layout on quit (so that agenda does not mess up with my layout).
#+begin_src emacs-lisp
(setq org-agenda-window-setup 'only-window)
(setq org-agenda-restore-windows-after-quit t)
#+end_src

Configure my agenda view.
#+name: org-config
#+begin_src emacs-lisp
(setq org-agenda-span 6)
#+end_src

Configure stuck projects.
#+name: org-config
#+begin_src emacs-lisp
(add-to-list 'org-tags-exclude-from-inheritance "PROJECT")
(setq org-stuck-projects
'("+PROJECT/-TODO-DONE-CANCELED-WAIT" ("NEXT" "WAIT") nil ""))
#+end_src

Do not align tags in agenda.
#+name: org-config
#+begin_src emacs-lisp
(setq org-agenda-tags-column 0)
#+end_src

Do not show project tags.
#+name: org-config
#+begin_src emacs-lisp
(setq org-agenda-hide-tags-regexp "PROJECT\\|fc\\|suspended")
#+end_src

#+begin_src emacs-lisp
(use-package org-super-agenda
:config
(general-def org-super-agenda-header-map
"k" #'org-agenda-next-line
"j" #'org-agenda-previous-line)

;; cache agenda, and only rebuild on request
(setq org-agenda-sticky t)

(setq org-agenda-block-separator nil
org-agenda-compact-blocks t
org-agenda-time-grid '((daily today require-timed) (1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300) "......" "----------------")
;; org-agenda-time-grid '((daily today require-timed) nil "......" "----------------")
)

(setq org-agenda-custom-commands
'(("o" "Overview"
((agenda "" (;; start from yesterday
(org-agenda-start-day "-1d")

;; show 6 days
(org-agenda-span 6)

;; show closed items
(org-agenda-show-log t)
(org-agenda-log-mode-items '(closed))

;; Show habits on each day. (Useful if today
;; is closed but you still want to see the
;; habit graph.)
;; (org-habit-show-habits-only-for-today nil)

(org-super-agenda-groups
'(;; 1. time-grid
;; 2. scheduled today
;; 3. deadline today
;; 4. habits
;; 5. rest (anniversaries, etc.)
;; 6. deadline reminders
(:name none ;; habits
:habit t
:order 4)
(:name none ;; time-grid
:time-grid t
:order 1)
(:name none ;; don't show closed items—they are still seen in the log
:discard (:todo ("DONE" "CANCELED")))
(:name none ;; scheduled today
:todo ("WAIT")
:scheduled today
:order 2.5)
(:name none ;; scheduled today
:scheduled today
:order 2)
(:name none ;; deadline today
:deadline today
:order 3)
(:name none ;; deadline reminders
:deadline t
:scheduled t
:order 6)
(:name none ;; everything else
:anything t
:order 5)))))
(alltodo "" ((org-agenda-overriding-header "")
(org-super-agenda-groups
'(;; drop scheduled items—they are shown in
;; agenda view
(:discard (:scheduled t))

;; 8. Next items
;; 9. Active projects (NEXT/WAIT)
;; 11. Active books (NEXT)
;; 12. Waiting for items (WAIT)
(:name "Books"
:and (:category "books"
:todo "NEXT")
:order 11)
(:name "Projects"
:and (:tag "PROJECT"
:todo "NEXT")
:and (:tag "PROJECT"
:todo "WAIT")
:order 9)
(:name "Next"
:todo "NEXT"
:order 8)
(:todo "WAIT"
:order 12)
(:discard (:anything t))))))

;; inbox items (they must have a “CREATED” property to be considered an item)
(search "+{:CREATED:}" ((org-agenda-files (mapcar (lambda (x) (concat rasen/org-directory "/" x))
'("refile-omicron.org"
"orgzly.org")))
(org-agenda-overriding-header "")
(org-super-agenda-groups
'((:name "Inbox"
:auto-category t
:anything t)))))))

("f" "Fluxon"
((agenda "" ((org-agenda-files '("~/org/roam/fluxon/index.org" "~/org/refile-bayraktar.org"))
;; start from yesterday
(org-agenda-start-day "-1d")

;; show 8 days
(org-agenda-span 8)

;; show closed items
(org-agenda-show-log t)
(org-agenda-log-mode-items '(closed))

;; Show habits on each day. (Useful if today
;; is closed but you still want to see the
;; habit graph.)
;; (org-habit-show-habits-only-for-today nil)

(org-super-agenda-groups
'(;; 1. time-grid
;; 2. scheduled today
;; 3. deadline today
;; 4. habits
;; 5. rest (anniversaries, etc.)
;; 6. deadline reminders
(:name none ;; habits
:habit t
:order 4)
(:name none ;; time-grid
:time-grid t
:order 1)
(:name none ;; don't show closed items—they are still seen in the log
:discard (:todo ("DONE" "CANCELED")))
(:name none ;; scheduled today
:and (:todo ("WAIT")
:scheduled today)
:order 2.5)
(:name none ;; scheduled today
:scheduled today
:order 2)
(:name none ;; deadline today
:deadline today
:order 3)
(:name none ;; deadline reminders
:deadline t
:scheduled t
:order 6)
(:name none ;; everything else
:anything t
:order 5)))))
(alltodo "" ((org-agenda-files '("~/org/roam/fluxon/index.org" "~/org/refile-bayraktar.org"))
(org-agenda-overriding-header "")
(org-super-agenda-groups
'(;; drop scheduled items—they are shown in
;; agenda view
(:discard (:scheduled t))

;; 8. Next items
;; 9. Active projects (NEXT/WAIT)
;; 11. Active books (NEXT)
;; 12. Waiting for items (WAIT)
(:name "Books"
:and (:category "books"
:todo "NEXT")
:order 11)
(:name "Projects"
:and (:tag "PROJECT"
:todo "NEXT")
:and (:tag "PROJECT"
:todo "WAIT")
:order 9)
(:name "Kiavi"
:and (:category "kiavi"
:todo "NEXT")
:order 8.1)
(:name "Tonic"
:and (:category "tonic"
:todo "NEXT")
:order 8.2)
(:name "Dory"
:and (:category "dory"
:todo "NEXT")
:order 8.3)
(:name "Next"
:todo "NEXT"
:order 8.4)
(:todo "WAIT"
:order 12)
(:discard (:anything t))))))

;; inbox items (they must have a “CREATED” property to be considered an item)
(search "+{:CREATED:}" ((org-agenda-files '("~/org/refile-bayraktar.org"))
(org-agenda-overriding-header "")
(org-super-agenda-groups
'((:name "Inbox"
:auto-category t
:anything t)))))))

("N" tags "+TODO=\"NEXT\"-PROJECT|+TODO=\"WAIT\"-PROJECT")
("n" todo-tree "NEXT")
("p" "active projects" tags "+PROJECT/+NEXT")
("P" "all projects" tags "+PROJECT/-DONE-CANCELED")))
(org-super-agenda-mode))
#+end_src
*** Allow NEXT projects to stuck
=org-agenda-list-stuck-projects= marks project as unstuck if its header matches any of specified keywords. This makes all =NEXT= projects automatically unstuck.

Fix this by skipping the first line (project title) in =org-agenda-skip-function=.
#+begin_src emacs-lisp
(el-patch-feature org-agenda)
(el-patch-defun org-agenda-list-stuck-projects (&rest ignore)
"Create agenda view for projects that are stuck.
Stuck projects are project that have no next actions. For the definitions
of what a project is and how to check if it stuck, customize the variable
`org-stuck-projects'."
(interactive)
(let* ((org-agenda-overriding-header
(or org-agenda-overriding-header "List of stuck projects: "))
(matcher (nth 0 org-stuck-projects))
(todo (nth 1 org-stuck-projects))
(tags (nth 2 org-stuck-projects))
(gen-re (org-string-nw-p (nth 3 org-stuck-projects)))
(todo-wds
(if (not (member "*" todo)) todo
(org-agenda-prepare-buffers (org-agenda-files nil 'ifmode))
(org-delete-all org-done-keywords-for-agenda
(copy-sequence org-todo-keywords-for-agenda))))
(todo-re (and todo
(format "^\\*+[ \t]+\\(%s\\)\\>"
(mapconcat #'identity todo-wds "\\|"))))
(tags-re (cond ((null tags) nil)
((member "*" tags) org-tag-line-re)
(tags
(let ((other-tags (format "\\(?:%s:\\)*" org-tag-re)))
(concat org-outline-regexp-bol
".*?[ \t]:"
other-tags
(regexp-opt tags t)
":" other-tags "[ \t]*$")))
(t nil)))
(re-list (delq nil (list todo-re tags-re gen-re)))
(skip-re
(if (null re-list)
(error "Missing information to identify unstuck projects")
(mapconcat #'identity re-list "\\|")))
(org-agenda-skip-function
;; Skip entry if `org-agenda-skip-regexp' matches anywhere
;; in the subtree.
`(lambda ()
(and (save-excursion
(let ((case-fold-search nil)
(el-patch-add (subtree-end (save-excursion (org-end-of-subtree t)))))
(el-patch-add (forward-line))
(re-search-forward
,skip-re
(el-patch-swap
(save-excursion (org-end-of-subtree t))
subtree-end)
t)))
(progn (outline-next-heading) (point))))))
(org-tags-view nil matcher)
(setq org-agenda-buffer-name (buffer-name))
(with-current-buffer org-agenda-buffer-name
(setq org-agenda-redo-command
`(org-agenda-list-stuck-projects ,current-prefix-arg))
(let ((inhibit-read-only t))
(add-text-properties
(point-min) (point-max)
`(org-redo-cmd ,org-agenda-redo-command))))))
#+end_src
** Babel
Code-highlight (fontify) org-babel (=#+begin_src=) blocks.
#+name: org-config
#+begin_src emacs-lisp
(setq org-src-fontify-natively t)
#+end_src

Do not confirm evaluation for emacs-lisp.
#+name: org-config
#+begin_src emacs-lisp
(defun rasen/org-confirm-babel-evaluate (lang body)
(not (member lang '("emacs-lisp"))))

(setq org-confirm-babel-evaluate 'rasen/org-confirm-babel-evaluate)
#+end_src

Load more languages:
#+name: org-config
#+begin_src emacs-lisp
(org-babel-do-load-languages 'org-babel-load-languages
'((shell . t)))
#+end_src
** Latex preview
Install imagemagick and latex:
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.imagemagick
# latex for displaying fragments in org-mode
(pkgs.texlive.combine {
inherit (pkgs.texlive)
scheme-small
dvipng
dvisvgm
mhchem # chemistry
tikz-cd # category theory diagrams
# required for org export
wrapfig
capt-of
;
})
pkgs.ghostscript
];
}
#+end_src

#+name: org-config
#+begin_src emacs-lisp
(setq org-latex-packages-alist
'(;; Use mhchem for chemistry formulas
("" "mhchem" t)
;; Use tikz-cd for category theory formulas
("" "tikz-cd" t)))

;; Store all preview in external directory
(setq org-preview-latex-image-directory (expand-file-name "cache/ltximg/" user-emacs-directory))

;; Use imagemagick instead of dvipng (dvipng does not work with tikz)
(setq org-preview-latex-default-process 'imagemagick)

;; Enable latex preview by default
(setq org-startup-with-latex-preview t)

(when (string= (system-name) "omicron")
;; The latest imagemagick incorrectly trims images when density is
;; odd. My density is 277. Hard-code -density option to the closest
;; even number, so latex images are properly trimmed.
(plist-put (alist-get 'imagemagick org-preview-latex-process-alist)
:image-converter '("convert -density 278 -trim -antialias %f -quality 100 %O")))
#+end_src
** Image preview
#+name: org-config
#+begin_src emacs-lisp
;; Scale inline images by default
(setq org-image-actual-width '(800))
;; Show inline images by default
(setq org-startup-with-inline-images t)
#+end_src
** Export
Fix exporting for confluence.

=ox-confluence= has an issue with verbatim---it doesn't redefine verbatim translation, so =org-ascii-verbatim= is used. The following makes =org-ascii-verbatim= produce proper confluence fixed-width block.
#+name: org-config
#+begin_src emacs-lisp
(add-to-list 'org-modules 'ox-confluence)
(setq org-ascii-verbatim-format "\{\{%s\}\}")

(defun rasen/org-ox-confluence ()
(interactive)
(save-excursion
(save-restriction
(when (region-active-p)
(narrow-to-region (region-beginning) (region-end)))

(goto-char (point-min))
(perform-replace "-" "-"
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
)
(goto-char (point-min))
(perform-replace "_" "_"
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
)
(goto-char (point-min))
(perform-replace "{" "{"
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
)
(goto-char (point-min))
(perform-replace "}" "}"
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
)
(goto-char (point-min))
(perform-replace "[" "["
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
)
(goto-char (point-min))
(perform-replace "]" "]"
nil ; replace all
nil ; not regex
nil ; replace on word boundaries
))))

(setq rasen/confluence-block-known-languages
'("actionscript3"
"applescript"
"bash"
"c#"
"cpp"
"css"
"coldfusion"
"delphi"
"diff"
"erl" ; Erlang
"groovy"
"xml" ; and HTML
"java"
"jfx" ; Java FX
"js"
"php"
"perl"
"text"
"powershell"
"py"
"ruby"
"sql"
"sass"
"scala"
"vb" ; Visual Basic
"yml"))

(require 'ox-confluence)
(el-patch-defun org-confluence--block (language theme contents)
(concat (el-patch-swap "\{code:theme=" "\{code") (el-patch-remove theme)
(when (el-patch-swap language (member language rasen/confluence-block-known-languages)) (format (el-patch-swap "|language=%s" ":language=%s") language))
"}\n"
contents
"\{code\}\n"))
#+end_src
** Crypt
Allow encrypted entries in org files.
#+name: org-config
#+begin_src emacs-lisp
(require 'org-crypt)
(org-crypt-use-before-save-magic)
(add-to-list 'org-tags-exclude-from-inheritance "crypt")
(setq org-crypt-key "rasen.dubi@gmail.com")
(add-hook 'org-babel-pre-tangle-hook 'org-decrypt-entries t)
#+end_src
** org-list
I always use either =-= or =1.= style for lists. Make ~org-cycle-list-bullet~ ignore the rest of styles (=*=, =+=, =1)=), so switching between ordered/unordered list is always one command away:
#+name: org-config
#+begin_src emacs-lisp
(el-patch-defun org-cycle-list-bullet (&optional which)
"Cycle through the different itemize/enumerate bullets.
This cycle the entire list level through the sequence:

`-' -> `+' -> `*' -> `1.' -> `1)'

If WHICH is a valid string, use that as the new bullet. If WHICH
is an integer, 0 means `-', 1 means `+' etc. If WHICH is
`previous', cycle backwards."
(interactive "P")
(unless (org-at-item-p) (error "Not at an item"))
(save-excursion
(beginning-of-line)
(let* ((struct (org-list-struct))
(parents (org-list-parents-alist struct))
(prevs (org-list-prevs-alist struct))
(list-beg (org-list-get-first-item (point) struct prevs))
(bullet (org-list-get-bullet list-beg struct))
(alpha-p (org-list-use-alpha-bul-p list-beg struct prevs))
(case-fold-search nil)
(current (cond
((string-match "[a-z]\\." bullet) "a.")
((string-match "[a-z])" bullet) "a)")
((string-match "[A-Z]\\." bullet) "A.")
((string-match "[A-Z])" bullet) "A)")
((string-match "\\." bullet) "1.")
((string-match ")" bullet) "1)")
(t (org-trim bullet))))
;; Compute list of possible bullets, depending on context.
(bullet-list
(append '("-" (el-patch-remove "+"))
(el-patch-remove
;; *-bullets are not allowed at column 0.
(unless (looking-at "\\S-") '("*")))
;; Description items cannot be numbered.
(unless (or (eq org-plain-list-ordered-item-terminator ?\))
(org-at-item-description-p))
'("1."))
(el-patch-remove
(unless (or (eq org-plain-list-ordered-item-terminator ?.)
(org-at-item-description-p))
'("1)"))
(unless (or (not alpha-p)
(eq org-plain-list-ordered-item-terminator ?\))
(org-at-item-description-p))
'("a." "A."))
(unless (or (not alpha-p)
(eq org-plain-list-ordered-item-terminator ?.)
(org-at-item-description-p))
'("a)" "A)")))))
(len (length bullet-list))
(item-index (- len (length (member current bullet-list))))
(get-value (lambda (index) (nth (mod index len) bullet-list)))
(new (cond
((member which bullet-list) which)
((numberp which) (funcall get-value which))
((eq 'previous which) (funcall get-value (1- item-index)))
(t (funcall get-value (1+ item-index))))))
;; Use a short variation of `org-list-write-struct' as there's
;; no need to go through all the steps.
(let ((old-struct (copy-tree struct)))
(org-list-set-bullet list-beg struct (org-list-bullet-string new))
(org-list-struct-fix-bul struct prevs)
(org-list-struct-fix-ind struct parents)
(org-list-struct-apply-struct struct old-struct)))))
#+end_src
** org-checklist
Setting property =RESET_CHECK_BOXES= on a periodic task to =t= will clear all checkboxes when the task is closed.
#+name: org-config
#+begin_src emacs-lisp
(require 'org-checklist)
#+end_src
** Habits
#+name: org-config
#+begin_src emacs-lisp
(require 'org-habit)
(setq org-habit-show-habits-only-for-today t)
(setq org-habit-preceding-days 25)
(setq org-habit-following-days 3)
#+end_src
** adaptive-wrap
Better line wrapping. (Use proper wrap-prefix in lists, etc.)
#+begin_src emacs-lisp
(use-package adaptive-wrap
:config
(add-hook 'org-mode-hook #'adaptive-wrap-prefix-mode))
#+end_src
** org-id
Use timestamps as ids.
#+name: org-config
#+begin_src emacs-lisp
(setq org-id-method 'ts)
#+end_src

Configure ~org-store-link~ to prefer ids for headlines.
#+name: org-config
#+begin_src emacs-lisp
(setq org-id-link-to-org-use-id 'create-if-interactive)
#+end_src

Override ~org-id-new~ to use ~rasen/tsid~ as ids. (They have less precision but that's enough for me.) By using tsid, I can easily switch headline-nodes to file-nodes—id becomes the filename.
#+name: org-config
#+begin_src emacs-lisp
(el-patch-defun org-id-new (&optional prefix)
"Create a new globally unique ID.

An ID consists of two parts separated by a colon:
- a prefix
- a unique part that will be created according to `org-id-method'.

PREFIX can specify the prefix, the default is given by the variable
`org-id-prefix'. However, if PREFIX is the symbol `none', don't use any
prefix even if `org-id-prefix' specifies one.

So a typical ID could look like \"Org:4nd91V40HI\"."
(let* ((prefix (if (eq prefix 'none)
""
(concat (or prefix org-id-prefix) ":")))
unique)
(if (equal prefix ":") (setq prefix ""))
(cond
((memq org-id-method '(uuidgen uuid))
(setq unique (org-trim (shell-command-to-string org-id-uuid-program)))
(unless (org-uuidgen-p unique)
(setq unique (org-id-uuid))))
((eq org-id-method 'org)
(let* ((etime (org-reverse-string (org-id-time-to-b36)))
(postfix (if org-id-include-domain
(progn
(require 'message)
(concat "@" (message-make-fqdn))))))
(setq unique (concat etime postfix))))
((eq org-id-method 'ts)
(let ((ts (el-patch-swap (format-time-string org-id-ts-format)
(rasen/tsid)))
(postfix (if org-id-include-domain
(progn
(require 'message)
(concat "@" (message-make-fqdn))))))
(setq unique (concat ts postfix))))
(t (error "Invalid `org-id-method'")))
(concat prefix unique)))
#+end_src

Highlight org-id links with different color.
#+name: org-config
#+begin_src emacs-lisp
(defface rasen/org-id-link
'((t :inherit org-link))
"Face for org-id links.")

(org-link-set-parameters "id" :face 'rasen/org-id-link)
#+end_src
Actual style is overridden in Color theme section.
** org-roam
#+begin_src emacs-lisp
(use-package org-roam
:after org
:diminish
:autoload (org-roam-db-update-file)
:bind
(:map org-mode-map
("C-c i" . org-roam-node-insert))
:general
(s-leader-def
"n r" #'org-roam-buffer-toggle
"n f" #'org-roam-node-find
"n j" #'org-roam-dailies-goto-date
"n t" #'org-roam-dailies-goto-today
"n ." #'org-roam-dailies-goto-today
"n ," #'org-roam-dailies-goto-yesterday)
(:keymaps 'org-mode-map
:states 'normal
"SPC ," #'org-roam-dailies-goto-previous-note
"SPC ." #'org-roam-dailies-goto-next-note)
(:keymaps 'org-mode-map
:states '(insert visual)
"C-c i" #'org-roam-node-insert
;; C-i is interpreted as TAB
"C-c TAB" #'org-roam-node-insert)

:init
;; yes, I have migrated to v2
(setq org-roam-v2-ack t)

:config

(setq org-roam-directory (concat rasen/org-directory "/roam")
;; move `org-roam-db-location' off roam directory, so syncthing does not sync it
org-roam-db-location (expand-file-name "cache/org-roam.db" user-emacs-directory))

<>

<>

<>

<>

<>

<>

<>

<>

<>

<>

<>

(org-roam-db-autosync-enable))
#+end_src
*** org-roam-exclude-org-fc
Do not treat [[*org-fc][org-fc]] cards as nodes.
#+name: org-roam-exclude-org-fc
#+begin_src emacs-lisp :tangle no
(setq org-roam-db-node-include-function
(defun rasen/org-roam-include ()
;; exclude org-fc headlines from org-roam
(not (member "fc" (org-get-tags)))))
#+end_src
*** org-roam-slip-boxes
Slip boxes are basically different directories that I split notes into.
#+name: org-roam-slip-boxes
#+begin_src emacs-lisp :tangle no
(defconst rasen/slip-boxes
'(;; Default slip-box with permanent notes
("d" "default" "" "${rasen/capture-tsid}")
;; duplicate with another key to allow \\ n n
("n" "default" "" "${rasen/capture-tsid}")

;; "Life project"—everything that doesn't fit in other slip
;; boxes. Examples are: my gratitude journal, small projects,
;; article drafts, idea list.
("l" "life" "life/" "${rasen/capture-tsid}")

;; Work notes
("f" "fluxon" "fluxon/" "${rasen/capture-tsid}")

("P" "pulse" "pulse/" "${rasen/capture-tsid}" "#+DATE: %<%FT%T%z>\n#+LAST_MODIFIED: \n")

;; Posts
("p" "posts" "posts/" "${slug}" "#+DATE: %<%Y-%m-%d>\n#+LAST_MODIFIED: \n#+PUBLISHED: false")

;; Literature notes
("b" "bibliograpic" "biblio/" "${citekey}" "#+LAST_MODIFIED: \n#+DATE: %<%Y-%m-%d>\n"))
"My slip boxes. Format is a list of (capture-key name directory filename extra-template).")

;; one capture template per slip-box
(setq org-roam-capture-templates
(mapcar (lambda (x)
(let ((key (nth 0 x))
(name (nth 1 x))
(dir (nth 2 x))
(filename (nth 3 x))
(extra-template (nth 4 x)))
`(,key ,name plain "%?"
:if-new (file+head
,(concat dir filename ".org")
,(concat "#+TITLE: ${title}\n"
extra-template))
:immediate-finish t
:unnarrowed t)))
rasen/slip-boxes))

(defun rasen/capture-tsid (node)
"A hack definition to workaround that org-roam passes a node argument."
(rasen/tsid))
#+end_src

And a helper command to move notes between slip boxes.
#+name: org-roam-slip-boxes
#+begin_src emacs-lisp :tangle no
(defun rasen/move-to-slip-box (slip-box)
"Move file to specified SLIP-BOX."
(interactive (list (completing-read "Move to slip-box: "
(mapcar (lambda (x) (nth 2 x)) rasen/slip-boxes))))
(let* ((filename (buffer-file-name))
(directory (file-name-directory filename))
(name (file-name-nondirectory filename))
(new-name (f-join org-roam-directory slip-box name)))
(rasen/roam-rename new-name)))

;; TODO: with org-roam-v2 this probably can be simplified
(defun rasen/roam-rename (new-name)
"Move file to NEW-NAME. `org-roam' takes care of adjusting all links."
(let ((filename (buffer-file-name)))
(unless filename
(error "Buffer '%s' is not visiting file!" (buffer-name)))
(rename-file filename new-name)
(set-visited-file-name new-name t)
(revert-buffer t t t)
;; trigger save-buffer for org-roam to regenerate `org-roam-buffer'.
(set-buffer-modified-p t)
(save-buffer)))
#+end_src

And some extra refile helpers for dealing with inbox.
#+name: org-roam-slip-boxes
#+begin_src emacs-lisp :tangle no
;; TODO: replace hard-coded paths with querying org-roam by title.

(defun rasen/refile-weight ()
"Refile current item as weight log."
(interactive)
(save-excursion
(save-window-excursion
(rasen/org-copy-log-entry t)
(find-file (concat org-roam-directory "/life/20200620011908.org"))
(goto-char (point-max))
(yank))))

(defun rasen/refile-gratitude ()
(interactive)
(save-excursion
(save-window-excursion
(let* ((element (org-element-at-point))
(created (org-element-property :CREATED element))
(cbeg (org-element-property :contents-begin element))
(cend (org-element-property :contents-end element))
(contents (buffer-substring cbeg cend)))
(org-cut-subtree)
(current-kill 1)

(find-file (concat org-roam-directory "/life/20200620010632.org"))
(org-datetree-find-date-create
(calendar-gregorian-from-absolute
(time-to-days (org-read-date nil t created))))

(next-line)
(insert contents)))))
#+end_src
*** org-roam-node-display
Configure how nodes are shown in the prompt (when searching, creating new, inserting link).

Show slip box and path within file. e.g., =(life) My file > sub-note=.
#+name: org-roam-node-display
#+begin_src emacs-lisp :tangle no
(setq org-roam-node-display-template "${hierarchy:*} ${tags:10}")

(defun org-roam-node-filetitle (node)
"Return the file TITLE for the node."
(org-roam-get-keyword "TITLE" (org-roam-node-file node)))

(defun org-roam-node-hierarchy (node)
"Return the hierarchy for the node."
(let ((title (org-roam-node-title node))
(olp (org-roam-node-olp node))
(level (org-roam-node-level node))
(directories (org-roam-node-directories node))
(filetitle (org-roam-node-filetitle node)))
(concat
(if directories (format "(%s) " directories))
(if (> level 0) (concat filetitle " > "))
(if (> level 1) (concat (string-join olp " > ") " > "))
title)))

(defun org-roam-node-directories (node)
(if-let ((dirs (file-name-directory (file-relative-name (org-roam-node-file node) org-roam-directory))))
(string-join (f-split dirs) "/")
nil))

;; (cl-defmethod org-roam-node-filetitle ((node org-roam-node))
;; "Return the file TITLE for the node."
;; (org-roam-get-keyword "TITLE" (org-roam-node-file node)))

;; (cl-defmethod org-roam-node-hierarchy ((node org-roam-node))
;; "Return the hierarchy for the node."
;; (let ((title (org-roam-node-title node))
;; (olp (org-roam-node-olp node))
;; (level (org-roam-node-level node))
;; (directories (org-roam-node-directories node))
;; (filetitle (org-roam-node-filetitle node)))
;; (concat
;; (if directories (format "(%s) " directories))
;; (if (> level 0) (concat filetitle " > "))
;; (if (> level 1) (concat (string-join olp " > ") " > "))
;; title)))

;; (cl-defmethod org-roam-node-directories ((node org-roam-node))
;; (if-let ((dirs (file-name-directory (file-relative-name (org-roam-node-file node) org-roam-directory))))
;; (string-join (f-split dirs) "/")
;; nil))
#+end_src
*** org-roam-buffer
Configure org-roam-buffer (buffer with backlinks).

Show all sections:
#+name: org-roam-buffer
#+begin_src emacs-lisp :tangle no
(setq org-roam-mode-section-functions
(list #'org-roam-backlinks-section
#'org-roam-reflinks-section
#'org-roam-unlinked-references-section))
#+end_src

Make it prettier—enable word-wrap and variable pitch font.
#+name: org-roam-buffer
#+begin_src emacs-lisp :tangle no
(add-hook 'org-roam-mode-hook #'visual-line-mode)
(add-hook 'org-roam-mode-hook #'variable-pitch-mode)
#+end_src
*** org-roam-dailies

I moved my journaling into org-roam and this provides more context when reviewing my notes (unlinked references show where that date was mentioned).

All daily notes are stored in a separate directory so they do not mix up with normal notes. Nothing fancy here.
#+name: org-roam-dailies
#+begin_src emacs-lisp :tangle no
(require 'org-roam-dailies)
(setq org-roam-dailies-directory "life/journal/")
(setq org-roam-dailies-capture-templates
`(("j" "journal" plain "%U\n%?"
:if-new (file+head "%<%Y-%m-%d>.org"
;; Adding day of week to title makes
;; unlinked references search weaker, so
;; store it in metadata.
,(concat
"#+TITLE: %<%Y-%m-%d>\n"
"- day of week :: %<%A>\n"
"\n"
;; "* Events\n"
;; "* Decisions\n"
;; "* Tomorrow\n"
)))))
#+end_src
*** org-roam-protocol
org-roam-protocol allows opening a note corresponding to the current URL directly from the browser (as well as capturing selection into it).

First, add the following snippet as a bookmarklet:
#+begin_src js
javascript:location.href = 'org-protocol://roam-ref?' + new URLSearchParams({
template: 'r',
ref: location.href.split('#')[0],
title: encodeURIComponent(document.title),
body: encodeURIComponent(window.getSelection())
})
#+end_src

Firefox is annoying with asking permissions to allow =org-protocol= urls, but you can disable that if you go to [[about:config]] and toggle =security.external_protocol_requires_permission= off (only if you know what you’re doing).

Configure template. ~rasen/capture-quote-body~ bit inserts the selection as a quote if something is selected and does nothing otherwise.
#+name: org-roam-protocol
#+begin_src emacs-lisp :tangle no
(require 'org-roam-protocol)

(setq org-roam-capture-ref-templates
`(("r" "ref" plain "%(rasen/capture-quote-body)%?"
:if-new (file+head "biblio/${rasen/capture-tsid}.org"
,(concat "#+TITLE: ${title}\n"
"#+DATE: %<%Y-%m-%d>\n"))
:empty-lines 1
:immediate-finish t
:jump-to-captured t
:unnarrowed t)))

(defun rasen/capture-quote-body ()
"Quote selection only if it is present."
(let ((body (plist-get org-roam-capture--info :body)))
(when (not (string-empty-p body))
(concat "#+begin_quote\n" body "\n#+end_quote"))))
#+end_src

When I take notes on the page, I want the note to be open in a split window. I also don’t want to be in the capture process, because you quickly get into recursive capture and it just takes extra time to quit them. ~:immediate-finish~ and ~:jump-to-captured~ do that. However, because I’m on EXWM, the default behavior for ~:jump-to-capture~ is to open the note in the /current/ window, which is my browser.

I patch ~org-goto-marker-or-bmk~ so that it does not necessarily use the same window. This is used for
org-roam-capture-ref to open the new note in a split window instead of reusing the browser window.
(This might cause some other parts of org-mode to behave weirdly, but I have to see.)
#+name: org-roam-protocol
#+begin_src emacs-lisp :tangle no
(el-patch-defun org-goto-marker-or-bmk (marker &optional bookmark)
"Go to MARKER, widen if necessary. When marker is not live, try BOOKMARK."
(if (and marker (marker-buffer marker)
(buffer-live-p (marker-buffer marker)))
(progn
((el-patch-swap pop-to-buffer-same-window pop-to-buffer) (marker-buffer marker))
(when (or (> marker (point-max)) (< marker (point-min)))
(widen))
(goto-char marker)
(org-show-context 'org-goto))
(if bookmark
(bookmark-jump bookmark)
(error "Cannot find location"))))
#+end_src
*** org-roam-graph
Install graphviz globally:
#+name: home-manager-section
#+begin_src nix
{
home.packages = [ pkgs.graphviz ];
}
#+end_src

Emacs configuration:
#+name: org-roam-graph
#+begin_src emacs-lisp :tangle no
(require 'org-roam-graph)

;; better defaults for graph view
;; (setq org-roam-graph-executable (executable-find "dot"))
;; (setq org-roam-graph-executable (executable-find "neato"))
;; (setq org-roam-graph-executable (executable-find "fdp"))
(setq org-roam-graph-executable (executable-find "sfdp"))
(setq org-roam-graph-extra-config '(("concentrate" . "true")
("overlap" . "prism100")
("overlap_scaling" . "-8")
;; ("pack" . "true")
("sep" . "20.0")
("esep" . "0.0")
;; ("esep" . "0.01")
;; ("splines" . "true")
("splines" . "polyline")
))

(setq org-roam-graph-node-extra-config
'(("id"
("shape" . "rectangle")
("style" . "bold,rounded,filled")
("fillcolor" . "#EEEEEE")
("color" . "#C9C9C9")
("fontcolor" . "#111111"))
("http"
("style" . "rounded,filled")
("fillcolor" . "#EEEEEE")
("color" . "#C9C9C9")
("fontcolor" . "#0A97A6"))
("https"
("shape" . "rounded,filled")
("fillcolor" . "#EEEEEE")
("color" . "#C9C9C9")
("fontcolor" . "#0A97A6"))))
(setq org-roam-graph-edge-extra-config nil)

<>
#+end_src
**** org-roam-graph-exclude-node
Patch org-roam to allow a custom function to exclude nodes.
#+name: org-roam-graph-exclude-node
#+begin_src emacs-lisp :tangle no
(require 'cl)
(require 'el-patch)

(defvar rasen/org-roam-graph-exclude-node (lambda (id node type) nil)
"Function to exclude nodes from org-roam-graph.")

(defun rasen/org-roam-graph--filter-edges (edges &optional nodes-table)
(let ((nodes-table (or nodes-table (org-roam--nodes-table))))
(seq-filter (pcase-lambda (`(,source ,dest ,type))
(let ((source-node (gethash source nodes-table))
(dest-node (gethash dest nodes-table)))
(not (or (funcall rasen/org-roam-graph-exclude-node source source-node "id")
(funcall rasen/org-roam-graph-exclude-node dest dest-node type)))))
edges)))

(el-patch-defun org-roam-graph--dot (&optional edges all-nodes)
"Build the graphviz given the EDGES of the graph.
If ALL-NODES, include also nodes without edges."
(let ((org-roam-directory-temp org-roam-directory)
(nodes-table (org-roam--nodes-table))
(seen-nodes (list))
(edges (el-patch-let (($orig (or edges (org-roam-db-query [:select :distinct [source dest type] :from links]))))
(el-patch-swap
$orig
(rasen/org-roam-graph--filter-edges $orig)))))
(with-temp-buffer
(setq-local org-roam-directory org-roam-directory-temp)
(insert "digraph \"org-roam\" {\n")
(dolist (option org-roam-graph-extra-config)
(insert (org-roam-graph--dot-option option) ";\n"))
(insert (format " edge [%s];\n"
(mapconcat (lambda (var)
(org-roam-graph--dot-option var nil "\""))
org-roam-graph-edge-extra-config
",")))
(pcase-dolist (`(,source ,dest ,type) edges)
(unless (member type org-roam-graph-link-hidden-types)
(pcase-dolist (`(,node ,node-type) `((,source "id")
(,dest ,type)))
(unless (member node seen-nodes)
(insert (org-roam-graph--format-node
(or (gethash node nodes-table) node) node-type))
(push node seen-nodes)))
(insert (format " \"%s\" -> \"%s\";\n"
(xml-escape-string source)
(xml-escape-string dest)))))
(when all-nodes
(maphash (lambda (id node)
(unless (el-patch-let (($orig (member id seen-nodes)))
(el-patch-swap
$orig
(or $orig
(funcall rasen/org-roam-graph-exclude-node id node "id"))))
(insert (org-roam-graph--format-node node "id"))))
nodes-table))
(insert "}")
(buffer-string))))
#+end_src

Exclude all links that are not nodes (non-id) as well as links from non-permanent directories.
#+name: org-roam-graph-exclude-node
#+begin_src emacs-lisp :tangle no
(setq rasen/org-roam-graph-exclude-node
(defun rasen/org-roam-graph-exclude-node (id node type)
(or (not (string-equal type "id"))
(and node
(string-match "/\\(life\\|biblio\\)/" (org-roam-node-file node))))))
#+end_src
*** org-roam-kebab-slugs
Patch slug function so it uses kebab-case instead of snake-case.
#+name: org-roam-kebab-slugs
#+begin_src emacs-lisp :tangle no
(el-patch-defun org-roam-node-slug (node)
"Return the slug of NODE."
(let ((title (org-roam-node-title node))
(slug-trim-chars '(;; Combining Diacritical Marks https://www.unicode.org/charts/PDF/U0300.pdf
768 ; U+0300 COMBINING GRAVE ACCENT
769 ; U+0301 COMBINING ACUTE ACCENT
770 ; U+0302 COMBINING CIRCUMFLEX ACCENT
771 ; U+0303 COMBINING TILDE
772 ; U+0304 COMBINING MACRON
774 ; U+0306 COMBINING BREVE
775 ; U+0307 COMBINING DOT ABOVE
776 ; U+0308 COMBINING DIAERESIS
777 ; U+0309 COMBINING HOOK ABOVE
778 ; U+030A COMBINING RING ABOVE
780 ; U+030C COMBINING CARON
795 ; U+031B COMBINING HORN
803 ; U+0323 COMBINING DOT BELOW
804 ; U+0324 COMBINING DIAERESIS BELOW
805 ; U+0325 COMBINING RING BELOW
807 ; U+0327 COMBINING CEDILLA
813 ; U+032D COMBINING CIRCUMFLEX ACCENT BELOW
814 ; U+032E COMBINING BREVE BELOW
816 ; U+0330 COMBINING TILDE BELOW
817 ; U+0331 COMBINING MACRON BELOW
)))
(cl-flet* ((nonspacing-mark-p (char)
(memq char slug-trim-chars))
(strip-nonspacing-marks (s)
(ucs-normalize-NFC-string
(apply #'string (seq-remove #'nonspacing-mark-p
(ucs-normalize-NFD-string s)))))
(cl-replace (title pair)
(replace-regexp-in-string (car pair) (cdr pair) title)))
(let* ((pairs `(el-patch-swap (("[^[:alnum:][:digit:]]" . "_") ;; convert anything not alphanumeric
("__*" . "_") ;; remove sequential underscores
("^_" . "") ;; remove starting underscore
("_$" . "")) ;; remove ending underscore
(("[^[:alnum:][:digit:]]" . "-") ;; convert anything not alphanumeric
("--*" . "-") ;; remove sequential dashes
("^-" . "") ;; remove starting dash
("-$" . "")))) ;; remove ending dash
(slug (-reduce-from #'cl-replace (strip-nonspacing-marks title) pairs)))
(downcase slug)))))
#+end_src
*** org-roam-update-ids
A helper function for the next time org-id fucks up its database.
#+name: org-roam-update-ids
#+begin_src emacs-lisp :tangle no
(defun rasen/org-roam-update-ids ()
"Update all org-ids in org-roam-directory."
(interactive)
(org-id-update-id-locations
(directory-files-recursively org-roam-directory "\\.org$")))
#+end_src
*** org-roam-new-node
A function to create a new node without prompting for a title. Sometimes I want to create a new node and I am not sure what the title will be—I discover it while I write the note.
#+name: org-roam-new-node
#+begin_src emacs-lisp
(defun rasen/org-roam-new-node (&optional keys)
(interactive)
(org-roam-capture-
:keys keys
:node (org-roam-node-create :title "")
:props '(:finalize find-file)))

(defun rasen/org-roam-new-node-default ()
(interactive)
(rasen/org-roam-new-node "d"))

(defun rasen/org-roam-new-node-life ()
(interactive)
(rasen/org-roam-new-node "l"))

(defun rasen/org-roam-new-node-pulse ()
(interactive)
(rasen/org-roam-new-node "P"))

(defun rasen/org-roam-new-node-fluxon ()
(interactive)
(rasen/org-roam-new-node "f"))

;; (s-leader-def "n n" #'rasen/org-roam-new-node)
;; (s-leader-def "n d" #'rasen/org-roam-new-node-default)
;; (s-leader-def "n l" #'rasen/org-roam-new-node-life)
;; (s-leader-def "n p" #'rasen/org-roam-new-node-pulse)
;; (s-leader-def "n F" (defun rasen/org-roam-new-node-fluxon ()
;; (interactive)
;; (rasen/org-roam-new-node "f")))
#+end_src
*** org-roam-update-title
#+name: org-roam-update-title
#+begin_src emacs-lisp
;; TODO: this only handles file renames. Make it work for headline nodes too.
(defun rasen/org-roam-title-update ()
"Update the title of the current node and patch all incoming links."
(interactive)
(save-restriction
(save-excursion
(goto-char (point-min))
(let* ((old-node (org-roam-node-at-point))
(old-title (and old-node (org-roam-node-title old-node)))
(old-id (and old-node (org-roam-node-id old-node)))
(new-title (cdar (org-collect-keywords '("title") '("title")))))
(when (and old-title (not (string-equal old-title new-title)))
(message "renaming: %s -> %s" old-title new-title)
(let ((files (org-roam-db-query [:select (unique file)
:from links
:inner-join nodes
:on (= links:source nodes:id)
:where (= dest $s1)
:and (= type "id")]
old-id))
(replace-re (rx "[[id:"
(literal old-id)
"]["
(literal old-title)
"]"))
(new-link (concat "[[id:" old-id "][" new-title "]")))
(mapc (pcase-lambda (`(,file))
(with-current-buffer (find-file-noselect file)
(goto-char (point-min))
(while (re-search-forward replace-re nil t)
(replace-match new-link))))
files)))))))

(add-hook 'org-mode-hook
(defun rasen/setup-title-hook ()
(add-hook 'before-save-hook #'rasen/org-roam-title-update 0 t)
(add-hook 'after-save-hook #'org-roam-db-update-file 0 t)))
#+end_src
** org-roam-ui
#+begin_src emacs-lisp
(use-package org-roam-ui
:after org-roam
:commands (org-roam-ui-mode)
:config
(setq org-roam-ui-update-on-save t
org-roam-ui-sync-theme nil
org-roam-ui-open-on-start t))
#+end_src
** org-ref
#+begin_src emacs-lisp
(use-package ivy-bibtex
:config
(push (cons 'org-mode #'bibtex-completion-format-citation-org-cite) bibtex-completion-format-citation-functions)
(defun rasen/ivy-cite ()
(interactive)
(let ((ivy-bibtex-default-action #'ivy-bibtex-insert-citation))
(call-interactively #'ivy-bibtex))))

(use-package oc
:config
(let* ((bib-file-name '("books.bib" "papers.bib" "online.bib"))
(bib-directory (expand-file-name "roam/biblio/" org-directory))
(bib-files-directory (expand-file-name "files/" bib-directory))
(bib-files (mapcar (lambda (x) (expand-file-name x bib-directory)) bib-file-name)))

(setq org-cite-global-bibliography bib-files)

(setq reftex-default-bibliography bib-files)
;; (setq org-ref-default-bibliography bib-files)
(setq bibtex-completion-bibliography bib-files)

;; (setq org-ref-bibliography-notes bib-directory)
(setq bibtex-completion-notes-path bib-directory)

;; (setq org-ref-pdf-directory bib-files-directory)
(setq bibtex-completion-library-path `(,bib-files-directory)))

(setq bibtex-completion-pdf-open-function
(defun rasen/find-file-external (filename)
(start-process filename nil
(if (eq system-type 'darwin) "open" "xdg-open") (expand-file-name filename)))))

(use-package org-ref
;; :after org-roam
:config

(require 'org-ref-ivy)

(require 'org-ref-url-utils)
(require 'org-ref-isbn)
(general-def 'normal 'bibtex-mode-map
"C-c C-c" #'org-ref-clean-bibtex-entry
"C-c c" #'org-ref-clean-bibtex-entry
"C-c s" #'bibtex-sort-buffer
"C-c n" #'org-ref-open-bibtex-notes

;; (a)ttach pdf
"C-c a" #'org-ref-bibtex-assoc-pdf-with-entry
"C-c f" #'org-ref-bibtex-pdf

;; (o)nline
"C-c o" #'org-ref-url-html-to-bibtex
"C-c i" #'isbn-to-bibtex)

(setq org-ref-completion-library 'org-ref-ivy-cite)

(setq org-ref-insert-cite-function
(lambda ()
(org-cite-insert nil)))

;; Rules for automatic key generation
(setq bibtex-autokey-year-length 4
bibtex-autokey-name-year-separator ""
bibtex-autokey-year-title-separator "-"
bibtex-autokey-titleword-separator "-"
bibtex-autokey-titlewords 5
bibtex-autokey-titlewords-stretch 1
bibtex-autokey-titleword-length 5)

(setq bibtex-dialect 'biblatex)

;; `isbn-to-bibtex' fails with "(wrong-type-argument stringp nil)"
;; error down in `org-ref-isbn-clean-bibtex-entry' functions. This
;; happens because temporary buffer is not in `bibtex-mode', so
;; `bibtex-entry-head' variable is not set.
;;
;; Prepend `bibtex-mode' to the list of processors, so the next ones
;; work correctly.
(add-hook 'org-ref-isbn-clean-bibtex-entry-hook #'bibtex-mode)

;; Do not fill entries. (It works badly with urls.)
(el-patch-defun bibtex-fill-field-bounds (bounds justify &optional move)
"Fill BibTeX field delimited by BOUNDS.
If JUSTIFY is non-nil justify as well.
If optional arg MOVE is non-nil move point to end of field."
(let ((end-field (copy-marker (bibtex-end-of-field bounds))))
(if (not justify)
(goto-char (bibtex-start-of-text-in-field bounds))
(goto-char (bibtex-start-of-field bounds))
(forward-char) ; leading comma
(bibtex-delete-whitespace)
(insert "\n")
(indent-to-column (+ bibtex-entry-offset
bibtex-field-indentation))
(re-search-forward "[ \t\n]*=" end-field)
(replace-match "=")
(forward-char -1)
(if bibtex-align-at-equal-sign
(indent-to-column
(+ bibtex-entry-offset (- bibtex-text-indentation 2)))
(insert " "))
(forward-char)
(bibtex-delete-whitespace)
(if bibtex-align-at-equal-sign
(insert " ")
(indent-to-column bibtex-text-indentation)))
(el-patch-remove
;; Paragraphs within fields are not preserved. Bother?
(fill-region-as-paragraph (line-beginning-position) end-field
default-justification nil (point)))
(if move (goto-char end-field)))))
#+end_src
** org-ref-cite
#+begin_src emacs-lisp
;; (use-package citeproc)
;;
;; (use-package oc
;; :config
;; (require 'oc-csl))
;;
;; (use-package org-ref-cite
;; :after org-ref
;; :config
;; (setq org-cite-global-bibliography bibtex-completion-bibliography
;; org-cite-insert-processor 'org-ref-cite
;; org-cite-follow-processor 'org-ref-cite
;; org-cite-activate-processor 'org-ref-cite)
;;
;; ;; blatantly re-define function to suppress errors
;; (defun org-ref-cite-activate (&rest args)
;; "Run all the activation functions in `org-ref-cite-activation-functions'.
;; Argument CITATION is an org-element holding the references."
;; (cl-loop for activate-func in org-ref-cite-activation-functions
;; do
;; (ignore-error wrong-number-of-arguments (apply activate-func args))))
;;
;; (defadvice org-activate-links (around org-activate-links-ignore-errors)
;; "Ignore errors in `org-activate-links'."
;; (ignore-error wrong-number-of-arguments ad-do-it))
;; ;; (ad-deactivate 'org-activate-links)
;; (ad-activate 'org-activate-links))

#+end_src
** org-roam-bibtex
Citations and bibliography tools for org-mode.
#+begin_src emacs-lisp
(use-package org-roam-bibtex
:diminish
:after org-roam
:config
(require 'org-ref)
(org-roam-bibtex-mode))
#+end_src
** toc-org
Generate Table of Contents for this file.

#+begin_src emacs-lisp
(use-package toc-org
:commands (toc-org-mode toc-org-insert-toc))
#+end_src
** org-fc
Flashcards/spaced repetition system for org-mode. It works with many files better than org-drill (and many files is what I have with org-roam).

Install required dependencies:
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.findutils
pkgs.gawk
];
}
#+end_src

#+begin_src emacs-lisp
(use-package org-fc
:config
(require 'org-fc-keymap-hint)

(setq org-fc-directories (list (expand-file-name "roam" rasen/org-directory)))
(setq org-fc-review-history-file (expand-file-name "org-fc-history.tsv" rasen/org-directory))

;; (setq org-fc-stats-review-min-box 2)

;; (el-patch-defun org-fc-index-flatten-card (card)
;; "Flatten CARD into a list of positions.
;; Relevant data from the card is included in each position
;; element."
;; (mapcar
;; (lambda (pos)
;; (list
;; :filetitle (plist-get card :filetitle)
;; :tags (plist-get card :tags)
;; :path (plist-get card :path)
;; :id (plist-get card :id)
;; (el-patch-add :suspended (plist-get card :suspended))
;; :type (plist-get card :type)
;; :due (plist-get pos :due)
;; :position (plist-get pos :position)))
;; (plist-get card :positions)))

(defun rasen/org-fc-index-positions (cards)
(mapcan (lambda (card) (org-fc-index-flatten-card card)) cards))

(defun rasen/org-fc-upcoming-histogram (&optional context)
"Draw a histogram of upcoming review."
(interactive (list (org-fc-select-context)))
(let* ((positions (seq-filter (lambda (x)
(not (plist-get x :suspended)))
(rasen/org-fc-index-positions (org-fc-index (or context 'all)))))
(total (length positions))
(sorted (seq-sort
(lambda (x y) (time-less-p
(plist-get x :due)
(plist-get y :due)))
positions))
(next-review (plist-get (car sorted) :due))
(next-review-diff (time-to-seconds (time-subtract next-review nil)))
(grouped (seq-group-by
(lambda (x)
(format-time-string "%F" (plist-get x :due)))
sorted))
(grouped-count (mapcar (lambda (x)
(cons (car x) (length (cdr x))))
grouped)))
(with-output-to-temp-buffer "*org-fc-upcoming*"
(princ (format-time-string "Next review: %F %T" next-review))
(if (> next-review-diff 0)
(princ (format " (in %s)\n" (format-seconds "%D %H %z%M" next-review-diff)))
(princ " (ready)\n"))
(princ (format "Total positions: %s\n\n" total))
(princ "Upcoming reviews:\n")
(mapc
(lambda (x)
(princ (car x))
(princ (format " %3s " (cdr x)))
(princ (make-string (cdr x) ?+))
(princ "\n"))
grouped-count))
(switch-to-buffer-other-window "*org-fc-upcoming*")))

(general-define-key
:definer 'minor-mode
:states 'normal
:keymaps 'org-fc-review-flip-mode
"RET" 'org-fc-review-flip
"n" 'org-fc-review-flip
"s" 'org-fc-review-suspend-card
"q" 'org-fc-review-quit)

(general-define-key
:definer 'minor-mode
:states 'normal
:keymaps 'org-fc-review-rate-mode
"a" 'org-fc-review-rate-again
"h" 'org-fc-review-rate-hard
"g" 'org-fc-review-rate-good
;; There seems to be an issue binding "g" and it still behaves as
;; a prefix for other commands in rate mode.
;;
;; Bind `org-fc-review-rate-good' to "n" as well to workaround
;; this.
"n" 'org-fc-review-rate-good
"e" 'org-fc-review-rate-easy
"s" 'org-fc-review-suspend-card
"q" 'org-fc-review-quit)

(general-def 'normal 'org-fc-review-edit-mode-map
"'" #'org-fc-review-resume)

(general-def 'normal 'org-fc-dashboard-mode-map
"r" #'org-fc-dashboard-review
"g" (defun rasen/org-fc-dashboard ()
(interactive)
(org-fc-dashboard org-fc-context-all))
"h" #'rasen/org-fc-upcoming-histogram
"q" #'quit-window)

<>)
#+end_src

** COMMENT org-fc review todos
My modifications to support reviewing arbitrary todo lists with spaced repetition.
#+name: org-fc-review-todos
#+begin_src emacs-lisp
(defcustom rasen/org-fc-todos-context `(:paths (,(expand-file-name "resources.org" rasen/org-directory))
:filter (type "nocard"))
"Context in which to search for todo cards.")

(defcustom rasen/org-fc-writing-inbox-context `(:paths ("~/org/roam/life/20200907034408.org")
:filter (type "nocard"))
"Context in which to search for writing inbox cards.")

;; override all to exclude nocard
(setq org-fc-context-all '(:paths all
:filter (not (type "nocard"))))
(setq org-fc-context-dashboard org-fc-context-all)

(defvar rasen/org-fc-todos-current-context rasen/org-fc-todos-context)

;; Special org-fc card type with no flipping
(defun org-fc-type-nocard-init ()
"Mark headline as a no-card."
(interactive)
(org-fc--init-card "nocard")
(org-fc-review-data-update '("single")))

(defun org-fc-type-nocard-setup (_position)
"Prepare a no-card for review."
(interactive)
(org-fc-noop))

(org-fc-register-type
'nocard
#'org-fc-type-nocard-setup
#'org-fc-noop
#'org-fc-noop)

(defvar rasen/org-fc-todos-current-card nil)
(defun rasen/org-fc-todos-next-card ()
"Present a single card from the current buffer for review."
(interactive)
(save-buffer)
(let* ((index (org-fc-index rasen/org-fc-todos-current-context))
(cards (org-fc-index-filter-due index))
(positions (org-fc-index-shuffled-positions cards)))
(if (null positions)
(progn
(message "No todos due right now")
(setq rasen/org-fc-todos-current-card nil)
(setq hydra-deactivate t))
(rasen/org-fc-todos-present-position (car positions)))))

(defun rasen/org-fc-todos-present-position (card)
(let* ((path (plist-get card :path))
(id (plist-get card :id))
(type (plist-get card :type))
(position (plist-get card :position)))
(let ((buffer (find-buffer-visiting path)))
(with-current-buffer (find-file path)
(goto-char (point-min))
(org-fc-id-goto id path)
(org-reveal)

(setq rasen/org-fc-todos-current-card card)
(setq org-fc-timestamp (time-to-seconds (current-time)))))))

(el-patch-defun (el-patch-swap org-fc-review-update-data rasen/org-fc-todos-review-update-data) (path id position rating delta)
"Update the review data of the card.
Also add a new entry in the review history file. PATH, ID,
POSITION identify the position that was reviewed, RATING is a
review rating and DELTA the time in seconds between showing and
rating the card."
(org-fc-with-point-at-entry
;; If the card is marked as a demo card, don't log its reviews and
;; don't update its review data
(unless (member org-fc-demo-tag (org-get-tags))
(let* ((data (org-fc-get-review-data))
(current (assoc position data #'string=)))
(unless current
(error "No review data found for this position"))
(let ((ease (string-to-number (cl-second current)))
(box (string-to-number (cl-third current)))
(interval (string-to-number (cl-fourth current))))
(el-patch-remove (org-fc-review-history-add
(list
(org-fc-timestamp-now)
path
id
position
(format "%.2f" ease)
(format "%d" box)
(format "%.2f" interval)
(symbol-name rating)
(format "%.2f" delta)
(symbol-name org-fc-algorithm))))
(cl-destructuring-bind (next-ease next-box next-interval)
(org-fc-sm2-next-parameters ease box interval rating)
(setcdr
current
(list (format "%.2f" next-ease)
(number-to-string next-box)
(format "%.2f" next-interval)
(org-fc-timestamp-in next-interval)))
(org-fc-set-review-data data)))))))

(defun rasen/org-fc-todos-rate (rating)
"Rate the card at point with RATING."
(if-let ((card rasen/org-fc-todos-current-card))
(if (string= (plist-get card :id) (org-id-get))
(let* ((path (plist-get card :path))
(id (plist-get card :id))
(position (plist-get card :position))
(now (time-to-seconds (current-time)))
(delta (- now org-fc-timestamp)))
(rasen/org-fc-todos-review-update-data path id position rating delta)
(rasen/org-fc-todos-next-card))
(message "Flashcard ID mismatch"))
(message "No todos review is in progress")))
(defun rasen/org-fc-todos-rate-soon ()
(interactive)
(rasen/org-fc-todos-rate 'hard))
(defun rasen/org-fc-todos-rate-normal ()
(interactive)
(rasen/org-fc-todos-rate 'good))
(defun rasen/org-fc-todos-rate-later ()
(interactive)
(rasen/org-fc-todos-rate 'easy))
(defun rasen/org-fc-todos-today ()
(interactive)
(save-excursion
(rasen/org-fc-todos-rate 'again))
(save-excursion
(rasen/org-do-today))
(save-buffer)
(rasen/org-fc-todos-next-card))

(defun rasen/org-fc-todos-suspend ()
(interactive)
(org-fc-suspend-card)
(save-buffer)
(rasen/org-fc-todos-next-card))

(defun rasen/org-fc-todos-delete ()
(interactive)
(org-cut-subtree)
(save-buffer)
(rasen/org-fc-todos-next-card))

(defun rasen/org-fc-todos-update-fc ()
(when (member org-fc-flashcard-tag (org-get-tags nil 'local))
(cond
((string= "NEXT" org-state) (org-toggle-tag org-fc-suspended-tag 'on))
((string= "TODO" org-state) (org-toggle-tag org-fc-suspended-tag 'off))
((string= "DONE" org-state) (org-toggle-tag org-fc-suspended-tag 'on)))))

(add-hook 'org-after-todo-state-change-hook #'rasen/org-fc-todos-update-fc)

(defun rasen/org-fc-todos-estimate-next-interval (rating)
(condition-case err
(org-fc-with-point-at-entry
(let* ((data (org-fc-get-review-data))
(current (assoc (plist-get rasen/org-fc-todos-current-card :position) data #'string=)))
(let ((ease (string-to-number (cl-second current)))
(box (string-to-number (cl-third current)))
(interval (string-to-number (cl-fourth current))))
(cl-destructuring-bind (next-ease next-box next-interval) (org-fc-sm2-next-parameters ease box interval rating)
next-interval))))
(error 0)))

(defun rasen/org-fc-todos-hydra-hint (name rating)
(format "%s (%.2f days)" name (rasen/org-fc-todos-estimate-next-interval rating)))

(defhydra rasen/hydra-todos-review ()
"todos review"
("q" nil "quit")
("s" #'rasen/org-fc-todos-rate-soon (rasen/org-fc-todos-hydra-hint "soon" 'hard))
("n" #'rasen/org-fc-todos-rate-normal (rasen/org-fc-todos-hydra-hint "normal" 'good))
("l" #'rasen/org-fc-todos-rate-later (rasen/org-fc-todos-hydra-hint "later" 'easy))
("o" #'org-open-at-point "open")
("t" #'rasen/org-fc-todos-today "today")
("S" #'rasen/org-fc-todos-suspend "suspend")
("d" #'rasen/org-fc-todos-delete "delete"))

(defun rasen/org-fc-todos-review-with-context (ctx)
(setq rasen/org-fc-todos-current-context ctx)
(rasen/org-fc-todos-next-card)
(when rasen/org-fc-todos-current-card
(rasen/hydra-todos-review/body)))

(defun rasen/todos-review ()
(interactive)
(rasen/org-fc-todos-review-with-context rasen/org-fc-todos-context))

(defun rasen/writing-review ()
(interactive)
(rasen/org-fc-todos-review-with-context rasen/org-fc-writing-inbox-context))
#+end_src
** toggle markup/view
#+begin_src emacs-lisp
(defun rasen/toggle-org-view-mode (arg)
(interactive "P")
;; partially stolen from `org-toggle-link-display'
(if org-link-descriptive
(progn
(remove-from-invisibility-spec '(org-link))
(setq-local org-hide-emphasis-markers nil)
(setq-local org-pretty-entities nil)
(org-clear-latex-preview (point-min) (point-max))
(org-remove-inline-images)
(valign-mode -1)
(when arg
(org-variable-pitch-minor-mode -1)
(valign-mode -1))
(message "org-view-mode disabled"))

(add-to-invisibility-spec '(org-link))
(setq org-hide-emphasis-markers t)
(setq-local org-pretty-entities t)
(org--latex-preview-region (point-min) (point-max))
(org-display-inline-images)
(org-variable-pitch-minor-mode t)
(valign-mode t)
(message "org-view-mode enabled"))
(setq-local org-link-descriptive (not org-link-descriptive))
(font-lock-fontify-buffer))

(leader-def 'normal 'org-mode-map
"\\" #'rasen/toggle-org-view-mode)
#+end_src
** Evilify org-mode
#+begin_src emacs-lisp
(use-package evil-org
:disabled t
:after org
:diminish
:init
;; https://github.com/Somelauw/evil-org-mode/issues/93
(fset 'evil-redirect-digit-argument 'ignore)

:custom
;; https://github.com/Somelauw/evil-org-mode/issues/93
(add-to-list 'evil-digit-bound-motions 'evil-org-beginning-of-line)
(evil-define-key 'motion 'evil-org-mode
(kbd "0") 'evil-org-beginning-of-line)

;; swap j/k
(evil-org-movement-bindings '((up . "j")
(down . "k")
(left . "h")
(right . "l")))
:config
(add-hook 'org-mode-hook 'evil-org-mode)
(add-hook 'evil-org-mode-hook
(lambda ()
(evil-org-set-key-theme)))
(require 'evil-org-agenda)
(evil-org-agenda-set-keys)

;; when editing code blocks, use current window and do not
;; reorganize my frame
(setq org-src-window-setup 'current-window)

(general-def 'normal org-mode-map
"'" #'org-edit-special
"C-c '" (rasen/hard-way "'")
"go" #'org-open-at-point
"C-c C-o" (rasen/hard-way "go"))

;; open file links in the same window
(push '(file . find-file) org-link-frame-setup)

(general-def 'normal org-src-mode-map
"'" #'org-edit-src-exit
"C-c '" (rasen/hard-way "'"))

(general-def 'motion org-agenda-mode-map
"k" #'org-agenda-next-line
"j" #'org-agenda-previous-line
"gk" #'org-agenda-next-item
"gj" #'org-agenda-previous-item
"C-k" #'org-agenda-next-item
"C-j" #'org-agenda-previous-item

"K" #'org-agenda-priority-down
"J" #'org-agenda-priority-up

"M-k" #'org-agenda-drag-line-forward
"M-j" #'org-agenda-drag-line-backward)

(general-def 'motion org-agenda-mode-map
"SPC" nil ;; unset prefix
"go" #'org-agenda-open-link
"gl" #'org-agenda-log-mode)
(leader-def 'motion org-agenda-mode-map
"SPC" #'org-save-all-org-buffers
"s" #'org-agenda-schedule
"d" #'org-agenda-deadline
"w" #'rasen/org-refile-hydra/body
"t" #'rasen/org-agenda-todo))
#+end_src
Use emacs-state in org-lint buffers.
#+name: org-config
#+begin_src emacs-lisp
;;(evil-set-initial-state 'org-lint--report-mode 'emacs)
;;(evil-set-initial-state 'epa-key-list-mode 'emacs)
#+end_src
** Timestamps
Configure time-stamp for org-mode, so ~time-stamp~ command would update =#+LAST_MODIFIED:= or =#+DATE:= keyword value (whichever is found first) using ISO8601 format.
#+begin_src emacs-lisp
(use-package time-stamp
:config
(add-hook 'org-mode-hook
(defun rasen/set-time-stamp ()
(interactive)
;; Either DATE or LAST_MODIFIED—whichever comes first, wins.
(setq-local time-stamp-pattern "^#\\+\\(DATE\\|LAST_MODIFIED\\): %%$")
(setq-local time-stamp-format "%Y-%02m-%02dT%02H:%02M:%02S%5z"))))
#+end_src
** Fix focus steal when inserting “.” in date field
I have an issue with EXWM and org-mode: whenever I am asked to input a date (schedule, deadline) and I put dot (“.”) as a first character, it is not inserted and the focus is stolen to the tray icons and I have to manually refocus minibuffer to continue input.

I have debugged the issue to be caused by ~org-read-date-minibuffer-local-map~ binding for =.=, which is defined as:
#+begin_src emacs-lisp :tangle no
(org-defkey map (kbd ".")
(lambda () (interactive)
;; Are we at the beginning of the prompt?
(if (looking-back "^[^:]+: "
(let ((inhibit-field-text-motion t))
(line-beginning-position)))
(org-eval-in-calendar '(calendar-goto-today))
(insert "."))))
#+end_src

I am not sure how but the if-branch causes the issue. (Somehow, it causes mouse cursor to jump.) So… just redefine the binding:

#+name: org-config
#+begin_src emacs-lisp
(org-defkey org-read-date-minibuffer-local-map (kbd ".") #'self-insert-command)
#+end_src

With ~self-insert-command~, it works just fine. Well, the calendar doesn’t jump to today but who cares.

* Mail setup
My email load is handled by mbsync (to download email), msmtp (to send mail), and notmuch (to tag and browse it).

Applications are configured with Home Manager, and notmuch frontend is configured in Emacs.
** Applications
#+name: home-manager-section
#+begin_src nix
{
# Store mails in ~/Mail
accounts.email.maildirBasePath = "Mail";

accounts.email.accounts.as = {
realName = "Oleksii Shmalko";
address = "me@alexeyshmalko.com";
flavor = "plain";

userName = "me@alexeyshmalko.com";
imap.host = "imap.secureserver.net";
imap.port = 993;
imap.tls.enable = true;
smtp.host = "smtpout.secureserver.net";
smtp.port = 465;
smtp.tls.enable = true;

passwordCommand = "pass me@alexeyshmalko.com";
maildir.path = "alexeyshmalko";

msmtp.enable = true;
notmuch.enable = true;
mbsync.enable = true;
mbsync.create = "maildir";
};

# Use mbsync to fetch email. Configuration is constructed manually
# to keep my current email layout.
programs.mbsync = {
enable = true;
extraConfig = lib.mkBefore ''
MaildirStore local
Path ~/Mail/
Inbox ~/Mail/INBOX
SubFolders Verbatim
'';
};

# Notmuch for email browsing, tagging, and searching.
programs.notmuch = {
enable = true;
new.ignore = [
".mbsyncstate"
".mbsyncstate.lock"
".mbsyncstate.new"
".mbsyncstate.journal"
".uidvalidity"
"dovecot-uidlist"
"dovecot-keywords"
"dovecot.index"
"dovecot.index.log"
"dovecot.index.log.2"
"dovecot.index.cache"
"/^archive/"
];
};

# msmtp for sending mail
programs.msmtp.enable = true;

# My Maildir layout predates home-manager configuration, so I do not
# use mbsync config generation from home-manager, to keep layout
# compatible.
imports =
let
emails = [
{ name = "gmail"; email = "rasen.dubi@gmail.com"; path = "Personal"; primary = true; }
{ name = "ps"; email = "ashmalko@doctoright.org"; path = "protocolstandard"; }
{ name = "egoless"; email = "me@egoless.tech"; path = "egoless"; }
];
mkGmailBox = { name, email, path, ... }@all: {
accounts.email.accounts.${name} = {
realName = "Oleksii Shmalko";
address = email;
flavor = "gmail.com";

passwordCommand = "pass imap.gmail.com/${email}";
maildir.path = path;

msmtp.enable = true;
notmuch.enable = true;
} // (removeAttrs all ["name" "email" "path"]);

programs.mbsync.extraConfig = ''
IMAPAccount ${name}
Host imap.gmail.com
User ${email}
PassCmd "pass imap.gmail.com/${email}"
SSLType IMAPS
CertificateFile /etc/ssl/certs/ca-certificates.crt

IMAPStore ${name}-remote
Account ${name}

Channel sync-${name}-all
Far :${name}-remote:"[Gmail]/All Mail"
Near :local:${path}/all
Create Both
SyncState *

Channel sync-${name}-spam
Far :${name}-remote:"[Gmail]/Spam"
Near :local:${path}/spam
Create Both
SyncState *

Channel sync-${name}-sent
Far :${name}-remote:"[Gmail]/Sent Mail"
Near :local:${path}/sent
Create Both
SyncState *

Group sync-${name}
Channel sync-${name}-all
Channel sync-${name}-spam
Channel sync-${name}-sent

'';
};
in map mkGmailBox emails;
}
#+end_src
** Interface
#+begin_src emacs-lisp
(use-package notmuch
:config
;; (setq mm-text-html-renderer 'shr)

(setq notmuch-archive-tags '("-unread"))
(setq notmuch-saved-searches
'(
(:name "unread-inbox" :query "tag:inbox and tag:unread" :key "u")
;; (:name "unread" :query "tag:unread and not tag:nixos and not tag:rust" :key "u")
(:name "unread-egoless" :query "tag:egoless and tag:unread" :key "e")
(:name "unread-nixos" :query "tag:unread and tag:nixos and not tag:nixpkgs" :key "n")
(:name "unread-nixpkgs" :query "tag:unread and tag:nixpkgs" :key "p")
(:name "unread-participating" :query "tag:unread and tag:participating" :key "t")
(:name "unread-doctoright" :query "tag:unread and tag:doctoright" :key "d")
(:name "unread-rss" :query "tag:unread and tag:rss" :key "r")
(:name "unread-other" :query "tag:unread and not tag:nixos and not tag:inbox and not tag:doctoright and not tag:rss" :key "o")
(:name "later" :query "tag:later" :key "l")
(:name "flagged" :query "tag:flagged" :key "F")
(:name "personal" :query "tag:personal" :key "P")
(:name "doctoright" :query "tag:doctoright" :key "D")
(:name "sent" :query "tag:sent" :key "s")
(:name "drafts" :query "tag:draft" :key "f")
(:name "all mail" :query "*" :key "a")))
(setq notmuch-hello-sections
'(;; notmuch-hello-insert-header
notmuch-hello-insert-saved-searches
;; notmuch-hello-insert-search
notmuch-hello-insert-alltags
notmuch-hello-insert-recent-searches
;; notmuch-hello-insert-footer
))
(setq-default notmuch-show-indent-content nil)

(defun rasen/mbsync ()
(interactive)
(let ((mbsync-cmd (if (string= (system-name) "omicron")
"mbsync sync-gmail & r2e run & wait; /home/rasen/dotfiles/notmuch.sh"
"mbsync -a && ~/dotfiles/notmuch.sh")))
(async-shell-command mbsync-cmd "*mbsync*")))

;; bind q in shell to hide buffer
(general-def 'motion shell-mode-map
"q" #'quit-window)

(defun rasen/notmuch-search-mute ()
(interactive)
(notmuch-search-tag '("+muted"))
(notmuch-search-archive-thread))

(general-def notmuch-hello-mode-map "f" 'rasen/mbsync)

(general-def
:keymaps '(notmuch-hello-mode-map
notmuch-search-mode-map
notmuch-show-mode-map)
"g" 'notmuch-refresh-all-buffers)

(general-def 'notmuch-search-mode-map
"k" #'notmuch-search-archive-thread
"m" #'rasen/notmuch-search-mute)
(general-def 'notmuch-show-mode-map
"k" #'notmuch-show-archive-thread-then-next)
;; remap old function
(general-def '(notmuch-search-mode-map
notmuch-show-mode-map)
"K" #'notmuch-tag-jump)

(general-def 'notmuch-show-mode-map
"C" #'rasen/org-capture-link)

(general-def 'notmuch-show-mode-map
"M-u" (lambda ()
(interactive)
(notmuch-show-tag '("+unread"))))

;; notmuch-tag-formats

(setq-default notmuch-tagging-keys
'(("a" notmuch-archive-tags "Archive")
("u" notmuch-show-mark-read-tags "Mark read")
("m" ("+muted") "Mute")
("f" ("+flagged") "Flag")
("s" ("+spam" "-inbox") "Mark as spam")
("d" ("+deleted" "-inbox") "Delete")))

;; support for linking notmuch mails in org-mode
(require 'ol-notmuch))
#+end_src

Open html links in browser:
#+name: home-manager-section
#+begin_src nix
{
home.file.".mailcap".text = ''
text/html; firefox %s
application/pdf; open %s
'';
}
#+end_src
** Emacs
#+begin_src emacs-lisp
(setq user-full-name "Oleksii Shmalko"
user-mail-address "rasen.dubi@gmail.com")
#+end_src

Email sending.
#+begin_src emacs-lisp
(use-package message
:ensure nil ; built-in
:config
(setq message-send-mail-function 'message-send-mail-with-sendmail
message-sendmail-f-is-evil t
message-sendmail-envelope-from nil ; 'header
message-sendmail-extra-arguments '("--read-envelope-from"))

(setq mml-secure-smime-sign-with-sender t)
(setq mml-secure-openpgp-sign-with-sender t)

;; Add signature by default
(add-hook 'message-setup-hook 'mml-secure-message-sign-pgpmime)
;; Verify other's signatures
(setq mm-verify-option 'always))

(use-package sendmail
:ensure nil ; built-in
:config
(setq mail-specify-envelope-from nil
send-mail-function 'message-send-mail-with-sendmail
sendmail-program "msmtp"))
#+end_src
** rss2email
Install rss2email to deliver RSS feeds to my maildir.
#+name: home-manager-section
#+begin_src nix
{
home.packages = [ pkgs.rss2email ];
}
#+end_src
* Applications
Here go applications (almost) every normal user needs.
** GPG
#+name: nixos-section
#+begin_src nix
{
programs.gnupg.agent = {
enable = true;
enableSSHSupport = true;
pinentryFlavor = "qt";
};

## is it no longer needed?
#
# systemd.user.sockets.gpg-agent-ssh = {
# wantedBy = [ "sockets.target" ];
# listenStreams = [ "%t/gnupg/S.gpg-agent.ssh" ];
# socketConfig = {
# FileDescriptorName = "ssh";
# Service = "gpg-agent.service";
# SocketMode = "0600";
# DirectoryMode = "0700";
# };
# };

services.pcscd.enable = true;
}
#+end_src

Install on macOS:
#+name: darwin-section
#+begin_src nix
{
environment.systemPackages = [ pkgs.gnupg ];
programs.gnupg.agent = {
enable = true;
enableSSHSupport = true;
};
}
#+end_src

Request passwords in Emacs minibuffer. (emacs-lisp)
#+begin_src emacs-lisp
(setq epa-pinentry-mode 'loopback)
#+end_src

*** Fix epg--filter-revoked-keys wrongly filtering out my keys
Reported as: bug#46138: 28.0.50; epg--filter-revoked-keys filters out valid keys

Temporary workaround:
#+begin_src emacs-lisp
(defun epg--filter-revoked-keys (keys)
keys)
#+end_src
** Yubikey
#+name: nixos-section
#+begin_src nix
{
environment.systemPackages = [
pkgs.yubikey-manager
pkgs.yubikey-personalization
pkgs.yubikey-personalization-gui
];

services.udev.packages = [
pkgs.yubikey-personalization
pkgs.libu2f-host
];
}
#+end_src

#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.yubikey-manager
pkgs.yubikey-personalization
];
}
#+end_src
** password-store
Install [[https://www.passwordstore.org/][password-store]] along with [[https://github.com/tadfisher/pass-otp][one-time password extension]].
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
(pkgs.pass.withExtensions (exts: [ exts.pass-otp exts.pass-audit exts.pass-genphrase ]))
pkgs.qrencode
];
}
#+end_src

Install [[https://github.com/browserpass/browserpass][browserpass]] firefox extension backend.
#+name: home-manager-section
#+begin_src nix
{
programs.browserpass = {
enable = true;
browsers = ["firefox" "chrome"];
};
}
#+end_src

Integration with Emacs. (emacs-lisp)
#+begin_src emacs-lisp
(use-package ivy-pass
:disabled t
:commands (ivy-pass))

(use-package pass
:disabled t
:commands (pass))
#+end_src

Enable auth-source–pass integration.
#+begin_src emacs-lisp
(use-package auth-source
:config
(auth-source-pass-enable))
#+end_src
** Age

Use Age for file encryption.

#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.age
pkgs.age-plugin-yubikey
];
}
#+end_src

** Passage
#+name: home-manager-section
#+begin_src nix
{
home.sessionVariables.PASSAGE_DIR = "${config.home.homeDirectory}/.password-store";
home.sessionVariables.PASSAGE_IDENTITIES_FILE = "${config.home.homeDirectory}/.config/passage/identities";
home.packages = [
(pkgs.passage.overrideAttrs (old: {
patches =
(old.patches or [])
++ [
# Allow using multiple identities.
(pkgs.fetchpatch {
url = "https://github.com/FiloSottile/passage/commit/fba940f9e9ffbad7b746f26b8d6323ef6f746187.patch";
sha256 = "sha256-2w/k6JmcxFq9ThBasM0sL+58fwutF1ioZzwRFXfJgME=";
})
];
}))
];
}
#+end_src

** Gopass
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.unstable.gopass
pkgs.unstable.gopass-jsonapi
pkgs.pinentry_mac
];
}
#+end_src

** KDE apps
I don't use full KDE but some apps are definitely nice.
#+name: home-manager-section
#+begin_src nix
{
home.packages = pkgs.lib.linux-only [
pkgs.gwenview
pkgs.dolphin
# pkgs.kdeFrameworks.kfilemetadata
pkgs.filelight
pkgs.shared-mime-info
];
}
#+end_src

KDE apps might have issues with mime types without this:
#+name: nixos-section
#+begin_src nix
{
environment.pathsToLink = [ "/share" ];
}
#+end_src
** Zathura
[[https://pwmt.org/projects/zathura/][Zathura]] is a cool document viewer with Vim-like bindings.
#+name: home-manager-section
#+begin_src nix
{
programs.zathura = {
enable = true;
options = {
incremental-search = true;
};

# Swap j/k (for Workman layout)
extraConfig = ''
map j scroll up
map k scroll down
'';
};
}
#+end_src
** User applications
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
(pkgs.lib.linux-only pkgs.google-play-music-desktop-player)
(pkgs.lib.linux-only pkgs.tdesktop) # Telegram
pkgs.feh

# mesa is broken on macOS
(pkgs.lib.linux-only pkgs.mplayer)
(pkgs.lib.linux-only pkgs.smplayer)
];
}
#+end_src
** ActivityWatcher
Emacs integration:
#+begin_src emacs-lisp
(use-package activity-watch-mode
:config
(global-activity-watch-mode))
#+end_src
* Development
** Vim
Install Vim as my backup editor. (~<>~)
#+name: nixos-section
#+begin_src nix
{
environment.systemPackages = [
pkgs.vim_configurable
];
}
#+end_src

For Home Manager–managed hosts.
#+name: home-manager-section
#+begin_src nix
{
home.packages = [
pkgs.vim_configurable
];
}
#+end_src

Link its configuration.
#+name: home-manager-section
#+begin_src nix
{
home.file.".vim".source = ./.vim;
home.file.".vimrc".source = ./.vim/init.vim;
}
#+end_src
** Terminal / shell
*** rxvt-unicode
I use urxvt as my terminal emulator.
#+name: home-manager-section
#+begin_src nix
{
programs.urxvt = {
enable = true;
iso14755 = false;

fonts = [
"-*-terminus-medium-r-normal-*-32-*-*-*-*-*-iso10646-1"
];

scroll = {
bar.enable = false;
lines = 65535;
scrollOnOutput = false;
scrollOnKeystroke = true;
};
extraConfig = {
"loginShell" = "true";
"urgentOnBell" = "true";
"secondaryScroll" = "true";

# Molokai color theme
"background" = "#101010";
"foreground" = "#d0d0d0";
"color0" = "#101010";
"color1" = "#960050";
"color2" = "#66aa11";
"color3" = "#c47f2c";
"color4" = "#30309b";
"color5" = "#7e40a5";
"color6" = "#3579a8";
"color7" = "#9999aa";
"color8" = "#303030";
"color9" = "#ff0090";
"color10" = "#80ff00";
"color11" = "#ffba68";
"color12" = "#5f5fee";
"color13" = "#bb88dd";
"color14" = "#4eb4fa";
"color15" = "#d0d0d0";
};
};
}
#+end_src

Urxvt gets its setting from =.Xresources= file. If you ever want to reload it on-the-fly, type the following (or press =C-c C-c= if you're reading this document in emacs now):
#+begin_src sh :tangle no
xrdb ~/.Xresources
#+end_src
*** vterm
vterm is a terminal emulator using libvterm. Which allows running it within Emacs.
#+begin_src emacs-lisp
(use-package vterm
:commands vterm
:config
(setq vterm-kill-buffer-on-exit t)