(let ((data '(("Color" "Name" "Symbol" "Hex Code") ("Adwaita Dark Background (Original)" "" "" "#29353b") ("Adwaita Dark Background (Darker)" "" "" "#19252b") ("Adwaita Dark Background (Darkest)" "" "color-background" "#09151b") ("White Foreground" "" "color-foreground" "#bbc2cf") ("White Foreground Accent" "" "" "#798188") ("Yellow Cursor" "" "color-cursor" "#eeee22") ("Bright Yellow Highlight" "" "color-paren" "#ffff33") ("White Mouse" "" "color-mouse" "#ffffff") ("Outline Level 1" "goldenrod" "color-1" "#daa520") ("Outline Level 2" "light goldenrod" "color-2" "#eedd82") ("Outline Level 3" "yellow green" "color-3" "#9acd32") ("Outline Level 4" "light salmon" "color-4" "#ffa07a") ("Outline Level 5" "tan" "color-5" "#d2b48c") ("Outline Level 6" "light green" "color-6" "#90ee90") ("Outline Level 7" "coral" "color-7" "#ff7f50") ("Outline Level 8" "wheat" "color-8" "#f5deb3"))))
(mapc (lambda (x)
(let ((color (caddr x))
(value (cadddr x)))
(when (> (length color) 0)
(set (intern color) value))))
(cdr data))
)
(defun message--with-timestamp (format-string &rest args)
"Add timestamps to `*Messages*' buffer."
(when (and (> (length format-string) 0)
(not (string= format-string " ")))
(let ((deactivate-mark nil))
(save-mark-and-excursion
(with-current-buffer "*Messages*"
(let ((inhibit-read-only t))
(goto-char (point-max))
(when (not (bolp)) (newline))
(insert (format-time-string "[%T] " (current-time)))))))))
(advice-add 'message :before #'message--with-timestamp)
(defun init-message (level format-string &rest args)
"Custom version of `message' to log messages during Emacs initialization.
LEVEL is the indentation level."
(let ((file (file-name-sans-extension
(file-name-nondirectory
(or load-file-name buffer-file-name (buffer-name))))))
(message (concat ";;; " file " "
(make-string (* 2 level) ?-)
"> " format-string) args)))
(init-message 2 "Start: Status Messages")
(defun emacs-startup-hook--message-startup-time ()
"Message the Emacs startup time and number of garbage collections."
(message "Emacs startup time: %f seconds"
(float-time (time-subtract after-init-time before-init-time)))
(message "Emacs startup garbage collections: %d" gcs-done))
(add-hook 'emacs-startup-hook #'emacs-startup-hook--message-startup-time)
(setq gc-cons-threshold (* 50 1000 1000))
(defun advice--ignore-errors (orig-fun &rest args)
"Ignore errors when interactively calling ORIG-FUN with ARGS."
(condition-case err
(apply orig-fun args)
('error
(if (called-interactively-p 'any)
(message "%s" err)
(error err)))))
(defmacro when-lock-file-acquired (lock-file &rest body)
"Evaluate BODY unless another running Emacs instance has done so.
LOCK-FILE is a file name to be used as a lock for this BODY code.
Skips checks if run on Windows or Mac."
(declare (indent 1))
(let ((procdir (gensym "procdir")))
`(let ((,procdir (format "/proc/%d" (emacs-pid))))
(unless (or (string= system-type "windows-nt")
(string= system-type "darwin")
(file-exists-p ,lock-file))
(make-symbolic-link ,procdir ,lock-file t))
(when (or (string= system-type "windows-nt")
(string= system-type "darwin")
(file-equal-p ,lock-file ,procdir))
,@body))))
(init-message 1 "Package Manager")
(init-message 2 "Package Manager: Straight")
(require 'package)
(setq package-archives '(("melpa" . "http://melpa.org/packages/")
("elpa" . "http://elpa.gnu.org/packages/")))
(defvar bootstrap-version)
(let ((bootstrap-file
(expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
(bootstrap-version 5))
(unless (file-exists-p bootstrap-file)
(with-current-buffer
(url-retrieve-synchronously
"https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
'silent 'inhibit-cookies)
(goto-char (point-max))
(eval-print-last-sexp)))
(load bootstrap-file nil 'nomessage))
(straight-use-package 'use-package)
(setq straight-check-for-modifications
(remove 'find-at-startup straight-check-for-modifications))
(init-message 1 "Environment Settings")
(use-package async
:straight t)
(use-package bind-key
:straight t
:init
(setq bind-key-describe-special-forms t))
(use-package cl-generic
:straight (:type built-in))
(use-package cl-macs
:straight (:type built-in))
(use-package dash
:straight t
:demand t
:config
(use-package dash-functional
:straight t
:demand t))
(use-package diminish
:straight (diminish :type git :host github :repo "myrjola/diminish.el"))
(use-package f
:straight t
:demand t)
(use-package s
:straight t
:demand t)
(use-package seq
:straight (:type built-in))
(use-package subr-x
:straight (:type built-in))
(use-package org
:straight (:type built-in))
(use-package org-table
:straight (:type built-in))
(use-package ob-tangle
:straight (:type built-in))
(use-package ox
:straight (:type built-in))
(init-message 2 "Environment Settings: Environment")
(setq current-language-environment "UTF-8"
locale-coding-system 'utf-8)
(set-language-environment 'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)
(setenv "TZ" "America/Chicago")
(defconst window-system-windows
(string= window-system "w32")
"Non-nil if running on a MS-Windows display.")
(defconst window-system-mac
(string= window-system "ns")
"Non-nil if running on a Macintosh GNUstep or Cocoa display.")
(defconst window-system-linux
(string= window-system "x")
"Non-nil if running on a Linux X display.")
(defconst work-system
(file-exists-p "~/.work")
"Non-nil if running on a work system.")
(cd "~")
(setq shell-file-name (or (getenv "SHELL") "/bin/bash")
shell-command-switch "-c"
explicit-shell-file-name shell-file-name
explicit-sh-args '("-login" "-i"))
(when window-system-windows
(defvar w32-quote-process-args ?\"
"Windows quote arguments."))
(when window-system-mac
(add-to-list 'exec-path "/usr/local/sbin")
(add-to-list 'exec-path "/usr/local/bin"))
(setq print-length nil
print-level nil
eval-expression-print-length nil
eval-expression-print-level nil)
(init-message 2 "Environment Settings: Global Variables")
(defconst emacs-home-dir
(file-truename (expand-file-name "~/.emacs.d"))
"Emacs configuration home directory.")
(defmacro emacs-home-sub-dir (dir)
"Return expanded directory name of DIR if found as a
sub-directory of `emacs-home-dir', or just `emacs-home-dir'
otherwise."
`(let ((file (expand-file-name ,dir emacs-home-dir)))
(if (file-exists-p file)
(file-truename file)
emacs-home-dir)))
(defconst emacs-modules-dir
(emacs-home-sub-dir "modules")
"Emacs modules directory.")
(defconst local-modules-dir
(emacs-home-sub-dir "local-modules")
"Emacs local modules directory.")
(defconst local-work-modules-dir
(emacs-home-sub-dir "local-work-modules")
"Emacs local work modules directory.")
(defconst customization-file
(file-truename (expand-file-name "customization.el" emacs-home-dir))
"Emacs customization file.")
(setq custom-file customization-file)
(defconst init-emacs-true-file-name
(file-truename (expand-file-name "init-emacs.org" emacs-home-dir))
"The true file name of this buffer.")
(defconst user-name "kyle")
(defconst user-full-name "Kyle W T Sherman")
(defconst user-short-name "Kyle Sherman")
(defconst user-first-name "Kyle")
(defconst user-last-name "Sherman")
(defconst user-mail-address
(if (getenv "EMAIL")
(getenv "EMAIL")
(concat "kyle" "w" "sherman" "@" "gmail" "." "com"))
"User email address.")
(defconst user-mail-address-nospam
(replace-regexp-in-string "\\." " dot "
(replace-regexp-in-string "@" " at " user-mail-address))
"Slightly obfuscated user email address.")
(defun signature (&optional fortune)
"Return a signature.
A fortune is added if FORTUNE is non-nil."
(let ((name (or user-short-name user-full-name))
(mail user-mail-address))
(let ((sig (if (and name mail)
(concat name " <" mail ">")
(if name
name
mail))))
(concat (if sig sig "")
(if (and sig fortune) "\n\n" "")
(if fortune
(shell-command-to-string
(concat "fortune -a "
(shell-quote-argument (expand-file-name "~/quotes"))
" | xargs echo -n"))
"")))))
(init-message 2 "Environment Settings: Load Path")
(when (file-exists-p local-modules-dir)
(add-to-list 'load-path local-modules-dir))
(when (file-exists-p emacs-modules-dir)
(add-to-list 'load-path emacs-modules-dir))
(when window-system
(init-message 3 "Environment Settings: GUI: General")
(when (string= window-system "x")
(setq select-enable-clipboard t select-enable-primary t x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING) save-interprogram-paste-before-kill t interprogram-paste-function 'x-cut-buffer-or-selection-value mouse-yank-at-point t))
(setq inverse-video t)
(setq visible-bell t)
(setq ring-bell-function 'ignore)
(blink-cursor-mode 0)
(when (and (fboundp 'scroll-bar-mode)
scroll-bar-mode)
(scroll-bar-mode -1))
(when (and (fboundp 'tool-bar-mode)
tool-bar-mode)
(tool-bar-mode -1))
(setq frame-title-format "%b")
(bind-keys* ([vertical-scroll-bar down-mouse-1] . scroll-bar-drag))
(setq mouse-wheel-scroll-amount '(1 ((shift) . 1))
mouse-wheel-progressive-speed t)
(init-message 3 "Environment Settings: GUI: Font")
(ignore-errors
(cl-case window-system
(x
(condition-case nil
(cond
((x-list-fonts "Hack Nerd Font")
(set-frame-font "Hack Nerd Font Mono-12" nil t))
((x-list-fonts "DroidSansMono Nerd Font")
(set-frame-font "DroidSansMono Nerd Font Mono-12" nil t))
((x-list-fonts "Fira Code")
(set-frame-font "Fira Code Mono-12" nil t))
(t
(set-frame-font "9x15" nil t)))
('error
(set-frame-font "9x15" nil t))))
(w32
(condition-case nil
(set-frame-font "Hack Nerd Font Mono-12" nil t)
('error
nil)))
(ns
(condition-case nil
(progn
(set-frame-font "Hack Nerd Font Mono-14" nil t)
)
('error
(set-frame-font "Menlo" nil t))))))
(init-message 3 "Environment Settings: GUI: Faces")
(defvar background-alpha
100
"Background transparency alpha percentage.
Common values:
100 = none
90 = 10% transparency
85 = 15% transparency
80 = 20% transparency")
(setq background-alpha (if (or window-system-mac window-system-windows)
100 85)) (set-frame-parameter (selected-frame) 'alpha
`(,background-alpha . ,background-alpha))
(add-to-list 'default-frame-alist
`(alpha . (,background-alpha . ,background-alpha)))
(set-mouse-color color-mouse)
(init-message 3 "Environment Settings: GUI: Modus Themes")
(use-package modus-themes
:straight (:type built-in)
:bind ("<f2>" . modus-themes-toggle)
:init
(setq modus-themes-italic-constructs t
modus-themes-bold-constructs nil
modus-themes-mixed-fonts nil
modus-themes-subtle-line-numbers nil
modus-themes-intense-mouseovers nil
modus-themes-deuteranopia t
modus-themes-tabs-accented t
modus-themes-variable-pitch-ui nil
modus-themes-inhibit-reload t modus-themes-fringes nil
modus-themes-lang-checkers nil
modus-themes-mode-line '(accented borderless (padding . 4) (height . 0.9))
modus-themes-markup '(background italic)
modus-themes-syntax '(alt-syntax faint green-strings yellow-comments)
modus-themes-hl-line '(intense)
modus-themes-paren-match '(bold intense)
modus-themes-links '(neutral-underline background)
modus-themes-box-buttons '(variable-pitch flat faint 0.9)
modus-themes-prompts '(intense bold)
modus-themes-completions '((matches . (extrabold))
(selection . (semibold accented))
(popup . (accented intense)))
modus-themes-mail-citations nil
modus-themes-region '(bg-only accented)
modus-themes-diffs 'desaturated
modus-themes-org-blocks nil
modus-themes-org-agenda '((header-block . (variable-pitch 1.3))
(header-date . (grayscale workaholic bold-today 1.1))
(event . (accented varied))
(scheduled . uniform)
(habit . traffic-light))
modus-themes-headings '((t . ()))
modus-themes-vivendi-color-overrides `((bg-main . ,color-background)
(fg-main . ,color-foreground)))
(load-theme 'modus-vivendi :no-error)
:config
(modus-themes-load-vivendi))
)
(init-message 2 "Environment Settings: General")
(init-message 3 "Disable Splash Screen")
(setq inhibit-startup-screen t)
(setq load-prefer-newer t)
(init-message 3 "Hide Menu Bar")
(when (and (fboundp 'menu-bar-mode)
menu-bar-mode)
(menu-bar-mode -1))
(init-message 3 "Set Default Buffer Mode to `org-mode'")
(setq initial-major-mode 'org-mode)
(init-message 3 "Start with Empty Scratch Buffer")
(setq initial-scratch-message nil)
(init-message 3 "Ask before Closing Emacs")
(setq kill-emacs-query-functions
(cons (lambda () (yes-or-no-p "Really kill Emacs? "))
kill-emacs-query-functions))
(init-message 3 "Make Backspace Key Work Correctly")
(normal-erase-is-backspace-mode 1)
(init-message 3 "Add Some Characters to Word Boundaries")
(modify-syntax-entry ?_ "w")
(modify-syntax-entry ?- "w")
(init-message 3 "Beginning of Defun is Outermost Level Open-Paren.")
(setq open-paren-in-column-0-is-defun-start nil
defun-prompt-regexp nil)
(init-message 3 "Ignore Comments when Parsing S-Expressions")
(setq parse-sexp-ignore-comments t)
(setq-default parse-sexp-ignore-comments parse-sexp-ignore-comments)
(init-message 3 "Do Not Wrap Lines by Default")
(setq truncate-lines t)
(setq-default truncate-lines t)
(toggle-truncate-lines 1)
(init-message 3 "Turn Off `auto-fill-mode'")
(turn-off-auto-fill)
(init-message 3 "Turn On `global-visual-line-mode'")
(global-visual-line-mode -1)
(setq visual-line-fringe-indicators '(left-curly-arrow right-curly-arrow))
(init-message 3 "Set `display-line-numbers-type' to relative")
(setq display-line-numbers-type 'relative)
(init-message 3 "Prevent `next-line' from Inserting Newlines")
(setq next-line-add-newlines nil)
(init-message 3 "Keep the Cursor in the Same Column When Using Page-Up and Page-Down")
(setq scroll-preserve-screen-position 'keep)
(init-message 3 "Scroll Conservatively")
(setq scroll-step 1)
(setq scroll-conservatively 101)
(setq auto-window-vscroll nil)
(init-message 3 "Ignore Case on Search Matches")
(setq case-fold-search t)
(init-message 3 "Highlight Search Matches")
(setq search-highlight t
query-replace-highlight t)
(init-message 3 "Hightlight Marked Regions")
(transient-mark-mode 1)
(setq-default transient-mark-mode t)
(init-message 3 "Set Default Tab Indentation to Four Spaces and Turn on Auto-Complete")
(setq indent-tabs-mode nil tab-width 4 standard-indent 4 tab-always-indent 'complete tab-stop-list (number-sequence 4 180 4)) (setq-default indent-tabs-mode indent-tabs-mode
tab-width tab-width
standard-indent standard-indent
tab-always-indent tab-always-indent
tab-stop-list tab-stop-list)
(init-message 3 "Set Default Line-Wrapping Column to 78")
(setq fill-column 78)
(setq-default fill-column fill-column)
(init-message 3 "Set Default Right-Margin Comment Indent Column to 40")
(setq comment-column 40)
(setq-default comment-column comment-column)
(setq comment-fill-column nil)
(setq-default comment-fill-column comment-fill-column)
(init-message 3 "Have Cursor Movements Attempt to Keep Point on Original Column")
(put 'set-goal-column 'disabled nil)
(init-message 3 "Sentences and Colons Should Have One Space after Them")
(setq sentence-end-double-space nil)
(setq colon-double-space nil)
(init-message 3 "Highlight Matching Parenthesis")
(show-paren-mode 1)
(set-face-foreground 'show-paren-match color-paren)
(set-face-attribute 'show-paren-match nil :weight 'extra-bold)
(init-message 3 "Highlight TABs")
(setq highlight-tabs t)
(setq-default highlight-tabs highlight-tabs)
(init-message 3 "Highlight Tabs and Trailing Whitespace")
(setq whitespace-style '(face trailing tab-mark))
(custom-set-faces `(whitespace-tab ((t (:foreground ,color-foreground :background ,color-background)))))
(setq whitespace-display-mappings
'((space-mark 32 [183] [46]) (newline-mark 10 [182 10]) (tab-mark 9 [9655 9] [92 9]))) (global-whitespace-mode)
(init-message 3 "Highlight Current Line")
(hl-line-mode 1)
(global-hl-line-mode 1)
(init-message 3 "Turn on Syntax Highlighting")
(global-font-lock-mode 1)
(setq font-lock-maximum-decoration t)
(init-message 3 "Typing Replaces Highlighted Text")
(delete-selection-mode t)
(init-message 3 "Set Commenting Style to Indent")
(setq comment-style 'indent)
(setq enable-recursive-minibuffers t)
(minibuffer-depth-indicate-mode 1)
(init-message 3 "Have `apropos' Search All Symbols and Order by Relevance")
(setq apropos-do-all t)
(setq apropos-sort-by-scores t
apropos-documentation-sort-by-scores t)
(init-message 3 "Set Default `grep' Command")
(setq grep-command "grep -n -H -i -r -e ")
(init-message 3 "Set Email Sources")
(setq mail-sources `((pop :server "pop.gmail.com" :port 995
:user ,user-mail-address
:connection ssl :leave t)))
(init-message 3 "Set Default Browser")
(setq browse-url-browser-function 'browse-url-default-browser)
(setq browse-url-secondary-browser-function 'browse-url-default-browser)
(init-message 3 "Single Character Deletion Commands Delete Active Regions Without Saving to the Kill Ring")
(setq delete-active-region t)
(init-message 3 "Disable `vc-git'.")
(setq vc-handled-backends nil)
(init-message 3 "Recenter window after `occur-mode-goto-occurrence'.")
(defun occur-mode-goto-occurrence--recenter (&optional arg)
"Recenter when an `occur' result is selected."
(recenter))
(advice-add 'occur-mode-goto-occurrence :after #'occur-mode-goto-occurrence--recenter)
(init-message 3 "Set time zones to use for `display-time-world'.")
(setq display-time-world-list
'(("Etc/UTC" "UTC")
("America/Los_Angeles" "San Diego")
("America/Chicago" "Minneapolis")
("America/New_York" "New York")
("Etc/GMT" "GMT")
("Europe/London" "London")
("Europe/Paris" "Paris")
("Asia/Tokyo" "Tokyo")))
(init-message 2 "Environment Settings: System")
(setq max-specpdl-size 10000)
(setq max-lisp-eval-depth 10000)
(setq message-log-max 2048)
(setq history-length 250)
(setq history-delete-duplicates t)
(setq kill-ring-max 100)
(setq mark-ring-max 32)
(fset 'yes-or-no-p 'y-or-n-p)
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(setq disabled-command-function nil)
(setq-default bidi-paragraph-direction 'left-to-right)
(when (version<= "27.1" emacs-version)
(setq bidi-inhibit-bpa t))
(when (version<= "27.1" emacs-version)
(global-so-long-mode 1))
(init-message 3 "Set `safe-local-variable-values'.")
(add-to-list 'safe-local-variable-values '(org-babel-noweb-wrap-start . "{{"))
(add-to-list 'safe-local-variable-values '(org-babel-noweb-wrap-end . "}}"))
(init-message 2 "Environment Settings: Files")
(setq large-file-warning-threshold 50000000)
(setq enable-local-variables t
enable-local-eval 'maybe)
(setq delete-auto-save-files t)
(setq auto-save-default nil)
(setq-default auto-save-default nil)
(setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
auto-save-list-file-prefix temporary-file-directory
auto-save-list-file-name nil
auto-save-default nil)
(setq make-backup-files nil)
(setq-default make-backup-files nil)
(setq backup-directory-alist `((".*" . ,temporary-file-directory))
make-backup-files nil
backup-by-copying t
version-control nil
delete-old-versions t)
(setq vc-follow-symlinks t)
(setq-default vc-follow-symlinks vc-follow-symlinks)
(auto-compression-mode t)
(setq find-file-existing-other-name t)
(setq require-final-newline t)
(global-auto-revert-mode 1)
(defun create-buffer-file-name-directory-if-needed ()
"Create `buffer-file-name' directory if it does not already exist."
(when (and buffer-file-name
(not (file-exists-p (file-name-directory buffer-file-name))))
(make-directory (file-name-directory buffer-file-name) t)))
(add-hook 'before-save-hook #'create-buffer-file-name-directory-if-needed)
(setq delete-trailing-lines t)
(defun delete-trailing-whitespace-if-not-read-only (&optional beg end)
"Call `delete-trailing-whitespace' if current buffer is not read-only."
(interactive (if (use-region-p)
(list (region-beginning) (region-end))
(list nil nil)))
(when (not buffer-read-only)
(delete-trailing-whitespace beg end)))
(add-hook 'before-save-hook #'delete-trailing-whitespace-if-not-read-only)
(when (fboundp 'executable-make-buffer-file-executable-if-script-p)
(add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p))
(add-to-list 'file-coding-system-alist '("\\.ASM\\'" . dos))
(add-to-list 'file-coding-system-alist '("\\.BAT\\'" . dos))
(add-to-list 'file-coding-system-alist '("\\.DO\\'" . dos))
(add-to-list 'file-coding-system-alist '("\\.SYS\\'" . dos))
(setq bookmark-save-flag 1)
(when-lock-file-acquired (expand-file-name "emacs-desktop-history-lock-file"
temporary-file-directory)
(desktop-save-mode 1)
(setq desktop-save 'ask-if-new
desktop-load-locked-desktop t
desktop-restore-eager 0 desktop-buffers-not-to-save (concat "\\("
"\\.log\\|(ftp)\\|^tags\\|^TAGS"
"\\.diary\\|\\diary\\|\\.bbdb"
"\\)$"))
(add-to-list 'desktop-globals-to-save 'file-name-history t)
(add-to-list 'desktop-modes-not-to-save 'Info-mode t)
(add-to-list 'desktop-modes-not-to-save 'info-lookup-mode t)
)
(when (fboundp 'savehist-mode)
(when-lock-file-acquired (expand-file-name "emacs-minibuffer-history-lock-file"
temporary-file-directory)
(savehist-mode 1)
(setq savehist-save-minibuffer-history 1
savehist-additional-variables '(search-ring
regexp-search-ring))))
(init-message 2 "Environment Settings: Buffers and Windows")
(when (fboundp 'winner-mode)
(winner-mode 1))
(setq jit-lock-defer-time 0.05)
(setq switch-to-buffer-preserve-window-point t)
(setq mouse-wheel-scroll-amount '(1 ((shift) . 5) ((control))))
(setq max-mini-window-height 0.50)
(init-message 2 "General Settings: Tabs")
(defvar custom-tab-width 4
"Regular tab width.")
(defvar custom-short-tab-width 2
"Short tab width used for certain modes.")
(defun set-tabs (enable &optional width)
"Set default tab settings.
If ENABLED is non-nil, enable TAB characters.
Otherwise, disable TAB characters.
If WIDTH is given, it is used to set the TAB width.
Otherwise, `custom-tab-width' is used."
(let ((width (or width custom-tab-width)))
(setq indent-tabs-mode enable tab-width width standard-indent width tab-always-indent 'complete tab-stop-list (number-sequence width 180 width) backward-delete-char-untabify-method nil)))
(defun disable-tabs (&optional width)
"Disable TAB character usage, using WIDTH if given."
(set-tabs nil width))
(defun enable-tabs (&optional width)
"Enable TAB character usage, using WIDTH if given."
(set-tabs t width))
(defun enable-tabs-4 ()
"Enable TAB character usage with a width of 4 spaces."
(set-tabs t 4))
(defun enable-tabs-8 ()
"Enable TAB character usage with a width of 8 spaces."
(set-tabs t 8))
(init-message 3 "Environment Settings: Terminals: Configuration")
(setq custom-terminal-history-size 10000
custom-terminal-maximum-lines 10000)
(init-message 3 "Environment Settings: Terminals: eshell")
(defun custom-eshell-first-time-mode-hook ()
(add-hook 'eshell-pre-command-hook #'eshell-save-some-history)
(add-to-list 'eshell-output-filter-functions #'eshell-truncate-buffer))
(use-package eshell
:straight (:type built-in)
:hook (eshell-first-time-mode . custom-eshell-first-time-mode-hook)
:custom
(eshell-history-size custom-terminal-history-size)
(eshell-buffer-maximum-lines custom-terminal-maximum-lines)
(eshell-hist-ignoredups t)
(eshell-scroll-to-bottom-on-input t)
:config
(setenv "PAGER" "cat")
(with-eval-after-load 'esh-opt
(setq eshell-destroy-buffer-when-process-dies t
eshell-visual-commands '("htop" "ssh" "vim" "zsh"))))
(use-package eshell-git-prompt
:straight t
:after (eshell)
:config
(eshell-git-prompt-use-theme 'powerline))
(init-message 3 "Environment Settings: Terminals: term-bash")
(defun term-bash ()
"Start a BASH terminal-emulator in a new buffer."
(interactive)
(term "/bin/bash"))
(init-message 3 "Environment Settings: Terminals: term-zsh")
(defun term-zsh ()
"Start a ZSH terminal-emulator in a new buffer."
(interactive)
(term "/bin/zsh"))
(init-message 3 "Environment Settings: Terminals: vterm")
(use-package vterm
:straight t
:commands (vterm)
:custom
(vterm-max-scrollback custom-terminal-maximum-lines)
(vterm-kill-buffer-on-exit nil))
(init-message 1 "Key Bindings")
(init-message 2 "Key Bindings: System Keys")
(defun custom-key-bindings-system-keys ()
"Set custom system key bindings."
(cond
(window-system-mac
(when (fboundp 'new-scratch)
(bind-keys* ("s-t" . new-scratch))))
((or window-system-linux window-system-windows)
(if (fboundp 'kill-region-or-word)
(bind-keys* ("s-x" . kill-region-or-word))
(bind-keys* ("s-x" . kill-region)))
(bind-keys* ("s-c" . kill-ring-save))
(bind-keys* ("s-v" . yank))
(bind-keys* ("s-z" . undo))
(when (fboundp 'undo-tree-redo)
(bind-keys* ("s-y" . undo-tree-redo)))
(bind-keys* ("s-a" . mark-whole-buffer))
(bind-keys* ("s-f" . isearch-forward))
(bind-keys* ("s-g" . isearch-forward))
(bind-keys* ("s-r" . isearch-backward))
(bind-keys* ("s-o" . find-file))
(bind-keys* ("s-p" . print-buffer))
(if (fboundp 'save-buffer-always)
(bind-keys* ("s-s" . save-buffer-always))
(bind-keys* ("s-s" . save-buffer)))
(when (fboundp 'new-scratch)
(bind-keys* ("s-t" . new-scratch)))
(bind-keys* ("s-w" . kill-current-buffer))
(bind-keys* ("s-SPC" . set-mark-command)))))
(init-message 3 "custom-key-bindings-system-keys")
(custom-key-bindings-system-keys)
(init-message 2 "Key Bindings: Function Keys")
(defun custom-key-bindings-function-keys ()
"Set custom function key bindings."
(when (fboundp 'help-for-help)
(bind-keys ("<f1>" . help-for-help)))
(when (fboundp 'help-command)
(bind-keys ("S-<f1>" . help-command)))
(when (fboundp 'kmacro-start-macro-or-insert-counter)
(bind-keys ("<f3>" . kmacro-start-macro-or-insert-counter))) (when (fboundp 'kmacro-end-or-call-macro)
(bind-keys ("<f4>" . kmacro-end-or-call-macro))) (when (fboundp 'define-word-after-spell-check)
(bind-keys ("<f5>" . define-word-after-spell-check)))
(when (fboundp 'define-word-at-point-after-spell-check)
(bind-keys ("S-<f5>" . define-word-at-point-after-spell-check)))
(when (fboundp 'web-query)
(bind-keys ("<f7>" . web-query)))
(when (fboundp 'web-query-symbol-by-mode-at-point)
(bind-keys ("<S-f7>" . web-query-symbol-by-mode-at-point)))
(when (fboundp 'neotree)
(bind-keys ("<f8>" . neotree)))
(when (fboundp 'cycle-buffer-backward)
(bind-keys ("<f9>" . cycle-buffer-backward)))
(when (fboundp 'cycle-buffer-backward-permissive)
(bind-keys ("S-<f9>" . cycle-buffer-backward-permissive)))
(when (fboundp 'cycle-buffer)
(bind-keys ("<f10>" . cycle-buffer))) (when (fboundp 'cycle-buffer-permissive)
(bind-keys ("S-<f10>" . cycle-buffer-permissive)))
)
(init-message 3 "custom-key-bindings-function-keys")
(custom-key-bindings-function-keys)
(init-message 2 "Key Bindings: Extended Keys")
(defun custom-key-bindings-extended-keys ()
"Set custom extended key bindings."
(bind-keys* ("<home>" . beginning-of-line))
(bind-keys* ("<end>" . end-of-line))
(bind-keys* ("C-<home>" . beginning-of-buffer))
(bind-keys* ("C-<end>" . end-of-buffer)))
(init-message 3 "custom-key-bindings-extended-keys")
(custom-key-bindings-extended-keys)
(init-message 2 "Key Bindings: Movement Keys")
(defun custom-key-bindings-movement-keys (&optional keymap)
"Set custom movement key bindings on KEYMAP.
KEYMAP defaults to `override-global-map'."
(let ((keymap (or keymap override-global-map)))
(bind-keys* :map keymap
("<up>" . previous-line) ("<down>" . next-line) ("<left>" . left-char) ("<right>" . right-char) ("M-i" . previous-line) ("M-k" . next-line) ("M-j" . left-char) ("M-l" . right-char))
(bind-keys* :map keymap
("C-<up>" . backward-paragraph) ("C-<down>" . forward-paragraph) ("C-<left>" . left-word) ("C-<right>" . right-word) ("C-M-u" . backward-paragraph) ("C-M-o" . forward-paragraph) ("M-u" . left-word) ("M-o" . right-word))
(bind-keys* :map keymap
("C-M-<up>" . scroll-down-command) ("C-M-<down>" . scroll-up-command) ("C-M-<left>" . move-beginning-of-line) ("C-M-<right>" . move-end-of-line) ("C-M-i" . scroll-down-command) ("C-M-k" . scroll-up-command) ("C-M-j" . move-beginning-of-line) ("C-M-l" . move-end-of-line))
(bind-keys* :map keymap
("C-x <up>" . windmove-up)
("C-x <down>" . windmove-down)
("C-x <left>" . windmove-left) ("C-x <right>" . windmove-right) ("C-x C-<up>" . windmove-up)
("C-x C-<down>" . windmove-down)
("C-x C-<left>" . windmove-left) ("C-x C-<right>" . windmove-right) ("C-x M-i" . windmove-up)
("C-x M-k" . windmove-down)
("C-x M-j" . windmove-left)
("C-x M-l" . windmove-right))
(when (fboundp 'move-line-up)
(bind-keys* :map keymap
("M-[" . move-line-up)))
(when (fboundp 'move-line-down)
(bind-keys* :map keymap
("M-]" . move-line-down)))))
(init-message 3 "custom-key-bindings-movement-keys")
(custom-key-bindings-movement-keys)
(init-message 2 "Key Bindings: Standard Keys")
(defun custom-key-bindings-standard-keys ()
"Set custom standard key bindings."
(when (fboundp 'insert-line-below)
(bind-keys ("C-M-<return>" . insert-line-below)))
(bind-keys ("C-SPC" . set-mark-command))
(when (fboundp 'cua-set-rectangle-mark)
(bind-keys ("C-x rm" . cua-set-rectangle-mark)
("C-M-SPC" . cua-set-rectangle-mark)))
(when (fboundp 'yank-as-rectangle)
(bind-keys ("C-x r C-y" . yank-as-rectangle)))
(when (fboundp 'just-one-space)
(bind-keys ("C-x C-SPC" . just-one-space)))
(bind-keys ("C-x C-h" . help-command)
("C-x ?" . help))
(when (fboundp 'describe-function-or-variable-at-point)
(bind-keys ("C-h z" . describe-function-or-variable-at-point)
("C-x C-h z" . describe-function-or-variable-at-point)))
(when (fboundp 'shortdoc-display-group)
(bind-keys ("C-h D" . shortdoc-display-group)
("C-x C-h D" . shortdoc-display-group)))
(when (fboundp 'tmm-menubar)
(bind-keys ("C-M-z" . tmm-menubar)))
(when (fboundp 'save-buffer-always-maybe)
(bind-keys ("C-x C-s" . save-buffer-always-maybe)))
(bind-keys ("C-c y" . bury-buffer))
(bind-keys ("C-c C-y" . bury-buffer))
(bind-keys ("C-c r" . revert-buffer))
(bind-keys ("C-c C-r" . revert-buffer))
(bind-keys ("C-c d" . diff-current-buffer))
(when (fboundp 'mark-full-word)
(bind-keys ("M-@" . mark-full-word)))
(bind-keys ("M-&" . replace-regexp))
(when (fboundp 'insert-menu-prompt)
(bind-keys ("C-x i" . insert-menu-prompt)))
(bind-keys ("M-1" . delete-other-windows)) (bind-keys ("M-2" . split-window-horizontally)) (bind-keys ("M-3" . split-window-vertically)) (unbind-key "M-4") (if (fboundp 'swap-windows)
(bind-keys ("M-4" . swap-windows))) (unbind-key "M-5") (when (fboundp 'toggle-window-split)
(bind-keys ("M-5" . toggle-window-split))) (bind-keys ("M-6" . switch-to-buffer-other-window)) (unbind-key "M-7") (unbind-key "M-8") (unbind-key "M-8") (when (fboundp 'kill-other-window-buffer)
(bind-keys ("M-8" . kill-other-window-buffer))) (unbind-key "M-9") (when (fboundp 'kill-other-window-buffer-and-delete-window)
(bind-keys ("M-9" . kill-other-window-buffer-and-delete-window))) (bind-keys ("M-0" . delete-window))
(when (fboundp 'ace-window)
(bind-keys ("C-x o" . ace-window)))
(when (fboundp 'swap-windows)
(bind-keys ("C-x C-o" . swap-windows)))
(when (fboundp 'toggle-window-split)
(bind-keys ("C-x M-o" . toggle-window-split)))
(bind-keys ("C-$" . toggle-truncate-lines))
(bind-keys ("C-x C-k" . kill-current-buffer))
(when (fboundp 'delete-to-end-of-line)
(bind-keys ("C-k" . delete-to-end-of-line)))
(when (fboundp 'delete-line)
(bind-keys ("C-M-d" . delete-line)))
(when (fboundp 'delete-word)
(bind-keys ("M-d" . delete-word))) (when (fboundp 'backward-delete-word)
(bind-keys ("C-<backspace>" . backward-delete-word)))
(when (fboundp 'copy-line)
(bind-keys ("C-x C-y" . copy-line)))
(when (fboundp 'cut-line)
(bind-keys ("C-x M-y" . cut-line)))
(when (fboundp 'duplicate-line)
(bind-keys ("C-x C-d" . duplicate-line)))
(bind-keys ("C-x C-j" . join-line))
(when (fboundp 'join-next-line)
(bind-keys ("C-x j" . join-next-line)))
(when (fboundp 'titleize-word-enhanced)
(bind-keys ("M-t" . titleize-word-enhanced)) (bind-keys ("M-T" . titleize-line-or-region)))
(when (fboundp 'enlarge-window-5)
(bind-keys ("C-x &" . enlarge-window-5)))
(when (fboundp 'shrink-window-5)
(bind-keys ("C-x %" . shrink-window-5)))
(bind-keys ("C-x M-p" . describe-text-properties))
(when (fboundp 'goto-last-change)
(bind-keys ("C-x C-_" . goto-last-change)))
(when (fboundp 'match-paren)
(bind-keys ("M-(" . match-paren)))
(bind-keys ("C-x C-e" . eval-current-sexp))
(when (fboundp 'eval-sexp-buffer)
(bind-keys ("C-x M-e" . eval-sexp-buffer)))
(when (fboundp 'comment-or-uncomment-sexp)
(define-key emacs-lisp-mode-map (kbd "C-M-;") 'comment-or-uncomment-sexp))
(when (fboundp 'indent-region-or-thing)
(bind-keys ("C-M-\\" . indent-region-or-thing)))
(when (fboundp 'append-equal-to-column-80)
(bind-keys ("C-c =" . append-equal-to-column-80)))
(when (fboundp 'append-dash-to-column-80)
(bind-keys ("C-c -" . append-dash-to-column-80)))
(when (fboundp 'append-asterisk-to-column-80)
(bind-keys ("C-c 8" . append-asterisk-to-column-80))
(bind-keys ("C-c *" . append-asterisk-to-column-80)))
(when (fboundp 'insert-lisp-comment-block-equal)
(bind-keys ("C-c C-=" . insert-lisp-comment-block-equal)))
(when (fboundp 'insert-lisp-comment-block-dash)
(bind-keys ("C-c C--" . insert-lisp-comment-block-dash)))
(bind-keys ("C-c |" . align-current))
(when (fboundp 'complete-tag)
(bind-keys ("M-C-/" . complete-tag)))
(unbind-key "C-x f")
(when (fboundp 'compare-windows)
(bind-keys ("C-c C-w" . compare-windows)))
(when (fboundp 'unfill-paragraph)
(bind-keys ("M-Q" . unfill-paragraph)))
(when (and (fboundp 'pop-up-shell) (fboundp 'pop-up-shell-toggle))
(bind-keys ("C-x C-]" . pop-up-shell-toggle))))
(init-message 3 "custom-key-bindings-standard-keys")
(custom-key-bindings-standard-keys)
(init-message 2 "Key Bindings: Modes and Module Keys")
(defun custom-key-bindings-modes-and-modules-keys ()
"Set custom modes and modules key bindings."
(when (fboundp 'diary)
(bind-keys ("C-x y" . diary)))
(bind-keys ("C-M-'" . imenu))
(define-key isearch-mode-map (kbd "C-o")
(lambda ()
(interactive)
(let ((case-fold-search isearch-case-fold-search))
(occur (if isearch-regexp isearch-string (regexp-quote isearch-string))))))
(bind-keys ("C-x M-n" . display-line-numbers-mode))
(when (fboundp 'display-line-numbers-type-toggle)
(bind-keys ("C-x M-N" . display-line-numbers-type-toggle)))
(when (fboundp 'occur)
(bind-keys ("C-c o" . occur)))
(bind-keys ("C-x !" . shell)))
(init-message 3 "custom-key-bindings-modes-and-modules-keys")
(custom-key-bindings-modes-and-modules-keys)
(init-message 2 "Key Bindings: Grouped Prefix Keys")
(defun custom-key-bindings-grouped-prefix-keys ()
"Set custom grouped prefix key bindings."
(unbind-key "C-h e")
(define-prefix-command 'help-find-map nil "Help Find Commands")
(bind-keys* :prefix "C-h e"
:prefix-map help-find-map
:menu-name "Help Find Commands"
("e" . view-echo-area-messages)
("f" . find-function)
("k" . find-function-on-key)
("l" . find-library)
("v" . find-variable)
("V" . apropos-value))
(unbind-key "M-SPC")
(define-prefix-command 'space-map nil "Space Prefix Launching Point")
(bind-keys* :prefix "M-SPC"
:prefix-map space-map
:menu-name "Space Prefix Launching Point")
(bind-keys* ("C-." . space-map))
(bind-keys :map space-map ("M-SPC" . tmm-menubar))
(bind-keys :map space-map
:prefix "b"
:prefix-map space-buffer-map
:menu-name "Buffer Commands")
(when (fboundp 'switch-to-messages)
(bind-keys :map space-buffer-map ("m" . switch-to-messages)))
(when (fboundp 'new-scratch)
(bind-keys :map space-buffer-map ("n" . new-scratch)))
(when (fboundp 'new-emacs-lisp-scratch)
(bind-keys :map space-buffer-map ("e" . new-emacs-lisp-scratch)))
(when (fboundp 'switch-to-scratch)
(bind-keys :map space-buffer-map ("s" . switch-to-scratch)))
(when (fboundp 'switch-to-scratch-for-current-mode)
(bind-keys :map space-buffer-map ("c" . switch-to-scratch-for-current-mode)))
(bind-keys :map space-map
:prefix "c"
:prefix-map space-command-log-map
:menu-name "Command Log Commands"
("c" . command-log-mode-on)
("k" . command-log-mode-off)
("l" . clm/command-log-clear))
(bind-keys :map space-map
:prefix "g"
:prefix-map space-git-map
:menu-name "Git Commands"
("b" . magit-branch)
("c" . magit-branch-or-checkout)
("d" . magit-diff-unstaged)
("f" . magit-fetch)
("F" . magit-fetch-all)
("p" . magit-pull-branch)
("P" . magit-push-current)
("r" . magit-rebase)
("s" . magit-status))
(bind-keys :map space-git-map
:prefix "l"
:prefix-map space-git-log-map
:menu-name "Git Log Commands"
("l" . magit-log-current)
("f" . magit-log-buffer-file))
(bind-keys :map space-map
:prefix "G"
:prefix-map space-grep-map
:menu-name "Grep Commands")
(when (fboundp 'grep-bin)
(bind-keys :map space-grep-map ("b" . grep-bin)))
(when (fboundp 'grep-clojure)
(bind-keys :map space-grep-map ("c" . grep-clojure)))
(when (fboundp 'grep-clisp)
(bind-keys :map space-grep-map ("l" . grep-clisp)))
(when (fboundp 'grep-elisp)
(bind-keys :map space-grep-map ("e" . grep-elisp)))
(when (fboundp 'grep-elisp-extended)
(bind-keys :map space-grep-map ("E" . grep-elisp-extended)))
(when (fboundp 'grep-emacs-init)
(bind-keys :map space-grep-map ("i" . grep-emacs-init)))
(when (fboundp 'grep-home-init)
(bind-keys :map space-grep-map ("h" . grep-home-init)))
(when (fboundp 'grep-org)
(bind-keys :map space-grep-map ("o" . grep-org)))
(when (fboundp 'grep-python)
(bind-keys :map space-grep-map ("p" . grep-python)))
(when (fboundp 'grep-racket)
(bind-keys :map space-grep-map ("r" . grep-racket)))
(when (fboundp 'grep-web)
(bind-keys :map space-grep-map ("w" . grep-web)))
(bind-keys :map space-map
:prefix "i"
:prefix-map space-insert-map
:menu-name "Insert Commands"
("d" . insert-date)
("t" . insert-datetime)
("u" . insert-uuid))
(bind-keys :map space-insert-map
:prefix "o"
:prefix-map space-insert-babel-map
:menu-name "Insert Org-Babel Commands"
("b" . org-insert-literate-programming-src)
("c" . org-insert-literate-programming-code-block)
("e" . org-insert-literate-programming-src-emacs-lisp)
("i" . org-insert-literate-programming-init-emacs-block)
("k" . org-insert-literate-programming-src-kotlin)
("n" . org-insert-literate-programming-name)
("p" . org-insert-literate-programming-project-euler-problem-block)
("r" . org-insert-literate-programming-src-racket)
("s" . org-insert-literate-programming-src-sh))
(bind-keys :map space-map
:prefix "m"
:prefix-map space-miscellaneous-map
:menu-name "Miscellaneous Commands"
("c" . emacs-lisp-byte-compile)
("d" . toggle-debug-on-error)
("m" . macrostep-mode)
("s" . toggle-case-fold-search)
("t" . toggle-truncate-lines)
("x" . regexp-builder)
("v" . visual-line-mode))
(bind-keys :map space-miscellaneous-map
:prefix "e"
:prefix-map space-miscellaneous-eval-map
:menu-name "Eval Commands"
("b" . eval-buffer)
("r" . eval-region))
(bind-keys :map space-miscellaneous-map
:prefix "f"
:prefix-map space-miscellaneous-format-map
:menu-name "Format Commands"
("j" . json-pretty-print-buffer)
("x" . xml-format))
(bind-keys :map space-map
:prefix "p"
:prefix-map space-package-map
:menu-name "Package Commands"
("i" . package-install)
("l" . package-list-packages-no-fetch)
("L" . package-list-packages)
("P" . straight-pull-recipe-repositories)
("F" . straight-fetch-all))
(bind-keys :map space-map
:prefix "r"
:prefix-map space-run-map
:menu-name "Run Commands")
(when (and (fboundp 'safe-load) (boundp 'emacs-home-dir))
(defun safe-load-init-elisp ()
(safe-load (file-truename (expand-file-name "init.el" emacs-home-dir))))
(bind-keys :map space-run-map ("i" . safe-load-init-elisp)))
(bind-keys :map space-map
:prefix "t"
:prefix-map space-terminal-map
:menu-name "Terminal Commands"
("a" . ansi-term)
("e" . eshell)
("s" . shell)
("t" . term))
(when (fboundp 'term-bash)
(bind-keys :map space-terminal-map ("b" . term-bash)))
(when (fboundp 'term-zsh)
(bind-keys :map space-terminal-map ("z" . term-zsh)))
(when (fboundp 'vterm)
(bind-keys :map space-terminal-map ("v" . vterm)))
(bind-keys :map space-map
:prefix "z"
:prefix-map space-browse-url-map
:menu-name "Browse URL Commands"
("." . browse-url-at-point)
("b" . browse-url-of-buffer)
("r" . browse-url-of-region)
("u" . browse-url)
("v" . browse-url-of-file)))
(init-message 3 "custom-key-bindings-grouped-prefix-keys")
(custom-key-bindings-grouped-prefix-keys)
(init-message 2 "Key Bindings: Set All Custom Key Bindings")
(defun custom-key-bindings-set-all ()
"Set all custom key bindings."
(init-message 3 "custom-key-bindings-system-keys")
(custom-key-bindings-system-keys)
(init-message 3 "custom-key-bindings-function-keys")
(custom-key-bindings-function-keys)
(init-message 3 "custom-key-bindings-extended-keys")
(custom-key-bindings-extended-keys)
(init-message 3 "custom-key-bindings-movement-keys")
(custom-key-bindings-movement-keys)
(init-message 3 "custom-key-bindings-standard-keys")
(custom-key-bindings-standard-keys)
(init-message 3 "custom-key-bindings-modes-and-modules-keys")
(custom-key-bindings-modes-and-modules-keys)
(init-message 3 "custom-key-bindings-grouped-prefix-keys")
(custom-key-bindings-grouped-prefix-keys))
(init-message 1 "Org Mode")
(init-message 2 "Org Mode: Setup")
(init-message 3 "org")
(use-package org
:straight (:type built-in)
:demand t
:mode (("\\.org\\'" . org-mode)
("\\.org_archive\\'" . org-mode)
("\\.org\\.cpt\\'" . org-mode))
:bind* (("C-c a" . org-agenda)
("C-c c" . org-capture)
("C-c j" . org-babel-tangle-jump-to-org))
:config
(defun org-insert-heading--fix-newline-bug (orig-fun &rest args)
"Fix extra newline bug in org."
(if (= (point) (line-beginning-position))
(let ((start (point)))
(apply orig-fun args)
(goto-char (line-beginning-position))
(while (< (point) start)
(newline))
(goto-char (line-end-position)))
(apply orig-fun args)))
(advice-add 'org-insert-heading :around #'org-insert-heading--fix-newline-bug)
(unless (fboundp 'org-outline-overlay-data)
(defun org-outline-overlay-data (&optional use-markers)
"Return a list of the locations of all outline overlays.
These are overlays with the `invisible' property value `outline'.
The return value is a list of cons cells, with start and stop
positions for each overlay.
If USE-MARKERS is set, return the positions as markers."
(let (beg end)
(org-with-wide-buffer
(delq nil
(mapcar (lambda (x)
(when (eq (overlay-get x 'invisible) 'outline)
(setq beg (overlay-start x)
end (overlay-end x))
(and beg end (> end beg)
(if use-markers
(cons (copy-marker beg)
(copy-marker end t))
(cons beg end)))))
(overlays-in (point-min) (point-max))))))))
(unless (fboundp 'org-set-outline-overlay-data)
(defun org-set-outline-overlay-data (data)
"Create visibility overlays for all positions in DATA.
DATA should have been made by `org-outline-overlay-data'."
(org-with-wide-buffer
(org-show-all)
(dolist (c data) (org-flag-region (car c) (cdr c) t 'outline))))))
(init-message 3 "outline")
(use-package outline
:straight (:type built-in)
:after (org)
:commands (outline-up-heading
outline-forward-same-level
outline-show-subtree)
:config
(advice-add 'outline-up-heading :around #'advice--ignore-errors))
(init-message 2 "Org Mode: Configuration")
(use-package org
:straight (:type built-in)
:custom
(org-directory (file-truename (expand-file-name "~/org")))
(org-adapt-indentation t)
(org-startup-folded t)
(org-odd-levels-only t)
(org-hide-leading-stars t)
(org-replace-disputed-keys t)
(org-startup-with-inline-images t)
(org-blank-before-new-entry '((heading . nil) (plain-list-item . nil)))
(org-ellipsis " ")
(org-special-ctrl-a/e 'reversed)
(org-catch-invisible-edits 'show-and-error)
(org-use-fast-todo-selection t)
(org-treat-S-cursor-todo-selection-as-state-change nil)
(org-display-custom-times t)
(org-time-stamp-custom-formats '("<%Y-%m-%d %a>" . "<%Y-%m-%d %a %H:%M>"))
(org-log-note-headings
'((done . "CLOSING NOTE %t")
(state . "State %-12s %t")
(note . "Note taken on %t")
(reschedule . "Rescheduled from %S on %t")
(delschedule . "Not scheduled, was %S on %t")
(redeadline . "New deadline from %S on %t")
(deldeadline . "Removed deadline, was %S on %t")
(refile . "Refiled on %t")
(clock-out . "")))
:config
(custom-set-faces
`(org-ellipsis ((t (:underline nil))))
`(org-block ((t (:inherit shadow :foreground ,color-foreground)))))
(when window-system
(setq org-file-apps (quote ((auto-mode . emacs)
("\\.mm\\'" . default)
("\\.x?html?\\'" . default)
("\\.pdf\\'" . emacs)))))
(advice-add 'org-refile :after #'org-save-all-org-buffers)
(defun pabbrev-global-mode--org-disable (orig-fun &rest args)
"Turn off pabbrev mode (it interferes with org mode)."
(unless (eq major-mode 'org-mode)
(apply orig-fun args)))
(advice-add 'pabbrev-global-mode :around #'pabbrev-global-mode--org-disable)
(add-hook 'org-shiftup-final-hook #'windmove-up)
(add-hook 'org-shiftleft-final-hook #'windmove-left)
(add-hook 'org-shiftdown-final-hook #'windmove-down)
(add-hook 'org-shiftright-final-hook #'windmove-right)
(setq org-mobile-directory (file-truename (expand-file-name "~/Dropbox/MobileOrg")))
(setq org-mobile-inbox-for-pull (file-truename (expand-file-name "index.org" org-mobile-directory)))
(defun org-update-parent-cookie ()
"Update parent TODO cookies when children entries are killed."
(when (eq major-mode 'org-mode)
(save-mark-and-excursion
(ignore-errors
(org-back-to-heading)
(org-update-parent-todo-statistics)))))
(defun org-kill-src-buffers (&rest args)
"Kill temporary buffers created by `org-src-font-lock-fontify-block'."
(dolist (buffer (buffer-list))
(let ((buffer-name (buffer-name buffer)))
(when (string-prefix-p " org-src-fontification:" buffer-name)
(kill-buffer buffer)))))
(defun org-src-font-lock-fontify-block--kill-src-buffers (lang start end)
"Kill temporary buffers created by `org-src-font-lock-fontify-block'."
(org-kill-src-buffers))
(advice-add 'org-src-font-lock-fontify-block :after #'org-src-font-lock-fontify-block--kill-src-buffers)
(defun before-save-hook--update-last-modified-property ()
"Hook to update last modified property on save."
(when (and buffer-file-name
(string= (file-name-extension buffer-file-name) "org"))
(org-update-last-modified-property)))
(add-hook 'before-save-hook #'before-save-hook--update-last-modified-property)
(defun after-save-hook--generate-init-emacs-elisp-file ()
"Hook to generate init-emacs.el file on save."
(when (and buffer-file-name
(string= (file-truename buffer-file-name) init-emacs-true-file-name))
(if (fboundp 'org-babel-tangle-file-async)
(org-babel-tangle-file-async init-emacs-true-file-name)
(org-babel-tangle-file init-emacs-true-file-name))))
(add-hook 'after-save-hook #'after-save-hook--generate-init-emacs-elisp-file :append))
(init-message 2 "Org Mode: Agenda")
(use-package org
:when (file-exists-p org-directory)
:straight (:type built-in)
:config
(setq org-log-done 'time)
(setq org-agenda-file-regexp "agenda.*\\.org\\'"
org-agenda-files (mapcar (lambda (x) (expand-file-name x (file-name-as-directory org-directory)))
(cl-remove-if-not (lambda (x) (string-match org-agenda-file-regexp x))
(directory-files org-directory))))
(setq org-agenda-span 7)
(setq org-deadline-warning-days 14)
(setq org-agenda-show-all-dates t)
(setq org-agenda-skip-deadline-if-done t)
(setq org-agenda-skip-scheduled-if-done t)
(setq org-agenda-start-on-weekday nil)
(setq org-reverse-note-order t)
(setq org-fast-tag-selection-single-key 'expert)
(setq org-agenda-custom-commands
(quote (("d" todo "DONE" nil)
("w" todo "WAITING" nil)
("W" agenda "" ((org-agenda-ndays 21)))
("A" agenda ""
((org-agenda-skip-function
(lambda ()
(org-agenda-skip-entry-if 'notregexp "\\=.*\\[#A\\]")))
(org-agenda-ndays 1)
(org-agenda-overriding-header "Today's Priority #A tasks: ")))
("u" alltodo ""
((org-agenda-skip-function
(lambda ()
(org-agenda-skip-entry-if 'scheduled 'deadline 'regexp "<[^>\n]+>")))
(org-agenda-overriding-header "Unscheduled TODO entries: "))))))
(when (not (boundp 'org-called-interactively-p))
(defalias 'org-called-interactively-p 'called-interactively-p))
(defun org-agenda-archive-done-tasks ()
"Archive DONE tasks."
(interactive)
(org-map-entries #'org-archive-subtree "/DONE" 'file))
(when (boundp 'org-archive-subtree-save-file-p)
(setq org-archive-subtree-save-file-p t)))
(init-message 2 "Org Mode: Alerts")
(init-message 2 "Org Mode: Modules")
(org-load-modules-maybe t)
(init-message 2 "Org Mode: Functions")
(init-message 3 "Org Mode: Functions: org-get-property-list")
(defun org-get-property-list (&optional property buffer)
"Return an association list of org properties matching PROPERTY in BUFFER.
PROPERTY is used to `string-match' for properties to
return (defaults to \"PROPERTY\"). Multiple properties can be
queried in one call by using a regular expression. (E.g.
\"\\(AUTHOR\\|EMAIL\\|TITLE\\)\")
If BUFFER is nil, current buffer is used."
(let ((property (or property "PROPERTY")))
(with-current-buffer (or buffer (current-buffer))
(org-element-map (org-element-parse-buffer) 'keyword
(lambda (x) (let ((key (org-element-property :key x)))
(when (string-match property key)
(cons key (org-element-property :value x)))))))))
(init-message 3 "Org Mode: Functions: org-get-element-tree")
(defun org-get-element-tree (types &optional buffer)
"Return a tree structure representing the org levels found in
BUFFER for given TYPES.
TYPES is the same symbol or list of symbols used with
`org-element-map'.
If BUFFER is nil, current buffer is used."
(with-current-buffer (or buffer (current-buffer))
(org-element-map (org-element-parse-buffer) types
(lambda (x) (cons (org-element-property :level x)
(org-element-property :raw-value x))))))
(init-message 3 "Org Mode: Functions: org-get-file-data")
(defun org-get-file-data (file &optional path)
"Return tree structure version of given Org FILE.
PATH is an optional list of headlines to match starting from the
top level.
Output format:
(((\"KEY1\" . VALUE1)
(\"KEY2\" . VALUE2)
(\"KEY3\" . VALUE3))
((HEADLINE1)
(HEADLINE2
(HEADLINE21 . BODY21))
(HEADLINE3
(HEADLINE31
(HEADLINE311 . BODY311)
(HEADLINE312 . BODY312))
(HEADLINE32
(HEADLINE321 . BODY321)
(HEADLINE322 . BODY322)))))"
(let* ((property-headline-regexp "^[ \t]*\\** Org$")
(property-regexp "^[ \t]*#\\+\\(.*\\): \\(.*\\)$")
(property-drawer-regexp "[ \t]*:PROPERTIES:.*:END:[ \t]*")
(headline-regexp "^\\(\*+ \\)\\(.*\\)$")
(property-alist nil)
(property-section t)
(level 0)
(tree (cons nil nil))
(start tree)
(stack nil)
(matches path)
(path-level (length path)))
(with-temp-buffer
(insert-file-contents file)
(goto-char (point-min))
(while (not (eobp))
(cond
((and (bobp)
(looking-at property-headline-regexp))
nil)
((and property-section
(looking-at property-regexp))
(let ((key (match-string-no-properties 1))
(value (match-string-no-properties 2)))
(push (cons key value) property-alist)))
((looking-at headline-regexp)
(setq property-section nil)
(let ((headline-level (/ (length (match-string-no-properties 1))
(if org-odd-levels-only 2 1)))
(headline-value (match-string-no-properties 2))
(segment (car path)))
(when (and path
(not matches)
(>= path-level headline-level))
(setq matches path))
(when (or (and (not matches)
(> headline-level path-level))
(string= headline-value (car matches)))
(when (string= headline-value (car matches))
(setq matches (cdr matches)))
(cond
((> headline-level level)
(setcdr tree (cons (cons headline-value nil) nil))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree))
(setq level headline-level))
((= headline-level level)
(setq tree (pop stack))
(setcdr tree (cons (cons headline-value nil) nil))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree)))
((< headline-level level)
(while (< headline-level level)
(setq tree (pop stack))
(setq level (1- level)))
(setq tree (pop stack))
(setcdr tree (cons (cons headline-value nil) nil))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree))
(setq level headline-level))))))
((and (not matches)
(>= level path-level))
(setq property-section nil)
(when (> (length start) 1)
(let ((body "")
(point (point)))
(while (and (not (eobp))
(not (looking-at property-regexp))
(not (looking-at headline-regexp)))
(when (> (length body) 0)
(setq body (concat body "\n")))
(setq body (concat body
(replace-regexp-in-string "^[ \t\n]*" ""
(buffer-substring-no-properties
(line-beginning-position)
(line-end-position)))))
(forward-line 1))
(when (>
(length
(replace-regexp-in-string property-drawer-regexp ""
(replace-regexp-in-string "\n" "" body)))
0)
(setcdr tree (cons (replace-regexp-in-string "[ \t]*$" "" body) nil))
(setq tree (cdr tree)))
(forward-line 0)
(when (> (point) point)
(forward-line -1)))))
(t
(setq property-section nil)))
(forward-line 1))
(cons property-alist (cdr start)))))
(init-message 3 "Org Mode: Functions: org-get-buffer-data")
(defun org-get-buffer-data (buffer &optional path with-markers)
"Return tree structure version of given Org BUFFER.
PATH is an optional list of headlines to match starting from the
top level.
If WITH-MARKERS is non-nil, include `point-marker' after HEADLINE
values in output.
Output format:
(((\"KEY1\" . VALUE1)
(\"KEY2\" . VALUE2)
(\"KEY3\" . VALUE3))
((HEADLINE1)
(HEADLINE2
(HEADLINE21 . BODY21))
(HEADLINE3
(HEADLINE31
(HEADLINE311 . BODY311)
(HEADLINE312 . BODY312))
(HEADLINE32
(HEADLINE321 . BODY321)
(HEADLINE322 . BODY322)))))
Output format if WITH-MARKERS is non-nil:
(((\"KEY1\" . VALUE1)
(\"KEY2\" . VALUE2)
(\"KEY3\" . VALUE3))
((HEADLINE1 . MARKER1)
(HEADLINE2 . MARKER2
(HEADLINE21 . MARKER21 . BODY21))
(HEADLINE3 . MARKER3
(HEADLINE31 . MARKER31
(HEADLINE311 . MARKER311 . BODY311)
(HEADLINE312 . MARKER312 . BODY312))
(HEADLINE32 . MARKER32
(HEADLINE321 . MARKER321 . BODY321)
(HEADLINE322 . MARKER322 . BODY322)))))"
(let* ((property-headline-regexp "^[ \t]*\\** Org$")
(property-regexp "^[ \t]*#\\+\\(.*\\): \\(.*\\)$")
(property-drawer-regexp "[ \t]*:PROPERTIES:.*:END:[ \t]*")
(headline-regexp "^\\(\*+ \\)\\(.*\\)$")
(property-alist nil)
(property-section t)
(level 0)
(tree (cons nil nil))
(start tree)
(stack nil)
(matches path)
(path-level (length path)))
(with-current-buffer buffer
(goto-char (point-min))
(while (not (eobp))
(cond
((and (bobp)
(looking-at property-headline-regexp))
nil)
((and property-section
(looking-at property-regexp))
(let ((key (match-string-no-properties 1))
(value (match-string-no-properties 2)))
(push (cons key value) property-alist)))
((looking-at headline-regexp)
(setq property-section nil)
(let ((headline-level (/ (length (match-string-no-properties 1))
(if org-odd-levels-only 2 1)))
(headline-value (match-string-no-properties 2))
(segment (car path)))
(when (and path
(not matches)
(>= path-level headline-level))
(setq matches path))
(when (or (and (not matches)
(> headline-level path-level))
(string= headline-value (car matches)))
(when (string= headline-value (car matches))
(setq matches (cdr matches)))
(cond
((> headline-level level)
(if with-markers
(setcdr tree (cons (cons (cons headline-value (point-marker)) nil) nil))
(setcdr tree (cons (cons headline-value nil) nil)))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree))
(setq level headline-level))
((= headline-level level)
(setq tree (pop stack))
(if with-markers
(setcdr tree (cons (cons (cons headline-value (point-marker)) nil) nil))
(setcdr tree (cons (cons headline-value nil) nil)))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree)))
((< headline-level level)
(while (< headline-level level)
(setq tree (pop stack))
(setq level (1- level)))
(setq tree (pop stack))
(if with-markers
(setcdr tree (cons (cons (cons headline-value (point-marker)) nil) nil))
(setcdr tree (cons (cons headline-value nil) nil)))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree))
(setq level headline-level))))))
((and (not matches)
(>= level path-level))
(setq property-section nil)
(when (> (length start) 1)
(let ((body "")
(point (point)))
(while (and (not (eobp))
(not (looking-at property-regexp))
(not (looking-at headline-regexp)))
(when (> (length body) 0)
(setq body (concat body "\n")))
(setq body (concat body
(replace-regexp-in-string "^[ \t\n]*" ""
(buffer-substring-no-properties
(line-beginning-position)
(line-end-position)))))
(forward-line 1))
(when (>
(length
(replace-regexp-in-string property-drawer-regexp ""
(replace-regexp-in-string "\n" "" body)))
0)
(setcdr tree (cons (replace-regexp-in-string "[ \t]*$" "" body) nil))
(setq tree (cdr tree)))
(forward-line 0)
(when (> (point) point)
(forward-line -1)))))
(t
(setq property-section nil)))
(forward-line 1))
(cons property-alist (cdr start)))))
(init-message 3 "Org Mode: Functions: org-safe-meta")
(defmacro org-safe-meta-function (org-meta-function safe-function)
"Return SAFE-FUNCTION version of ORG-META-FUNCTION."
`(defun ,(intern safe-function) (&optional arg)
,(concat "Call `" org-meta-function "' ignoring any errors.")
(interactive)
(let ((pos (point)))
(condition-case nil
(,(intern org-meta-function) arg)
('error
(goto-char pos))))))
(defmacro org-safe-shiftmeta-function (org-shiftmeta-function safe-function)
"Return SAFE-FUNCTION version of ORG-SHIFTMETA-FUNCTION."
`(defun ,(intern safe-function) ()
,(concat "Call `" org-shiftmeta-function "' ignoring any errors.")
(interactive)
(let ((pos (point)))
(condition-case nil
(,(intern org-shiftmeta-function))
('error
(goto-char pos))))))
(org-safe-meta-function "org-metaleft" "org-safe-metaleft")
(org-safe-meta-function "org-metaright" "org-safe-metaright")
(org-safe-meta-function "org-metadown" "org-safe-metadown")
(org-safe-meta-function "org-metaup" "org-safe-metaup")
(org-safe-shiftmeta-function "org-shiftmetaleft" "org-safe-shiftmetaleft")
(org-safe-shiftmeta-function "org-shiftmetaright" "org-safe-shiftmetaright")
(org-safe-shiftmeta-function "org-shiftmetadown" "org-safe-shiftmetadown")
(org-safe-shiftmeta-function "org-shiftmetaup" "org-safe-shiftmetaup")
(init-message 3 "Org Mode: Functions: org-sort-multi")
(defun org-sort-multi (&rest sort-types)
"Multiple sorts on a certain level of an outline tree, or plain list items.
SORT-TYPES is a list where each entry is either a character or a
cons pair (BOOL . CHAR), where BOOL is whether or not to sort
case-sensitively, and CHAR is one of the characters defined in
`org-sort-entries-or-items'. Entries are applied in back to front
order.
Example: To sort first by TODO status, then by priority, then by
date, then alphabetically (case-sensitive) use the following
call:
(org-sort-multi '(?o ?p ?t (t . ?a))"
(interactive)
(dolist (x (nreverse sort-types))
(when (characterp x)
(setq x (cons nil x)))
(ignore-errors
(org-sort-entries (car x) (cdr x)))))
(init-message 3 "Org Mode: Functions: org-sort-current")
(defun org-sort-current (&rest sort-types)
"Sort the current org level.
SORT-TYPES is a list where each entry is either a character or a
cons pair (BOOL . CHAR), where BOOL is whether or not to sort
case-sensitively, and CHAR is one of the characters defined in
`org-sort-entries-or-items'. Entries are applied in back to front
order.
If entry at point has TODO and PRIORITY tags, then default
SORT-TYPE is \"?o ?p\" which is to sort by TODO status, then by
priority. Otherwise, default SORT-TYPE is \"?a\" which is to sort
alphabetically."
(interactive)
(when (string= mode-name "Org")
(let ((sort-types (or sort-types
(if (and (org-entry-get nil "TODO")
(org-entry-get nil "PRIORITY"))
'(?o ?p)
'((nil . ?a))))))
(save-mark-and-excursion
(goto-char (line-beginning-position))
(cl-case (car (org-element-at-point))
('headline
(condition-case nil
(outline-up-heading 1)
('error (forward-line 0)))
(let ((beg (point)))
(while (and (not (bobp)) (not (eobp)) (<= (point) beg))
(condition-case nil
(outline-forward-same-level 1)
('error
(condition-case nil
(outline-up-heading 1)
('error (goto-char (point-max)))))))
(unless (> (point) beg)
(goto-char (point-max)))
(let ((end (point)))
(goto-char beg)
(apply #'org-sort-multi sort-types)
(goto-char end)
(when (eobp)
(forward-line -1))
(when (looking-at "^\\s-*$")
(delete-line))
(goto-char beg)
(dotimes (x 2) (org-cycle)))))
('paragraph
(let* ((plist (cadr (org-element-at-point)))
(beg (plist-get plist :contents-begin))
(end (plist-get plist :contents-end)))
(sort-lines nil beg end)))
(t
(org-sort-list nil ?a)))))))
(defun org-fill-element--adapt-indentation (orig-fun &rest args)
"Modify `fill-column' based on current org block indentation."
(with-syntax-table org-mode-transpose-word-syntax-table
(let* ((element (save-excursion (end-of-line) (org-element-at-point)))
(type (org-element-type element)))
(if (or (eq type 'paragraph)
(eq type 'comment-block)
(eq type 'comment))
(let ((indent-min fill-column)
(fc fill-column)
(point (point)))
(while (and (not (bobp))
(eq type (org-element-type (org-element-at-point)))
(forward-line -1)))
(unless (eq type (org-element-type (org-element-at-point)))
(forward-line 1))
(while (and (not (eobp))
(eq type (org-element-type (org-element-at-point))))
(when (and (not (= (point-at-bol) (point-at-eol)))
(re-search-forward "^ *" (line-end-position) :noerror)
(< (current-column) indent-min))
(setq indent-min (current-column)))
(forward-line 1))
(goto-char point)
(let ((fill-column (+ fill-column indent-min)))
(apply orig-fun args)))
(apply orig-fun args)))))
(advice-add 'org-fill-element :around #'org-fill-element--adapt-indentation)
(init-message 3 "Org Mode: Functions: org-copy-to-clipboard")
(defun org-copy-to-clipboard (&optional beg end)
"Copy `org-mode' region (or entire buffer) to the `kill-ring'
and X clipboard, indenting and cleaning up links."
(interactive)
(let ((beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max))))
(buffer (current-buffer)))
(deactivate-mark)
(with-temp-buffer
(insert-buffer-substring buffer beg end)
(untabify (point-min) (point-max))
(let ((indent-min fill-column))
(goto-char (point-min))
(while (re-search-forward "^\\(*+ \\| *- \\)" nil :noerror)
(replace-match (concat (make-string (- (match-end 0) (match-beginning 0) 2) ? ) "- "))
(when (< (- (current-column) 2) indent-min)
(setq indent-min (- (current-column) 2)))
(goto-char (line-end-position)))
(when (= indent-min fill-column)
(goto-char (point-min))
(while (not (eobp))
(when (and (not (= (point-at-bol) (point-at-eol)))
(re-search-forward "^ *" (line-end-position) :noerror)
(< (current-column) indent-min))
(setq indent-min (current-column)))
(forward-line 1)))
(when (> indent-min 0)
(goto-char (point-min))
(while (re-search-forward (concat "^" (make-string indent-min ? )) nil :noerror)
(replace-match "")
(goto-char (line-end-position))))
(goto-char (point-min))
(while (re-search-forward "\\[\\[\\(.*?\\)\\]\\[.*?\\]\\]" nil :noerror)
(replace-match (match-string 1)))
(clipboard-kill-region (point-min) (point-max))))))
(init-message 3 "Org Mode: Functions: org-fix-custom-ids")
(defun org-fix-custom-ids (&optional beg end)
"Fix CUSTOM_ID tags in region (or entire buffer), by lower casing them and
replacing spaces with dashes."
(interactive)
(let ((case-fold-search t)
(beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max))))
(buffer (current-buffer)))
(deactivate-mark)
(save-mark-and-excursion
(save-restriction
(save-match-data
(narrow-to-region beg end)
(goto-char (point-min))
(while (re-search-forward "^[ \t]*:PROPERTIES:$" nil :noerror)
(goto-char (line-beginning-position))
(forward-char 1)
(while (and (not (looking-at "^[ \t]*:END:$"))
(re-search-forward "^[ \t]*:CUSTOM_ID: " (line-end-position) :noerror))
(let ((pos (point)))
(downcase-region pos (line-end-position))
(while (re-search-forward " " (line-end-position) :noerror)
(replace-match "-"))
(goto-char pos)
(while (re-search-forward ":" (line-end-position) :noerror)
(replace-match "-"))
(goto-char (line-beginning-position))
(forward-line 1)))))))))
(init-message 3 "Org Mode: Functions: org-update-last-modified-property")
(defun org-update-last-modified-property ()
"Update value of LAST-PROPERTY property to current timestamp,
if found and buffer has been modified."
(when (buffer-modified-p)
(save-mark-and-excursion
(save-match-data
(let ((case-fold-search t))
(goto-char (point-min))
(when (re-search-forward "^[ \t]*#\\+LAST_MODIFIED: \\(.*\\)$" nil :noerror)
(replace-match (format-time-string "%Y-%m-%d %H:%M" nil t) t t nil 1)))))))
(init-message 3 "Org Mode: Functions: org-export-to-json")
(use-package json
:straight (:type built-in)
:commands (json-encode)
:config
(defun org-export-to-json (&optional output beg end)
"Export the outline as JSON.
IF OUTPUT is nil, a default output buffer will be created and exported into.
If OUTPUT is non-nil, create a buffer with that name and export to it.
If OUTPUT is the symbol 'string, exported data is returned as a string.
If BEG and END are given, only that region is exported."
(interactive)
(let ((beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max)))))
(deactivate-mark)
(save-mark-and-excursion
(save-restriction
(narrow-to-region beg end)
(let ((tree (org-element-parse-buffer)))
(org-element-map tree (append org-element-all-elements
org-element-all-objects
'(plain-text))
(lambda (x)
(when (org-element-property :parent x)
(org-element-put-property x :parent "none"))
(when (org-element-property :structure x)
(org-element-put-property x :structure "none"))))
(if (eq output 'string)
(json-encode tree)
(let ((buffer (generate-new-buffer (or output (concat buffer-file-name ".json")))))
(set-buffer buffer)
(insert (json-encode tree))
(switch-to-buffer buffer)))))))))
(init-message 3 "Org Mode: Functions: org-toggle-headline-checkbox")
(defun org-toggle-headline-checkbox (&optional beg end)
"Toggle between an Org headline and checkbox on current line or region."
(interactive)
(let ((beg (or beg (if (use-region-p) (region-beginning) (point))))
(end (or end (if (use-region-p) (region-end) (point)))))
(deactivate-mark)
(save-mark-and-excursion
(save-match-data
(goto-char beg)
(while (<= (point) end)
(goto-char (line-beginning-position))
(if (re-search-forward "^\\*+ " (line-end-position) :noerror)
(replace-match (concat
(make-string (- (point) (line-beginning-position) 2) ? )
"- [ ] "))
(if (re-search-forward "^ *- \\[ \\] " (line-end-position) :noerror)
(replace-match (concat
(make-string (- (point) (line-beginning-position) 5) ?*)
" "))))
(forward-line 1))))))
(init-message 3 "Org Mode: Functions: org-table-remove-commas")
(defun org-table-remove-commas ()
"Remove all commas in current Org table."
(interactive)
(save-mark-and-excursion
(save-match-data
(goto-char (org-table-begin))
(while (re-search-forward "," (org-table-end) :noerror)
(replace-match "")))))
(init-message 3 "Org Mode: Functions: org-days-between-dates")
(defun org-days-between-dates (beg end)
"Return the number of days between BEG (inclusive) and END (exclusive).
Where BEG and END dates are in one of these formats:
YYYY
YYYYMM
YYYYMMDD
YYYY-MM
YYYY-MM-DD"
(cl-labels
((convert-date (date)
(calendar-absolute-from-gregorian (org-date-to-gregorian date)))
(pad-date (date)
(let ((date (if (stringp date) date (number-to-string date))))
(cl-case (length date)
(4 (concat date "-01-01"))
(6 (concat (substring date 0 4) "-" (substring date 4) "-01"))
(7 (concat date "-01"))
(8 (concat (substring date 0 4) "-" (substring date 4 6) "-" (substring date 6)))
(10 date)))))
(let ((beg (convert-date (pad-date beg)))
(end (convert-date (pad-date end)))
x)
(when (> beg end)
(setq x beg
beg end
end x))
(- end beg))))
(init-message 3 "Org Mode: Functions: org-babel-tangle-block")
(defun org-babel-tangle-block ()
"Tangle blocks for the tangle file of the block at point."
(interactive)
(org-babel-tangle '(16)))
(init-message 3 "Org Mode: Functions: org-babel-tangle-file-async")
(defun org-babel-tangle-file-async (file &optional target-file lang-re attempt)
"Asynchronous version of `org-babel-tangle-file'.
ATTEMPT is used internally to determine how many tangle attempts have been made."
(interactive)
(let ((attempt (if attempt (1+ attempt) 1))
(lock-file (expand-file-name "emacs-tangle-file-async-lock-file"
temporary-file-directory))
(run-file (expand-file-name "emacs-tangle-file-async-run-file"
temporary-file-directory)))
(if (file-exists-p lock-file)
(progn
(message "Tangle running: %s" file)
(when (not (file-exists-p run-file))
(make-empty-file run-file)))
(progn
(message "Tangle started: %s" file)
(make-empty-file lock-file)
(eval
`(async-spinner
(lambda ()
(require 'ob-tangle)
(when (not (file-exists-p ,run-file))
(make-empty-file ,run-file))
(while (file-exists-p ,run-file)
(delete-file ,run-file)
(org-babel-tangle-file ,file ,target-file ,lang-re)))
(lambda (result)
(message "Tangle finished: %s" ,file)
(delete-file ,lock-file))))))))
(init-message 3 "Org Mode: Functions: org-copy-tangled-sections")
(defun org-copy-tangled-sections (source-file target-file sections &optional prefix)
"Copy section blocks from tangled SOURCE-FILE to TARGET-FILE
that match the names in SECTIONS.
If PREFIX is non-nil, insert it verbatim at the top of the
TARGET-FILE."
(let ((buffer (find-file-noselect target-file)))
(set-buffer buffer)
(erase-buffer)
(insert ";; -*- mode: emacs-lisp; lexical-binding: t; no-byte-compile: t -*-\n")
(insert ";;==============================================================================\n")
(insert ";;; " (file-name-nondirectory target-file) "\n")
(insert ";;\n")
(insert ";; This file was generated from " (file-name-nondirectory source-file) ".\n")
(insert ";;==============================================================================\n\n")
(when prefix
(insert (concat prefix "\n")))
(with-temp-buffer
(insert-file-contents source-file)
(dolist (section sections)
(goto-char (point-min))
(re-search-forward (concat "^[ \t]*" section "$"))
(goto-char (line-beginning-position))
(forward-line -1)
(unless (looking-at "^[ \t]*;;--")
(forward-line 1))
(let ((beg (point))
(end (progn
(re-search-forward (concat "^[ \t]*;; .* ends here$"))
(goto-char (line-beginning-position))
(forward-line 1)
(point))))
(append-to-buffer buffer beg end))))
(goto-char (point-min))
(while (re-search-forward "^[ \t]*(init-message [0-9] \"\\(.*\\)\")$" nil :noerror)
(delete-region (1- (line-beginning-position)) (1+ (line-end-position))))
(goto-char (point-min))
(while (re-search-forward "^[ \t]*;; .* ends here$" nil :noerror)
(goto-char (line-beginning-position))
(delete-region (line-beginning-position) (line-end-position)))
(goto-char (point-max))
(insert ";;==============================================================================\n")
(insert ";;; " (file-name-nondirectory target-file) " ends here\n")
(insert ";;==============================================================================\n")
(save-buffer)
(kill-buffer buffer)))
(init-message 3 "Org Mode: Functions: org-screenshot")
(defun org-screenshot ()
"Take a screenshot into a time stamped unique-named file in the
same directory as the org-buffer and insert a link to this file."
(interactive)
(let ((file-name
(concat (buffer-file-name)
"_"
(format-time-string "%Y%m%d_%H%M%S")
".png")))
(call-process "import" nil nil nil file-name)
(insert (concat "[[" file-name "]]\n"))))
(init-message 2 "Org Mode: Hook")
(defun custom-org-mode-hook ()
(bind-keys :map org-mode-map
([remap org-metaleft] . org-safe-metaleft)
([remap org-metaright] . org-safe-metaright)
([remap org-metadown] . org-safe-metadown)
([remap org-metaup] . org-safe-metaup)
([remap org-shiftmetaleft] . org-safe-shiftmetaleft)
([remap org-shiftmetaright] . org-safe-shiftmetaright)
([remap org-shiftmetadown] . org-safe-shiftmetadown)
([remap org-shiftmetaup] . org-safe-shiftmetaup))
(bind-keys :map org-mode-map
("M-n" . scroll-up)
("M-p" . scroll-down)
("M-W" . org-copy-to-clipboard)
("C-M-b" . org-metaleft)
("C-M-f" . org-metaright)
("C-M-n" . org-metadown)
("C-M-p" . org-metaup)
("C-M-B" . org-shiftmetaleft)
("C-M-F" . org-shiftmetaright)
("C-M-N" . org-shiftmetadown)
("C-M-P" . org-shiftmetaup)
("C-c a" . org-agenda)
("C-c l" . org-store-link)
("C-c m" . org-insert-todo-heading)
("C-c p" . org-priority) ("C-c s" . org-sort-current) ("C-c z" . org-agenda-archive-done-tasks) ("C-c C-j" . consult-outline) ("C-c C-z" . geiser-mode-switch-to-repl) ("C-c C-x C-l" . org-toggle-link-display) ("C-c C-x t" . org-toggle-headline-checkbox) ("C-c C-x T" . org-toggle-literate-programming-code-block) ("C-c C-x F" . org-fix-literate-programming-heading) ("C-c C-v q" . org-babel-tangle-block) ("C-c C-v C-q" . org-babel-tangle-block)) (custom-key-bindings-movement-keys org-mode-map)
(setq indent-tabs-mode nil)
(turn-off-auto-fill)
(auto-save-mode nil)
)
(use-package org
:straight (:type built-in)
:hook (org-mode . custom-org-mode-hook))
(init-message 2 "Org Mode: Babel")
(init-message 3 "Org Mode: Babel: Setup")
(use-package org
:straight (:type built-in)
:config
(require 'ob-shell nil :no-error))
(use-package ob-async
:straight t
:after (org))
(setq org-use-property-inheritance t
org-babel-use-quick-and-dirty-noweb-expansion t
org-src-tab-acts-natively t
org-src-preserve-indentation nil
org-src-ask-before-returning-to-edit-buffer nil
org-src-strip-leading-and-trailing-blank-lines t
org-src-window-setup 'current-window
org-confirm-babel-evaluate nil
org-confirm-shell-link-function nil
org-confirm-elisp-link-function nil)
(set-default 'org-export-backends '(ascii html icalendar latex md odt org))
(add-hook 'org-babel-after-execute-hook #'org-display-inline-images :append)
(init-message 3 "Org Mode: Babel: Structure Templates")
(use-package org-tempo
:straight (:type built-in)
:custom
(org-tempo-keywords-alist
'(
("A" . "ascii")
("H" . "html")
("i" . "index")
("L" . "latex")
("n" . "name")))
(org-structure-template-alist
'(
("c" . "center")
("C" . "comment")
("e" . "example")
("E" . "export")
("ea" . "export ascii")
("eh" . "export html")
("el" . "export latex")
("o" . "src org")
("q" . "quote")
("s" . "src")
("sel" . "src emacs-lisp")
("sk" . "src kotlin")
("spy" . "src python")
("sql" . "src sql")
("sr" . "src racket")
("ssh" . "src sh")
("ssu" . "src sh :dir /sudo::")
("t" . "src text")
("v" . "verse")))
:config
(defun org-tempo-add-block (entry)
"Add block entry from `org-structure-template-alist'."
(let* ((key (format "<%s" (car entry)))
(name (cdr entry))
(name-parts (split-string name " "))
(upcase-type (upcase (car name-parts)))
(upcase-name (mapconcat 'identity (cons upcase-type (cdr name-parts)) " "))
(special (member name '("src" "export"))))
(tempo-define-template (format "org-%s" (replace-regexp-in-string " " "-" name))
`(,(format "#+BEGIN_%s%s" upcase-name (if special " " ""))
,(when special 'p) '> n '> ,(unless special 'p) n
,(format "#+END_%s" upcase-type)
>)
key
(format "Insert a %s block" upcase-name)
'org-tempo-tags)))
(defun org-tempo-add-keyword (entry)
"Add keyword entry from `org-tempo-keywords-alist'."
(let* ((key (format "<%s" (car entry)))
(name (cdr entry))
(upcase-name (upcase name)))
(tempo-define-template (format "org-%s" (replace-regexp-in-string " " "-" name))
`(,(format "#+%s: " upcase-name) p '>)
key
(format "Insert a %s keyword" upcase-name)
'org-tempo-tags)))
(defun org-tempo--include-file ()
"Add #+include: and a file name."
(let ((inhibit-quit t))
(unless (with-local-quit
(prog1 t
(insert
(format "#+INCLUDE: %S "
(file-relative-name
(read-file-name "Include file: "))))))
(insert "<I")
(setq quit-flag nil))))
(org-tempo-add-templates))
(init-message 3 "Org Mode: Babel: Edit Source")
(use-package org
:straight (:type built-in)
:commands (org-edit-src-code
org-edit-src-exit)
:config
(require 'org-src)
(add-hook 'org-src-mode-hook #'custom-key-bindings-set-all)
(defun org-edit-src-exit--update-last-modified ()
"Update LAST_MODIFIED property timestamp on source update."
(org-update-last-modified-property))
(advice-add 'org-edit-src-exit :before #'org-edit-src-exit--update-last-modified)
(defun org-edit-src--recenter (&optional arg)
"Recenter when entering/exiting special editors."
(recenter))
(advice-add 'org-edit-special :after #'org-edit-src--recenter)
(advice-add 'org-edit-src-exit :after #'org-edit-src--recenter))
(init-message 3 "Org Mode: Babel: Tangle Case-Sensitive")
(defun org-babel-tangle-collect-blocks--case-sensitive (orig-fun &rest args)
"Set `case-fold-search' to nil so `string-match' calls are case-sensitive."
(let ((case-fold-search nil))
(apply orig-fun args)))
(advice-add 'org-babel-tangle-collect-blocks :around #'org-babel-tangle-collect-blocks--case-sensitive)
(init-message 3 "Org Mode: Babel: Tangle Update Timestamps")
(defun org-babel-post-tangle-hook--time-stamp ()
"Update timestamps in tangled files."
(time-stamp)
(save-buffer))
(add-hook 'org-babel-post-tangle-hook #'org-babel-post-tangle-hook--time-stamp)
(init-message 3 "Org Mode: Babel: Tangle Delete Trailing Whitespace")
(defun org-babel-post-tangle-hook--delete-trailing-whitespace ()
"Delete trailing whitespace in tangled files."
(delete-trailing-whitespace (point-min) (point-max))
(save-buffer))
(add-hook 'org-babel-post-tangle-hook #'org-babel-post-tangle-hook--delete-trailing-whitespace)
(init-message 3 "Org Mode: Babel: Racket")
(use-package ob-racket
:straight (ob-racket
:type git :host github :repo "hasu/emacs-ob-racket"
:files ("*.el" "*.rkt"))
:after (org)
:config
(add-hook 'ob-racket-pre-runtime-library-load-hook
#'ob-racket-raco-make-runtime-library)
(defvar org-babel-racket-command "racket")
(defvar org-babel-default-header-args:racket '())
(defvar org-babel-header-args:racket '((package . :any)))
(defun org-babel-execute:racket (body params)
"Execute a block of Racket Scheme code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block.
This function is called by `org-babel-execute-src-block'."
(let ((result
(if (with-temp-buffer
(insert (org-babel-expand-body:lisp body params))
(goto-char (point-min))
(re-search-forward "^[ \t]*#lang +\\([^ ]+\\)" nil :noerror))
(let ((src-file (org-babel-src-file "racket-" ".rkt")))
(with-temp-file src-file
(insert (org-babel-expand-body:lisp body params)))
(org-babel-eval (concat org-babel-racket-command " " src-file) ""))
(funcall (if (member "output" (cdr (assq :result-params params)))
(lambda (x) (cdr (assq (intern "output") x)))
(lambda (x) (cdr (assq (intern "result") x))))
(with-temp-buffer
(insert (org-babel-expand-body:lisp body params))
(racket-mode)
(goto-char (point-min))
(while (and (not (eobp))
(looking-at "^[ \t]*\\(;\\|$\\)"))
(forward-line 1))
(unless (eobp)
(if (fboundp 'geiser-eval-region)
(geiser-eval-region (point-min) (point-max) nil :raw)
(error "geiser-eval-region not defined"))))))))
(org-babel-reassemble-table
(org-babel-result-cond (cdr (assq :result-params params))
result
(condition-case nil
(read (org-babel-lisp-vector-to-list result))
(error result)))
(org-babel-pick-name (cdr (assq :colname-names params))
(cdr (assq :colnames params)))
(org-babel-pick-name (cdr (assq :rowname-names params))
(cdr (assq :rownames params)))))))
(init-message 3 "Org Mode: Babel: Java")
(use-package org
:straight (:type built-in)
:commands (org-babel-execute:java)
:config
(when (require 'ob-java nil :no-error)
(defun org-babel-execute:java (body params)
"Execute a block of Java code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block."
(let* ((classname (or (cdr (assoc :classname params))
(error ":classname parameter is required")))
(packagename (file-name-directory classname))
(src-file (concat classname ".java"))
(javacflags (or (cdr (assoc :javacflags params)) ""))
(javaflags (or (cdr (assoc :javaflags params)) ""))
(full-body (org-babel-expand-body:generic body params)))
(unless (or (not packagename) (file-exists-p packagename))
(make-directory packagename 'parents))
(with-temp-file src-file
(insert full-body)
(org-babel-eval (concat org-babel-java-compiler " " javacflags " " src-file) ""))
(let ((result (org-babel-eval (concat org-babel-java-command " " javaflags " " classname) "")))
(org-babel-reassemble-table
(org-babel-result-cond (cdr (assoc :result-params params))
(org-babel-read result)
(let ((temp-file (org-babel-temp-file "java-")))
(with-temp-file temp-file
(insert result)
(org-babel-import-elisp-from-file temp-file))))
(org-babel-pick-name (cdr (assoc :colname-names params))
(cdr (assoc :colnames params)))
(org-babel-pick-name (cdr (assoc :rowname-names params))
(cdr (assoc :rownames params)))))))))
(init-message 3 "Org Mode: Babel: Kotlin")
(use-package ob-kotlin
:straight t
:after (org kotlin-mode)
:commands (org-babel-execute:kotlin)
:functions (flycheck-mode
kotlin-send-buffer
org-babel-kotlin-command)
:defines (org-babel-kotlin-compiler)
:config
(defcustom org-babel-kotlin-command "kotlin"
"Name of the kotlin command.
May be either a command in the path, like kotlin or an absolute
path name, like /usr/local/bin/kotlin parameters may be used,
like kotlin -verbose"
:group 'org-babel
:type 'string)
(defcustom org-babel-kotlin-compiler "kotlinc"
"Name of the kotlin compiler.
May be either a command in the path, like kotlinc or an absolute
path name, like /usr/local/bin/kotlinc parameters may be used,
like kotlinc -verbose"
:group 'org-babel
:type 'string)
(defun org-babel-execute:kotlin (body params)
"If main function exists, then compile code and run jar
otherwise, run code in `kotlin-repl'."
(let* ((classname (or (cdr (assq :classname params)) "main"))
(src-file (org-babel-temp-file classname ".kt"))
(jar-file (concat (file-name-sans-extension src-file) ".jar"))
(cmpflag (or (cdr (assq :cmpflag params)) ""))
(cmdline (or (cdr (assq :cmdline params)) ""))
(full-body (org-babel-expand-body:generic body params)))
(if (or (string-match "fun main(args: Array<String>)" full-body)
(string-match "fun main()" full-body))
(progn
(with-temp-file src-file (insert full-body))
(org-babel-eval
(concat org-babel-kotlin-compiler " " cmpflag " " src-file " -include-runtime -d " jar-file) "")
(message (org-babel-eval (concat org-babel-java-command " " cmdline " -jar " jar-file) "")))
(with-temp-buffer
(insert body)
(kotlin-send-buffer))))))
(init-message 3 "Org Mode: Babel: Python")
(use-package org
:straight (:type built-in)
:after (python-mode)
:commands (org-babel-execute:python)
:config
(when (require 'ob-python nil :no-error)
(defun org-babel-execute:python (body params)
"Execute a block of Python code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block.
This function is called by `org-babel-execute-src-block'.
Note: This function only works with an iPython shell if it has
the autoindent feature turned off. Add '--no-autoindent' to
`py-ipython-command-args' to set this when an iPython process is
created."
(let* ((org-babel-python-command (or (cdr (assq :python params))
org-babel-python-command))
(session-name (cdr (assq :session params)))
(session (when (and session-name (not (string= session-name "none")))
(org-babel-python-initiate-session session)))
(result-params (cdr (assq :result-params params)))
(result-type (cdr (assq :result-type params)))
(return-val (when (and (eq result-type 'value) (not session))
(cdr (assq :return params))))
(preamble (cdr (assq :preamble params)))
(process (get-process python-shell-buffer-name))
(full-body
(org-babel-expand-body:generic
(concat body (if return-val (format "\nreturn %s" return-val) ""))
params (org-babel-variable-assignments:python params)))
(result (cond
(session
(org-babel-python-evaluate-session
session full-body result-type result-params))
(process
(process-send-string process (concat full-body "\n\n"))
(display-buffer (process-buffer process) t))
(t
(org-babel-python-evaluate-external-process
full-body result-type result-params preamble)))))
(org-babel-reassemble-table
result
(org-babel-pick-name (cdr (assq :colname-names params))
(cdr (assq :colnames params)))
(org-babel-pick-name (cdr (assq :rowname-names params))
(cdr (assq :rownames params))))))))
(init-message 3 "Org Mode: Babel: Rust")
(use-package ob-rust
:straight t
:after (org rust-mode)
:commands (org-babel-execute:rust)
:functions (flycheck-mode
rust-send-buffer
org-babel-rust-command)
:config
(when (require 'ob-rust nil :no-error)
(defun org-babel-execute:rust (body params)
"Execute a block of Rust code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block.
This function is called by `org-babel-execute-src-block'."
(let* ((tmp-src-file (org-babel-temp-file "rust-src-" ".rs"))
(tmp-run-file (org-babel-temp-file "rust-run-"))
(processed-params (org-babel-process-params params))
(_flags (cdr (assoc :flags processed-params)))
(_args (cdr (assoc :args processed-params)))
(coding-system-for-read 'utf-8) (coding-system-for-write 'utf-8)
(wrapped-body
(save-match-data
(if (string-match "fn main()" body)
body
(if (string-match "fn \\(.*_test\\)()" body)
(concat body "\n\nfn main() {\n" (match-string 1 body) "();\n}")
(concat "fn main() {\n" body "\n}"))))))
(with-temp-file tmp-src-file (insert wrapped-body))
(let ((result
(org-babel-eval
(format "rustc -o %s %s && %s" tmp-run-file tmp-src-file tmp-run-file)
"")))
(when result
(org-babel-reassemble-table
(if (or (member "table" (cdr (assoc :result-params processed-params)))
(member "vector" (cdr (assoc :result-params processed-params))))
(let ((tmp-file (org-babel-temp-file "rust-")))
(with-temp-file tmp-file (insert (org-babel-trim result)))
(org-babel-import-elisp-from-file tmp-file))
(org-babel-read (org-babel-trim result) t))
(org-babel-pick-name
(cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
(org-babel-pick-name
(cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))))))
(init-message 3 "Org Mode: Babel: V")
(defvar org-babel-tangle-lang-exts)
(add-to-list 'org-babel-tangle-lang-exts '("v" . "v"))
(defvar org-babel-v-command "v")
(defvar org-babel-default-header-args:v '())
(defvar org-babel-header-args:v '((package . :any)))
(defun org-babel-execute:v (body params)
"Execute a block of V code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block.
This function is called by `org-babel-execute-src-block'."
(let* ((tmp-src-file (org-babel-temp-file "v-src-" ".v"))
(tmp-run-file (org-babel-temp-file "v-run-"))
(processed-params (org-babel-process-params params))
(_flags (cdr (assoc :flags processed-params)))
(_args (cdr (assoc :args processed-params)))
(coding-system-for-read 'utf-8) (coding-system-for-write 'utf-8)
(wrapped-body
(save-match-data
(if (string-match "fn main()" body)
body
(if (string-match "fn \\(test_.*\\)()" body)
(let ((start 0)
tests)
(while (string-match "fn \\(test_.*\\)()" body start)
(push (match-string 1 body) tests)
(setq start (match-end 0)))
(concat body
"\n\nfn main() {\n"
(apply #'concat (nreverse tests))
"()\n}"))
body)))))
(with-temp-file tmp-src-file (insert wrapped-body))
(let ((result
(org-babel-eval
(format "v -o %s %s && %s" tmp-run-file tmp-src-file tmp-run-file)
"")))
(when result
(org-babel-reassemble-table
(if (or (member "table" (cdr (assoc :result-params processed-params)))
(member "vector" (cdr (assoc :result-params processed-params))))
(let ((tmp-file (org-babel-temp-file "v-")))
(with-temp-file tmp-file (insert (org-babel-trim result)))
(org-babel-import-elisp-from-file tmp-file))
(org-babel-read (org-babel-trim result) t))
(org-babel-pick-name
(cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
(org-babel-pick-name
(cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))))
(init-message 3 "Org Mode: Babel: Basic (Commander X16)")
(require 'basic)
(defvar org-babel-tangle-lang-exts)
(add-to-list 'org-babel-tangle-lang-exts '("basic" . "bas"))
(defvar org-babel-basic-command "x16emu -rom /usr/share/x16-rom/rom.bin")
(defun org-babel-execute:basic (body params)
"Execute a block of BASIC code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block."
(let ((src-file (org-babel-temp-file "basic-" ".bas")))
(with-temp-file src-file
(insert (org-babel-expand-body:generic body params)))
(org-babel-eval (concat org-babel-basic-command " -bas " src-file " -run &") "")))
(init-message 3 "Org Mode: Babel: Assembly Language (Commander X16)")
(defvar org-babel-tangle-lang-exts)
(add-to-list 'org-babel-tangle-lang-exts '("asm" . "asm"))
(defun org-babel-execute:asm (body params)
"Execute a block of Assembly Language code with Babel.
BODY is the contents of the block, as a string. PARAMS is a
property list containing the parameters of the block."
(let* ((base-file (org-babel-temp-file "asm-"))
(src-file (concat base-file ".asm"))
(list-file (concat base-file ".lst"))
(output-file (concat base-file ".prg"))
(defines (cdr (assoc :defines params)))
(cmpflag (or (cdr (assq :cmpflag params)) ""))
(cmdline (or (cdr (assq :cmdline params)) ""))
(x16emu (string= (cdr (assq :x16emu params)) "yes"))
(compile-command (concat "acme"
(if cmpflag (concat " " cmpflag) "")
(if defines (concat " -D " defines) "")
" --symbollist " list-file
" --outfile " output-file
" " src-file))
(run-command (when x16emu
(concat "x16emu -keymap en-us"
(if cmdline (concat " " cmdline) "")
" -prg " output-file " -run &"))))
(with-temp-file src-file
(insert (org-babel-expand-body:generic body params)))
(message (format "Compiling: %s" compile-command))
(org-babel-eval compile-command "")
(when x16emu
(message (format "Running: %s" run-command))
(org-babel-eval run-command ""))))
(init-message 3 "Org Mode: Babel: PlantUML")
(setq org-plantuml-jar-path "~/dev/java/lib/plantuml.jar")
(init-message 3 "Org Mode: Babel: Load Languages")
(org-babel-do-load-languages
'org-babel-load-languages '((clojure . t)
(css . t)
(ditaa . t)
(dot . t)
(emacs-lisp . t)
(gnuplot . t)
(java . t)
(js . t)
(kotlin . t)
(lisp . t)
(lua . t)
(makefile . t)
(org . t)
(perl . t)
(plantuml . t)
(python . t)
(racket . t)
(ruby . t)
(rust . t)
(scheme . t)
(shell . t)
(sql . t)))
(add-to-list 'org-src-lang-modes '("dot" . graphviz-dot))
(add-to-list 'org-src-lang-modes '("racket" . scheme))
(init-message 2 "Org Mode: Babel Functions")
(init-message 3 "Org Mode: Babel Functions: org-generate-custom-id-from-title")
(defun org-generate-custom-id-from-title (title)
"Generate a proper `org-mode' CUSTOM_ID property from a given TITLE."
(replace-regexp-in-string
(rx (seq "-" "-")) "-"
(replace-regexp-in-string
(rx (seq "-" eol)) ""
(replace-regexp-in-string
(rx (seq bol "-")) ""
(replace-regexp-in-string
(rx (any ".")) "-dot-"
(replace-regexp-in-string
(rx (any " " "_" "/")) "-"
(replace-regexp-in-string
(rx (not (any alnum space "-" "_" "." "/"))) ""
(downcase title))))))))
(init-message 3 "Org Mode: Babel Functions: org-fix-literate-programming-heading")
(defun org-fix-literate-programming-heading ()
"Fix 'literate programming' heading of current org section.
Reset the CUSTOM_ID property, title comment, and `init-message'."
(interactive "*")
(save-window-excursion
(save-mark-and-excursion
(save-match-data
(org-with-wide-buffer
(goto-char (line-beginning-position))
(while (not (looking-at "^\*+ "))
(forward-line -1))
(let* ((case-fold-search t)
(start (point))
(count (length (progn
(re-search-forward "^\\(\*+\\) " (line-end-position))
(match-string-no-properties 1))))
(level (/ (1+ count) (if org-odd-levels-only 2 1)))
headings)
(goto-char start)
(while (and (not (bobp))
(> count 0))
(let ((regexp (concat "^\*\\{" (number-to-string count) "\\} \\(.*\\)$")))
(while (and (not (bobp))
(not (looking-at regexp)))
(forward-line -1))
(when (re-search-forward regexp (line-end-position))
(push (replace-regexp-in-string "+" "" (match-string-no-properties 1)) headings)
(setq count (- count (if org-odd-levels-only 2 1))))))
(let ((id (mapconcat (lambda (x) (org-generate-custom-id-from-title x))
headings "-"))
(title (mapconcat #'(lambda (x) x) headings ": ")))
(goto-char start)
(org-set-property "CUSTOM_ID" id)
(forward-line 1)
(indent-region (point) (re-search-forward "^[ \t]*:END:$"))
(let ((end (if (re-search-forward "^\*+ " nil :noerror) (point) (point-max))))
(goto-char start)
(when (re-search-forward "^[ \t]*#\\+BEGIN_SRC" end :noerror)
(org-babel-do-in-edit-buffer
(let* ((comment-1 (substring comment-start -1))
(comment-2 (if (= (length comment-start) 1)
(concat comment-start comment-start)
comment-start))
(comment-3 (concat comment-2 comment-1))
(comment-4 (concat comment-3 comment-1)))
(when (looking-at (concat
comment-2 "[=-]+\n"
comment-2 "+ .*\n"
comment-2 "[=-]+$"))
(replace-match
(concat
comment-2 (make-string 78 (if (> level 1) ?- ?=)) "\n"
(if (> level 2) comment-4 comment-3) " " title "\n"
comment-2 (make-string 78 (if (> level 1) ?- ?=))))))
(goto-char (line-beginning-position))
(when (re-search-forward "(init-message .*$" nil :noerror)
(replace-match (concat "(init-message " (number-to-string level) " \"" title "\")")))))))))))))
(init-message 3 "Org Mode: Babel Functions: org-fix-literate-programming-heading-region")
(defun org-fix-literate-programming-heading-region (&optional beg end)
"Fix 'literate programming' headings contained with given region.
Reset the CUSTOM_ID property, title comment, and `init-message'."
(interactive "*")
(let ((case-fold-search t)
(beg (or beg (if (use-region-p) (region-beginning) (progn (beginning-of-line-text) (point)))))
(end (or end (if (use-region-p) (region-end) (line-end-position)))))
(save-window-excursion
(save-mark-and-excursion
(save-match-data
(org-with-wide-buffer
(goto-char beg)
(while (and (re-search-forward "^[ \t]*:CUSTOM_ID:" nil :noerror)
(< (line-end-position) end))
(org-fix-literate-programming-heading)
(forward-line 1))))))))
(init-message 3 "Org Mode: Babel Functions: org-toggle-literate-programming-code-block")
(defun org-toggle-literate-programming-code-block ()
"Toggle 'literate programming' heading and code block on/off."
(interactive)
(save-window-excursion
(save-mark-and-excursion
(save-match-data
(org-with-wide-buffer
(org-back-to-heading t)
(let ((case-fold-search t)
(beg (point))
(end (progn
(forward-line 1)
(re-search-forward "^\*" nil 'move)
(1- (point)))))
(goto-char beg)
(re-search-forward " " (line-end-position))
(let ((toggle-on (looking-at "\+"))) (goto-char end)
(while (re-search-backward "^[ \t]*#\\+BEGIN_" beg :noerror)
(if toggle-on
(when (re-search-forward " :tangle no" (line-end-position) :noerror)
(replace-match ""))
(progn
(goto-char (line-end-position))
(insert " :tangle no")))
(forward-line 1)
(org-babel-do-in-edit-buffer
(if toggle-on
(uncomment-region (point-min) (point-max))
(comment-region (point-min) (point-max))))
(forward-line -2))
(goto-char beg)
(re-search-forward " " (line-end-position))
(if toggle-on
(dotimes (x 2)
(when (re-search-forward "\+" (line-end-position))
(replace-match "")))
(progn
(insert "+")
(goto-char (line-end-position))
(insert "+"))))))))))
(init-message 3 "Org Mode: Babel Functions: org-insert-literate-programming-statics")
(defun org-insert-literate-programming-name ()
"Insert `org-babel' block NAME"
(interactive "*")
(org-indent-line)
(insert "#+NAME: "))
(defmacro org-insert-literate-programming-src-gen (name &optional lang)
"Generate org babel insert function from NAME and optional LANG.
LANG is only needed if the language section of the block is
different from NAME."
(let* ((lang (or lang name))
(funct (intern (concat "org-insert-literate-programming-src"
(if name (concat "-" name) ""))))
(doc (concat "Insert `org-babel'"
(if lang (concat " " name) "")
" source block"))
(block (concat "#+BEGIN_SRC"
(if lang (concat " " lang) "")
"\n\n#+END_SRC\n")))
`(defun ,funct ()
,doc
(interactive "*")
(let ((point (point)))
(insert ,block)
(indent-region point (point))
(forward-line -2)))))
(org-insert-literate-programming-src-gen nil)
(org-insert-literate-programming-src-gen "sh")
(org-insert-literate-programming-src-gen "sh-sudo" "sh :dir /sudo::")
(org-insert-literate-programming-src-gen "emacs-lisp")
(org-insert-literate-programming-src-gen "racket")
(org-insert-literate-programming-src-gen "kotlin")
(init-message 3 "Org Mode: Babel Functions: org-insert-literate-programming-init-emacs-block")
(defun org-insert-literate-programming-init-emacs-block (&optional title)
"Insert 'literate programming' init-emacs block consisting of a heading,
properties, source block, title comment, and `init-message'."
(interactive "*")
(let* ((case-fold-search t)
(point (point))
(title (or title (read-string "Block title: ")))
(tag (org-generate-custom-id-from-title title)))
(org-insert-heading)
(insert title)
(org-set-property "CUSTOM_ID" tag)
(re-search-forward "^[ \t]*:END:$")
(newline)
(newline)
(insert "#+BEGIN_SRC emacs-lisp\n")
(insert " ;;------------------------------------------------------------------------------\n")
(insert " ;;;; " title "\n")
(insert " ;;------------------------------------------------------------------------------\n")
(newline)
(insert " (init-message 2 \"" title "\")\n")
(newline)
(newline)
(insert "#+END_SRC\n")
(indent-region point (point))
(org-previous-visible-heading 1)
(goto-char (line-end-position))
(org-fix-literate-programming-heading)
(forward-line 12)))
(init-message 3 "Org Mode: Babel Functions: org-insert-literate-programming-code-block")
(defun org-insert-literate-programming-code-block ()
"Insert 'literate programming' code block consisting of a heading,
properties, source block, and title comment."
(interactive "*")
(let* ((case-fold-search t)
(point (point))
(title (read-string "Block title: "))
(funct (org-generate-custom-id-from-title title))
(lang (save-mark-and-excursion
(if (re-search-backward "^[ \t]*#\\+BEGIN_SRC \\([^ \t\n]*\\)" nil :noerror)
(match-string 1)
"emacs-lisp"))))
(org-previous-visible-heading 1)
(org-insert-heading-respect-content)
(insert title)
(org-set-property "CUSTOM_ID" funct)
(re-search-forward "^[ \t]*:END:$")
(newline)
(newline)
(insert "#+BEGIN_SRC " lang "\n")
(insert " ;;------------------------------------------------------------------------------\n")
(insert " ;;;; " title "\n")
(insert " ;;------------------------------------------------------------------------------\n")
(newline)
(insert " (define (" funct " num)\n")
(insert " )\n")
(insert "#+END_SRC\n")
(newline)
(insert "#+BEGIN_SRC " lang " :tangle no\n")
(insert " (define (" funct "-test)\n")
(insert " (check-equal? (" funct " ) )\n")
(insert " )\n")
(insert "#+END_SRC\n")
(indent-region point (point))
(org-previous-visible-heading 1)
(goto-char (line-end-position))
(org-fix-literate-programming-heading)
(forward-line 10)))
(init-message 3 "Org Mode: Babel Functions: org-insert-literate-programming-project-euler-problem-block")
(defun org-insert-literate-programming-project-euler-problem-block ()
"Insert 'literate programming' project euler problem block consisting of a
heading, properties, source block with title comment, and test block."
(interactive "*")
(let* ((case-fold-search t)
(point (point))
(num (read-string "Problem number: "))
(title (concat "Problem " num))
(funct (format "project-euler-%03d" (string-to-number num)))
(lang (save-mark-and-excursion
(if (re-search-backward "^[ \t]*#\\+BEGIN_SRC \\([^ \t\n]*\\)" nil :noerror)
(match-string 1)
"emacs-lisp"))))
(org-previous-visible-heading 1)
(org-insert-heading-respect-content)
(insert title)
(org-set-property "CUSTOM_ID" funct)
(re-search-forward "^[ \t]*:END:$")
(newline)
(newline)
(insert "#+BEGIN_SRC " lang "\n")
(insert " ;;------------------------------------------------------------------------------\n")
(insert " ;;;; " title "\n")
(insert " ;;\n")
(insert " ;;\n")
(insert " ;;\n")
(insert " ;; The correct answer is: \n")
(insert " ;;------------------------------------------------------------------------------\n")
(newline)
(insert " (define (" funct " [num 1000])\n")
(insert " )\n")
(insert "#+END_SRC\n")
(newline)
(insert "#+BEGIN_SRC " lang " :tangle no\n")
(insert " (define (" funct "-test)\n")
(insert " (check-equal? (" funct " ) )\n")
(insert " )\n")
(insert "#+END_SRC\n")
(indent-region point (point))
(org-previous-visible-heading 1)
(goto-char (line-end-position))
(org-fix-literate-programming-heading)
(forward-line 9)))
(init-message 2 "Org Mode: Visibility")
(use-package org-visibility
:straight t
:after (org)
:bind (:map org-visibility-mode-map
("C-x C-v" . org-visibility-force-save) ("C-x M-v" . org-visibility-remove)) :hook (org-mode . org-visibility-mode)
:custom
(org-visibility-include-paths `(,(file-truename "~/.emacs.d/init-emacs.org")
,(file-truename "~/code/github-nullman")
,(file-truename "~/dev")
,(file-truename "~/doc/bbs")
,(file-truename "~/org")
,(file-truename "~/web/org")))
(org-visibility-exclude-paths `(,(file-truename "~/org/old")
,(file-truename "~/org/test"))))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-guid")
(defun org-bookmarks-guid ()
"Return a twelve character GUID."
(cl-labels
((random-char ()
(let ((num (random 62)))
(cond
((< num 10)
(byte-to-string (+ num 48)))
((< num 36)
(byte-to-string (+ num 55)))
(t
(byte-to-string (+ num 61)))))))
(cl-loop repeat 12
concat (random-char))))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-timestamp")
(defun org-bookmarks-timestamp ()
"Return time since the epoch in microseconds."
(floor (* (float-time (current-time)) 1000000)))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-parse")
(defun org-bookmarks-parse (file)
"Return a tree structure representing the org folders and
bookmarks found in FILE.
Example input:
* Org
* Folder 1
** Folder 2
*** Bookmark 1
URI1
*** Bookmark 2 [bm2]
URI2
** Folder 3
Example output:
((:type \"folder\" :title \"Folder 1\" :children
[(:type \"folder\" :title \"Folder 2\" :children
[(:type \"bookmark\" :title \"Bookmark 1\" :uri \"URI1\")
(:type \"bookmark\" :title \"Bookmark 2\" :uri \"URI2\" :keyword \"bm2\")])
(:type \"folder\" :title \"Folder 3\")]))
If the first headline is \"Org\", it is ignored."
(cl-labels
((parse (bm tree)
(cond
((not bm)
nil)
((and (stringp (car bm)) (stringp (cadr bm)))
(let* ((title (car x))
(uri (cadr x))
(keyword (if (string-match " \\[\\(.*\\)\\]$" title)
(match-string-no-properties 1 title)
nil))
(title (replace-regexp-in-string " \\[.*\\]$" "" title))
(entry (list :type "bookmark" :title title :uri uri)))
(when keyword
(setq entry (append entry (list :keyword keyword))))
entry))
((stringp (car bm))
(let* ((title (car bm))
(entry (list :type "folder" :title title)))
(if (cdr bm)
(append entry (list :children (map 'vector (lambda (x)
(parse x tree))
(cdr bm))))
entry))))))
(let ((bm (org-get-file-data file)))
(map 'vector (lambda (x)
(parse x nil))
(cdr bm)))))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-export-to-json")
(defun org-bookmarks-export-to-json (org-file &optional json-file)
"Export from an Org Bookmarks file, ORG-FILE,
to a Mozilla/Firefox Bookmarks JSON file, JSON-FILE.
If JSON-FILE is non-nil, then output is returned."
(let* ((type-code-list '(("bookmark" . 1)
("folder" . 2)))
(type-value-list '(("bookmark" . "text/x-moz-place")
("folder" . "text/x-moz-place-container")))
(title-guid-list '(("Bookmarks Menu" . "menu________")
("Bookmarks Toolbar" . "toolbar_____")
("Other Bookmarks" . "unfiled_____")
("Mobile Bookmarks" . "mobile______")))
(title-root-list '(("Bookmarks Menu" . "bookmarksMenuFolder")
("Bookmarks Toolbar" . "toolbarFolder")
("Other Bookmarks" . "unfiledBookmarksFolder")
("Mobile Bookmarks" . "mobileFolder")))
(global-id 0)
(timestamp (org-bookmarks-timestamp)))
(cl-labels
((gen-id ()
(incf global-id))
(parse (bm tree index)
(let* ((type (plist-get bm :type))
(type-value (cdr (assoc type type-value-list)))
(type-code (cdr (assoc type type-code-list)))
(title (plist-get bm :title))
(uri (plist-get bm :uri))
(keyword (plist-get bm :keyword))
(children (plist-get bm :children))
(guid (org-bookmarks-guid))
(id (gen-id))
(root (cdr (assoc title title-root-list)))
(custom-guid (cdr (assoc title title-guid-list)))
(entry (list
:guid (or custom-guid guid)
:title title
:index index
:dateAdded timestamp
:lastModified timestamp
:id id
:typeCode type-code
:type type-value)))
(when uri
(setq entry (append entry (list :uri uri))))
(when keyword
(setq entry (append entry (list :keyword keyword))))
(when root
(setq entry (append entry (list :root root))))
(when children
(let ((idx -1))
(setq entry (append entry (list :children (map 'vector (lambda (x) (parse x tree (incf idx))) children))))))
(append tree entry))))
(let ((json-object-type 'plist)
(json-array-type 'vector)
(json-key-type 'string)
(bookmarks (org-bookmarks-parse org-file)))
(with-temp-buffer
(insert
(json-encode
(list :guid "root________"
:title ""
:index 0
:dateAdded timestamp
:lastModified timestamp
:id (gen-id)
:typeCode 2
:type (cdr (assoc "folder" type-value-list))
:root "placesRoot"
:children (map 'vector (lambda (x) (parse x nil 0)) bookmarks))))
(newline)
(if json-file
(write-region (point-min) (point-max) json-file)
(buffer-substring-no-properties (point-min) (point-max))))))))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-export-to-html")
(defun org-bookmarks-export-to-html (org-file &optional html-file)
"Export from an Org Bookmarks file to a Mozilla/Firefox Bookmarks HTML file."
"Export from an Org Bookmarks file, ORG-FILE,
to a Mozilla/Firefox Bookmarks HTML file, HTML-FILE.
If HTML-FILE is non-nil, then output is returned."
(let* ((type-code-list '(("bookmark" . 1)
("folder" . 2)))
(title-code-list '(("Bookmarks Toolbar" . "PERSONAL_TOOLBAR_FOLDER")
("Other Bookmarks" . "UNFILED_BOOKMARKS_FOLDER")))
(timestamp (number-to-string (truncate (org-bookmarks-timestamp) 1000000))))
(cl-labels
((indent (idt str)
(concat (spaces-string idt) str))
(parse (bm str idt)
(let* ((type (plist-get bm :type))
(type-code (cdr (assoc type type-code-list)))
(title (plist-get bm :title))
(title-code (cdr (assoc title title-code-list)))
(uri (url-encode-url (plist-get bm :uri)))
(keyword (plist-get bm :keyword))
(children (plist-get bm :children))
(entry (cl-case type-code
(2 (concat
(indent idt "<DT><H3>")
" ADD_DATE=\"" timestamp "\""
" LAST_MODIFIED=\"" timestamp "\""
(if title-code (concat " " title-code "=\"true\"") "")
">" title "</H3>"))
(1 (concat
(indent idt "<DT>")
"<A HREF=\"" uri "\""
" ADD_DATE=\"" timestamp "\""
" LAST_MODIFIED=\"" timestamp "\""
(if keyword (concat " SHORTCUTURL=\"" keyword "\"") "")
">" title "</A>")))))
(when children
(setq entry (concat entry
(indent idt "<DL><p>\n")
(mapconcat (lambda (x) (parse x str (+ idt 4))) children "\n")
(indent idt "</DL>\n"))))
entry)))
(let ((bookmarks (org-bookmarks-parse org-file)))
(with-temp-buffer
(insert
(concat
"<!DOCTYPE NETSCAPE-Bookmark-file-1>
<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=UTF-8\">
<TITLE>Bookmarks</TITLE>
<H1>Bookmarks Menu</H1>
<DL><p>\n"
(mapconcat (lambda (x) (parse x "" 4)) bookmarks "\n"))
"</DL>\n")
(if html-file
(write-region (point-min) (point-max) html-file)
(buffer-substring-no-properties (point-min) (point-max))))))))
(init-message 3 "Org Mode: Bookmarks: org-bookmarks-export-to-nyxt")
(defun org-bookmarks-export-to-nyxt (org-file &optional nyxt-file)
"Export from an Org Bookmarks file, ORG-FILE,
to an NYXT Bookmarks Lisp file, NYXT-FILE.
If NYXT-FILE is non-nil, then output is returned."
(let ((timestamp (format-time-string "%FT%T.%6NZ"))
(title-root-list '(("Bookmarks Menu" . "bookmarksMenuFolder")
("Bookmarks Toolbar" . "toolbarFolder")
("Other Bookmarks" . "unfiledBookmarksFolder")
("Mobile Bookmarks" . "mobileFolder"))))
(cl-labels
((folder? (type)
(string= type "folder"))
(tags (name)
(split-string name " " :omit-nulls))
(parse (bm tags)
(let* ((type (plist-get bm :type))
(folder? (folder? type))
(title (plist-get bm :title))
(uri (plist-get bm :uri))
(keyword (plist-get bm :keyword))
(children (plist-get bm :children))
(root? (cdr (assoc title title-root-list)))
(tags tags))
(when (and folder? (not root?))
(setq tags (append tags (tags title))))
(when keyword
(setq tags (append tags (list keyword))))
(when (not folder?)
(insert
(format "%S\n" (list :url uri :title title :date timestamp :tags tags))))
(when children
(map 'vector (lambda (x) (parse x tags)) children)))))
(let ((bookmarks (org-bookmarks-parse org-file)))
(with-temp-buffer
(insert "(\n")
(map 'vector (lambda (x) (parse x '())) bookmarks)
(insert ")\n")
(if nyxt-file
(write-region (point-min) (point-max) nyxt-file)
(buffer-substring-no-properties (point-min) (point-max))))))))
(init-message 2 "Org Mode: Finances")
(init-message 3 "Org Mode: Finances: export-taxes")
(defun export-taxes ()
"Export tax information found at current org subtree."
(interactive)
(let* ((title (concat
"Sherman Taxes "
(save-mark-and-excursion
(save-match-data
(goto-char (line-beginning-position))
(re-search-forward "^\*+ " (line-end-position))
(buffer-substring-no-properties (point) (line-end-position))))))
(target-buffer (generate-new-buffer-name (concat "*" title "*"))))
(org-cycle 8)
(org-copy-subtree)
(set-buffer (get-buffer-create target-buffer))
(org-mode)
(buffer-disable-undo)
(org-paste-subtree)
(goto-char (point-min))
(kill-region (line-beginning-position) (line-end-position))
(insert title)
(newline)
(insert "------------------")
(while (re-search-forward "^\*\\{3\\} " nil :noerror)
(kill-region (line-beginning-position) (point))
(insert "\n\n")
(capitalize-region (line-beginning-position) (line-end-position))
(goto-char (line-end-position)))
(goto-char (point-min))
(while (re-search-forward "^\*\\{5\\} " nil :noerror)
(kill-region (line-beginning-position) (point))
(insert "\n- ")
(capitalize-region (line-beginning-position) (line-end-position)))
(goto-char (point-min))
(while (re-search-forward "^\*\\{7\\} " nil :noerror)
(kill-region (line-beginning-position) (point))
(insert " - ")
(capitalize-region (line-beginning-position) (line-end-position)))
(goto-char (point-min))
(while (re-search-forward "^\|-" nil :noerror)
(goto-char (line-beginning-position))
(when (save-mark-and-excursion
(forward-line -1)
(not (looking-at "^$")))
(newline))
(goto-char (org-table-end)))
(goto-char (point-min))
(while (re-search-forward "^[ \t]*#\\+TBLFM:.*$" nil :noerror)
(kill-region (line-beginning-position) (1+ (point))))
(goto-char (point-min))
(switch-to-buffer target-buffer)))
(init-message 3 "Org Mode: Finances: duluth-hotel-invoiced-expense")
(defun duluth-hotel-invoiced-expense (balance)
"Insert Duluth Hotel Invoiced Expense."
(interactive "*sTotal Balance: ")
(org-table-goto-column 5)
(org-table-blank-field)
(org-table-recalculate)
(org-table-goto-column 7)
(let* ((invoice (/ (round (* (- (string-to-number (org-table-get-field))
(string-to-number balance))
100)) 100.0)))
(org-table-goto-column 5)
(insert (format "%.2f" invoice))
(org-table-recalculate)))
(init-message 3 "Org Mode: Finances: nwm-add-monthly-account-data")
(defun nwm-add-monthly-account-data (data)
"Add Northwestern Mutual monthly entries for all accounts found in DATA."
(interactive "*sNorthwestern Mutual Account Summary: ")
(cl-labels
((date-to-year-month (date)
(concat
(substring date 6 10)
(substring date 0 2))))
(let ((buffer (get-buffer "personal-encrypted.org.cpt"))
(tables '("NWM_A40_344433"
"NWM_A40_344458"
"NWM_A40_345190"
"NWM_B40_300756"
"NWM_B40_300798"))
date
balances)
(with-temp-buffer
(insert data)
(goto-char (point-min))
(re-search-forward "^Period Ending: ")
(setq date (date-to-year-month
(buffer-substring-no-properties (point) (line-end-position))))
(mapcar (lambda (x)
(re-search-forward "%\\([0-9,]*\.[0-9][0-9]\\)[0-9.]*%")
(push (replace-regexp-in-string "," "" (match-string 1)) balances))
tables))
(with-current-buffer buffer
(do ((tables tables (cdr tables))
(balances (nreverse balances) (cdr balances)))
((null tables))
(goto-char (point-min))
(re-search-forward (concat "^[ \t]*#\\+NAME: " (car tables) "$"))
(goto-char (org-table-end))
(forward-line -4)
(org-table-insert-row)
(org-table-goto-column 1)
(insert "#")
(org-table-goto-column 2)
(insert date)
(org-table-goto-column 4)
(insert (car balances))
(org-table-recalculate)
(re-search-forward (concat "^[ \t]*#\\+NAME: " (car tables) "_STATS$"))
(forward-line 1)
(org-table-recalculate)
(org-table-recalculate))))))
(init-message 2 "Org Mode: Magic the Gathering")
(defconst mtg-cards-owned-file-name (file-truename (expand-file-name "~/org/magic-the-gathering-cards-owned.org")))
(init-message 3 "Org Mode: Magic the Gathering: mtg-card-list")
(defun mtg-card-list ()
"Create a list of Magic The Gathering cards in inventory."
(interactive)
(unless (string= (buffer-name) (file-name-nondirectory mtg-cards-owned-file-name))
(find-file mtg-cards-owned-file-name))
(let ((source-buffer (current-buffer))
(target-buffer (generate-new-buffer-name "*mtg*")))
(set-buffer (get-buffer-create target-buffer))
(buffer-disable-undo)
(insert-buffer-substring source-buffer)
(goto-char (point-min))
(search-forward "* mtg cards owned")
(goto-char (line-beginning-position))
(kill-region (point-min) (point))
(unless (search-forward "* mtg card sets" nil :noerror)
(goto-char (point-max)))
(goto-char (line-beginning-position))
(kill-region (point) (point-max))
(org-mode)
(goto-char (point-min))
(outline-show-subtree)
(while (re-search-forward "^| +|.*\n" nil :noerror)
(replace-match ""))
(goto-char (point-min))
(while (re-search-forward "| +Artist" nil :noerror)
(org-table-delete-column))
(goto-char (point-min))
(switch-to-buffer target-buffer)))
(init-message 3 "Org Mode: Magic the Gathering: mtg-deck-search")
(defun mtg-deck-search ()
"Show cards owned from a deck list.
LIST must have one card per line with the number of cards
followed by the card name."
(interactive)
(let ((buffer (current-buffer))
cards
(ignored '("Plains" "Island" "Swamp" "Mountain" "Forest")))
(save-mark-and-excursion
(save-match-data
(goto-char (point-min))
(while (re-search-forward "^\s*\\([0-9]+\\)\s*\\(.*\\)\s*$" nil :noerror)
(let ((name (buffer-substring-no-properties (match-beginning 2) (match-end 2)))
(count (buffer-substring-no-properties (match-beginning 1) (match-end 1))))
(setq name (replace-regexp-in-string "\s*\\[.*\\]\s*" "" name))
(unless (member name ignored)
(push (list name count) cards))))))
(setq cards (sort cards (lambda (a b) (string< (car a) (car b)))))
(find-file mtg-cards-owned-file-name)
(occur (concat "\\(" (substring (apply #'concat (mapcar (lambda (x) (concat "\\|" (car x))) cards)) 2) "\\)"))
(switch-to-buffer buffer)))
(init-message 3 "Org Mode: Magic the Gathering: mtg-set-to-table")
(defun mtg-set-to-table (&optional owned)
"Convert `http://gatherer.wizards.com/' set checklist list to table.
If OWNED is non-nil, add an Owned column to the table."
(interactive "P")
(goto-char (point-min))
(let ((source-buffer (current-buffer))
(target-buffer (generate-new-buffer-name "*mtg-set-table*")))
(set-buffer (get-buffer-create target-buffer))
(buffer-disable-undo)
(insert-buffer-substring source-buffer)
(goto-char (point-min))
(delete-non-matching-lines "<tr class=\"cardItem\">" (point-min) (point-max))
(goto-char (point-min))
(while (re-search-forward "</tr><tr" nil :noerror)
(replace-match "</tr>\n<tr"))
(goto-char (point-min))
(while (re-search-forward "<td[^>]*>" nil :noerror)
(replace-match "| "))
(goto-char (point-min))
(while (re-search-forward "</td>" nil :noerror)
(replace-match " "))
(goto-char (point-min))
(while (re-search-forward "^\s*<tr[^>]*>" nil :noerror)
(replace-match ""))
(goto-char (point-min))
(while (re-search-forward "</tr>" nil :noerror)
(replace-match "|"))
(goto-char (point-min))
(while (re-search-forward "<a[^>]*>" nil :noerror)
(replace-match ""))
(goto-char (point-min))
(while (re-search-forward "</a>" nil :noerror)
(replace-match ""))
(goto-char (point-min))
(goto-char (point-min))
(insert (concat "|-+-+-+-+-+-|"))
(newline)
(insert (concat "| # | Name | Artist | Color | Rarity | Set |"))
(newline)
(insert (concat "|-+-+-+-+-+-|"))
(newline)
(goto-char (point-max))
(insert (concat "|-+-+-+-+-+-|"))
(goto-char (point-min))
(org-mode)
(org-table-align)
(when owned
(org-table-insert-column)
(insert "Owned")
(org-table-align))
(switch-to-buffer target-buffer)))
(init-message 2 "Org Mode: MechWarrior Online")
(init-message 3 "Org Mode: MechWarrior Online: mwo-export-mech")
(defun mwo-export-mech ()
"Export mech found at current org subtree."
(interactive)
(let ((target-buffer (generate-new-buffer-name "*mwo-mech*")))
(org-cycle 8)
(org-copy-subtree)
(set-buffer (get-buffer-create target-buffer))
(buffer-disable-undo)
(org-paste-subtree)
(goto-char (point-min))
(while (re-search-forward "^\*+ " (line-end-position) :noerror)
(replace-match ""))
(while (re-search-forward "^\*+ " nil :noerror)
(kill-region (line-beginning-position) (point))
(newline)
(capitalize-region (line-beginning-position) (line-end-position))
(goto-char (line-end-position))
(newline))
(switch-to-buffer target-buffer)
(goto-char (point-min))))
(init-message 2 "Org Mode: Dungeons and Dragons Online")
(init-message 3 "Org Mode: Dungeons and Dragons Online: ddo-get-item-info")
(defun ddo-get-item-info (&optional item)
"Look up ITEM in the DDO Wiki and return information about it."
(interactive "sDDO Item Name: ")
(save-current-buffer
(let* ((url (url-encode-url (concat "http://ddowiki.com/index.php?search=" item)))
(buffer (url-retrieve-synchronously url))
(enchantments ""))
(when buffer
(set-buffer buffer)
(goto-char (point-min))
(when (re-search-forward "Enchantments" nil :noerror)
(let ((start (point)))
(when (re-search-forward "</td>" nil :noerror)
(let ((end (point)))
(goto-char start)
(while (re-search-forward "<a .*>\\([^<]*\\)</a>" end :noerror)
(setq enchantments
(concat
enchantments
(if (zerop (length enchantments)) "" ", ")
(buffer-substring-no-properties (match-beginning 1) (match-end 1))))
(when (re-search-forward "</span>\\([^<]*\\)</li>" end :noerror)
(setq enchantments
(concat
enchantments
(buffer-substring-no-properties (match-beginning 1) (match-end 1))))))))))
(concat item " (" enchantments ")\n" url)))))
(init-message 3 "Org Mode: Dungeons and Dragons Online: ddo-fix-wiki-description")
(defun ddo-fix-wiki-description ()
"Fix wiki description around point."
(interactive)
(goto-char (line-beginning-position))
(while (not (looking-at "\\*"))
(insert ", ")
(goto-char (line-beginning-position))
(delete-char -1)
(goto-char (line-beginning-position)))
(while (re-search-forward "Icon tooltip\.png" (line-end-position) :noerror)
(replace-match ""))
(goto-char (line-beginning-position))
(while (re-search-forward " +," (line-end-position) :noerror)
(replace-match ","))
(goto-char (line-beginning-position))
(while (re-search-forward ",," (line-end-position) :noerror)
(replace-match ","))
(goto-char (line-beginning-position))
(while (re-search-forward " +" (line-end-position) :noerror)
(replace-match " "))
(goto-char (line-beginning-position))
(while (re-search-forward " +$" (line-end-position) :noerror)
(replace-match ""))
(goto-char (line-end-position))
(insert ")"))
(init-message 2 "Org Mode: Ironsworn")
(init-message 1 "Org Website")
(init-message 2 "Org Website: Configuration")
(init-message 3 "Org Website: Configuration: Publish Configuration")
(use-package org
:straight (:type built-in)
:commands (org-export-as
org-export-to-buffer
org-export-to-file)
:functions (org-export-collect-footnote-definitions
org-export-data
org-export-define-derived-backend
org-export-footnote-first-reference-p
org-export-get-footnote-number
org-export-get-previous-element
org-export-get-relative-level
org-website-convert-url-to-gopher-selector-hostname-port)
:config
(when (require 'ox nil :no-error)
(defun org-link-gopher-export-link (link desc format)
"Create export version of LINK and DESC to FORMAT."
(let ((link (concat "gopher:" link)))
(cond
((eq format 'html)
(format "<a href=\"%s\">%s</a>" link desc))
((eq format 'latex)
(format "\\href{%s}{%s}" link desc))
((eq format 'gopher)
(format "1\t%s\t%s" desc (org-website-convert-url-to-gopher-selector-hostname-port link)))
(t
(format "[%s](%s)" desc link)))))
(org-link-set-parameters "gopher" :export #'org-link-gopher-export-link))
(require 'ox-publish nil :no-error)
(require 'ox-ascii nil :no-error)
(when (require 'ox-html nil :no-error)
(let* ((site-extension "org")
(shared-extension "css")
(statics-extension (concat "html\\|css\\|js\\|sh\\|"
"txt\\|rss\\|"
"ico\\|gif\\|png\\|jpg\\|"
"mp4\\|webm\\|"
"eot\\|ttf\\|woff\\|"
"pdf\\|odt\\|doc\\|docx\\|"
"tgz\\|zip\\|"
"xml\\|xsd\\|xsl"))
(assets-extension (concat "org\\|" statics-extension)))
(setq org-publish-project-alist
`( ("nullman" :components ("nullman-shared"
"nullman-assets"
"nullman-site"
"nullman-site-statics"
"nullman-site-gopher"
"rsync"))
("nullman-shared"
:base-directory "~/web/sites/shared"
:base-extension ,shared-extension
:publishing-directory "~/web/sites/nullman/site"
:publishing-function org-publish-attachment
:recursive t)
("nullman-assets"
:base-directory "~/web/sites/nullman/assets"
:base-extension ,assets-extension
:publishing-directory "~/web/sites/nullman/site"
:publishing-function org-publish-attachment
:recursive t)
("nullman-site"
:base-directory "~/web/sites/nullman/site"
:base-extension ,site-extension
:publishing-directory "~/public_html/sites/nullman"
:publishing-function org-website-html-publish-to-html
:recursive t)
("nullman-site-statics"
:base-directory "~/web/sites/nullman/site"
:base-extension ,statics-extension
:publishing-directory "~/public_html/sites/nullman"
:publishing-function org-publish-attachment
:recursive t)
("nullman-site-gopher"
:base-directory "~/web/sites/nullman/site"
:base-extension ,site-extension
:publishing-directory "~/public_gopher/sites/nullman"
:publishing-function org-website-gopher-publish-to-gopher
:recursive t)
("nulldot" :components ("nulldot-shared"
"nulldot-assets"
"nulldot-site"
"nulldot-site-statics"
"rsync"))
("nulldot-shared"
:base-directory "~/web/sites/shared"
:base-extension ,shared-extension
:publishing-directory "~/web/sites/nulldot/site"
:publishing-function org-publish-attachment
:recursive t)
("nulldot-assets"
:base-directory "~/web/sites/nulldot/assets"
:base-extension ,assets-extension
:publishing-directory "~/web/sites/nulldot/site"
:publishing-function org-publish-attachment
:recursive t)
("nulldot-site"
:base-directory "~/web/sites/nulldot/site"
:base-extension ,site-extension
:publishing-directory "~/public_html/sites/nulldot"
:publishing-function org-website-html-publish-to-html
:recursive t)
("nulldot-site-statics"
:base-directory "~/web/sites/nulldot/site"
:base-extension ,statics-extension
:publishing-directory "~/public_html/sites/nulldot"
:publishing-function org-publish-attachment
:recursive t)
("nullware" :components ("nullware-shared"
"nullware-assets"
"nullware-site"
"nullware-site-statics"
"rsync"))
("nullware-shared"
:base-directory "~/web/sites/shared"
:base-extension ,shared-extension
:publishing-directory "~/web/sites/nullware/site"
:publishing-function org-publish-attachment
:recursive t)
("nullware-assets"
:base-directory "~/web/sites/nullware/assets"
:base-extension ,assets-extension
:publishing-directory "~/web/sites/nullware/site"
:publishing-function org-publish-attachment
:recursive t)
("nullware-site"
:base-directory "~/web/sites/nullware/site"
:base-extension ,site-extension
:publishing-directory "~/public_html/sites/nullware"
:publishing-function org-website-html-publish-to-html
:recursive t)
("nullware-site-statics"
:base-directory "~/web/sites/nullware/site"
:base-extension ,statics-extension
:publishing-directory "~/public_html/sites/nullware"
:publishing-function org-publish-attachment
:recursive t)
("kylesherman" :components ("kylesherman-shared"
"kylesherman-assets"
"kylesherman-site"
"kylesherman-site-statics"
"rsync"))
("kylesherman-shared"
:base-directory "~/web/sites/shared"
:base-extension ,shared-extension
:publishing-directory "~/web/sites/kylesherman/site"
:publishing-function org-publish-attachment
:recursive t)
("kylesherman-assets"
:base-directory "~/web/sites/kylesherman/assets"
:base-extension ,assets-extension
:publishing-directory "~/web/sites/kylesherman/site"
:publishing-function org-publish-attachment
:recursive t)
("kylesherman-site"
:base-directory "~/web/sites/kylesherman/site"
:base-extension ,site-extension
:publishing-directory "~/public_html/sites/kylesherman"
:publishing-function org-website-html-publish-to-html
:recursive t)
("kylesherman-site-statics"
:base-directory "~/web/sites/kylesherman/site"
:base-extension ,statics-extension
:publishing-directory "~/public_html/sites/kylesherman"
:publishing-function org-publish-attachment
:recursive t)
("shermanwest" :components ("shermanwest-shared"
"shermanwest-assets"
"shermanwest-site"
"shermanwest-site-statics"
"rsync"))
("shermanwest-shared"
:base-directory "~/web/sites/shared"
:base-extension ,shared-extension
:publishing-directory "~/web/sites/shermanwest/site"
:publishing-function org-publish-attachment
:recursive t)
("shermanwest-assets"
:base-directory "~/web/sites/shermanwest/assets"
:base-extension ,assets-extension
:publishing-directory "~/web/sites/shermanwest/site"
:publishing-function org-publish-attachment
:recursive t)
("shermanwest-site"
:base-directory "~/web/sites/shermanwest/site"
:base-extension ,site-extension
:publishing-directory "~/public_html/sites/shermanwest"
:publishing-function org-website-html-publish-to-html
:recursive t)
("shermanwest-site-statics"
:base-directory "~/web/sites/shermanwest/site"
:base-extension ,statics-extension
:publishing-directory "~/public_html/sites/shermanwest"
:publishing-function org-publish-attachment
:recursive t)
("rsync"
:base-directory "~/web"
:base-extension "none"
:publishing-directory "~/public_html")
))
(setq org-link-abbrev-alist
(append
'(("about" . "http://nullman.net/about/")
("blog" . "%(org-website-blog-url)")
("emacs" . "http://nullman.net/emacs/")
("nulldot" . "http://nulldot.net/")
("nullman" . "http://nullman.net/")
("pet-peeves" . "http://nullman.net/rants/pet-peeves.html")
("powerhouse" . "http://powerhouse.nullware.com/")
("projects" . "http://nullman.net/projects/")
("rants" . "http://nullman.net/rants/")
("tutorials" . "http://nullman.net/tutorials/"))
'(("cowiki" . "http://www.champions-online-wiki.com/wiki/")
("google" . "http://www.google.com/search?q=%h")
("urban" . "http://www.urbandictionary.com/define.php?term=")
("wiki" . "http://en.wikipedia.org/wiki/Special:Search?search=")
("word" . "http://en.wiktionary.org/wiki/")
("youtube" . "https://www.youtube.com/watch?v="))))
(setq org-html-toplevel-hlevel 1)
(setq org-html-table-default-attributes nil)
)))
(init-message 3 "Org Website: Configuration: Menu Lists")
(defconst org-website-menu-list
'((:home . (:name "Home" :title "Home Page" :url "http://nullman.net/"))
(:blog . (:name "Blog" :title "Personal Blog" :url "http://nulldot.net/"))
(:applications . (:name "Applications" :title "Nullware Applications" :url "http://nullware.com/"))
(:emacs . (:name "Emacs" :title "Emacs Customizations" :url "http://nullman.net/emacs/"))
(:projects . (:name "Projects" :title "Computer Programming Projects" :url "http://nullman.net/projects/"))
(:tutorials . (:name "Tutorials" :title "Computer Tutorials" :url "http://nullman.net/tutorials/"))
(:presentations . (:name "Presentations" :title "Presentations I've Given" :url "http://nullman.net/presentations/"))
(:interesting . (:name "Interesting" :title "Things of Interest" :url "http://nullman.net/interesting/"))
(:games . (:name "Games" :title "Computer Games" :url "http://nullman.net/games/"))
(:quotes . (:name "Quotes" :title "Collected Quotes" :url "http://nullman.net/quotes/"))
(:rants . (:name "Rants" :title "Random Ramblings and Rants" :url "http://nullman.net/rants/"))
(:social . (:name "Social" :title "Social Links" :url "http://nullman.net/social/"))
(:photos . (:name "Photos" :title "Personal Photographs" :url "http://nullman.net/photos/"))
(:bookmarks . (:name "Bookmarks" :title "Personal Bookmarks" :url "http://nullman.net/bookmarks/"))
(:about . (:name "About" :title "About This Site and Its Author" :url "http://nullman.net/about/")))
"Website standard menu list.
Format: ((TAG . (:name NAME :title TITLE :url URL)) ... )")
(defconst org-website-shermanwest-menu-list
'((:home . (:name "Home" :title "Home Page" :url "http://shermanwest.com/"))
(:pictures . (:name "Pictures" :title "Condo Pictures" :url "http://www.flickr.com/photos/nullman/sets/72157603365914146/show/"))
(:directions . (:name "Directions" :title "Sherman West Directions" :url "http://shermanwest.com/directions.html"))
(:restaurants . (:name "Restaurants" :title "San Diego Restaurants" :url "http://shermanwest.com/restaurants.html"))
(:bars . (:name "Bars" :title "San Diego Bars" :url "http://shermanwest.com/bars.html"))
(:attractions . (:name "Attractions" :title "San Diego Attractions" :url "http://shermanwest.com/attractions.html"))
(:shopping . (:name "Shopping" :title "San Diego Shopping" :url "http://shermanwest.com/shopping.html"))
(:rules . (:name "Rules" :title "House Rules" :url "http://shermanwest.com/rules.html"))
(:guestbook . (:name "Guestbook" :title "Guestbook" :url "http://shermanwest.com/guestbook.html")))
"Website Sherman West menu list.
Format: ((TAG . (:name NAME :title TITLE :url URL)) ... )")
(defconst org-website-gopher-menu-list
'((:home . (:name "Home" :title "Home Page" :selector "/nullman/index.gopher"))
(:blog . (:name "Blog" :title "Personal Blog" :selector "/nulldot/index.gopher"))
(:applications . (:name "Applications" :title "Nullware Applications" :selector "/nullware/index.gopher"))
(:emacs . (:name "Emacs" :title "Emacs Customizations" :selector "/nullman/emacs/index.gopher"))
(:projects . (:name "Projects" :title "Computer Programming Projects" :selector "/nullman/projects/index.gopher"))
(:tutorials . (:name "Tutorials" :title "Computer Tutorials" :selector "/nullman/tutorials/index.gopher"))
(:presentations . (:name "Presentations" :title "Presentations I've Given" :selector "/nullman/presentations/index.gopher"))
(:interesting . (:name "Interesting" :title "Things of Interest" :selector "/nullman/interesting/index.gopher"))
(:games . (:name "Games" :title "Computer Games" :selector "/nullman/games/index.gopher"))
(:quotes . (:name "Quotes" :title "Collected Quotes" :selector "/nullman/quotes/index.gopher"))
(:rants . (:name "Rants" :title "Random Ramblings and Rants" :selector "/nullman/rants/index.gopher"))
(:social . (:name "Social" :title "Social Links" :selector "/nullman/social/index.gopher"))
(:photos . (:name "Photos" :title "Personal Photographs" :selector "/nullman/photos/index.gopher"))
(:bookmarks . (:name "Bookmarks" :title "Personal Bookmarks" :selector "/nullman/bookmarks/index.gopher"))
(:about . (:name "About" :title "About This Site and Its Author" :selector "/nullman/about/index.gopher")))
"Website Gopher menu list.
Format: ((TAG . (:name NAME :title TITLE :selector SELECTOR)) ... )")
(init-message 3 "Org Website: Configuration: Gopher Configuration")
(defconst gopher-port 70
"Port used by Gopher server.")
(defconst gopher-text-width org-ascii-text-width
"Maximum width of Gopher text before word wrapping.")
(defconst gopher-type-text-file "0")
(defconst gopher-type-submenu "1")
(defconst gopher-type-binary-file "9")
(defconst gopher-type-gif-file "g")
(defconst gopher-type-image-file "i")
(defconst gopher-type-html-file "h")
(defconst gopher-type-sound-file "s")
(init-message 2 "Org Website: Functions")
(init-message 3 "Org Website: Functions: Get Property List")
(defun org-website-get-property-list (info)
"Return an association list of org properties in INFO."
(org-element-map (plist-get info :parse-tree) 'keyword
(lambda (x)
(let ((key (intern (concat ":" (replace-regexp-in-string "_" "-" (downcase (org-element-property :key x)))))))
(cons key (org-element-property :value x))))))
(init-message 3 "Org Website: Functions: Get Property Element")
(defun org-website-get-property-element (property-list element)
"Return ELEMENT from PROPERTY-LIST returned from `org-website-get-property-list', or empty string if element was not found."
(or (cdr (assoc element property-list)) ""))
(init-message 3 "Org Website: Functions: Get URL")
(defun org-website-get-url (property-list)
"Return target URL for current buffer being exported."
(concat
(org-website-get-property-element property-list :link-home)
(replace-regexp-in-string
"^.*/site/" ""
(replace-regexp-in-string "\.[^\.]*$" "" buffer-file-name))
".html"))
(init-message 3 "Org Website: Functions: Blog URL")
(defun org-website-blog-url (name)
"Return URL of given blog NAME."
(let ((parts (split-string name ".")))
(concat
"http://nulldot.net/"
(nth 0 parts) "/"
(nth 1 parts) "/"
name ".html")))
(init-message 3 "Org Website: Functions: Is Blog Post")
(defun org-website-is-blog-post (property-list)
"Return non-nil if current page is a blog entry."
(zerop (length (replace-regexp-in-string
"^.*/[0-9]\\{4\\}.[0-9]\\{2\\}.[0-9]\\{2\\}.[0-9]\\{4\\}-.*$"
""
buffer-file-name))))
(init-message 3 "Org Website: Functions: Get Level")
(defun org-website-get-level (property-list)
"Return level of current project file."
(- (length (split-string (org-website-get-url property-list) "/")) 3))
(init-message 3 "Org Website: Functions: Format Headline")
(defun org-website-format-headline (headline &optional char col)
"Return HEADLINE surrounded by CHAR ending at COL length."
(let* ((char (or char ?=))
(col (or col org-ascii-text-width))
(text-width (- col 12))
(headline (if (> (length headline) text-width)
(let ((fill-column text-width))
(with-temp-buffer
(insert headline)
(fill-region (point-min) (point-max))
(buffer-string)))
headline)))
(mapconcat
(lambda (line)
(let ((str (concat (make-string 5 char) " " (upcase line) " " (make-string 5 char))))
(while (< (length str) col)
(setq str (concat str (string char))))
str))
(split-string headline "\n") "\n")))
(init-message 3 "Org Website: Functions: Get Gopher Selector Hostname Port")
(defun org-website-get-gopher-selector-hostname-port (selector)
"Return Gopher selector, hostname, and port from given SELECTOR."
(let* ((hostname "nullman.net")
(port (if (boundp 'gopher-port) gopher-port 70)))
(concat selector "\t" hostname "\t" (int-to-string port))))
(init-message 3 "Org Website: Functions: Convert URL to Gopher Selector Hostname Port")
(defun org-website-convert-url-to-gopher-selector-hostname-port (url)
"Return Gopher selector, hostname, and port from given URL."
(let* ((suffix (replace-regexp-in-string "^.*://" "" url))
(hostname (replace-regexp-in-string "/.*$" "" suffix))
(selector (replace-regexp-in-string "^.*?/" "/" suffix))
(port (if (boundp 'gopher-port) gopher-port 70)))
(concat selector "\t" hostname "\t" (int-to-string port))))
(init-message 3 "Org Website: Functions: Gopher Justify Lines")
(defun org-website-gopher-justify-lines (str &optional indent width justify)
"Return STR after justifying all lines.
INDENT is the amount to indent the final text (defaults to 0).
WIDTH is an integer specifying maximum length of a line (defaults
to `gopher-text-width' or `org-ascii-text-width').
JUSTIFY determines the type of justification: `left', `right',
`full', `center', or `none' (defaults to `none')."
(with-temp-buffer
(let ((indent (or indent 0))
(fill-column (or width
(and (boundp 'gopher-text-width)
gopher-text-width)
org-ascii-text-width)))
(insert str)
(goto-char (point-min))
(while (search-forward "\n" nil :noerror)
(replace-match "\n\n"))
(fill-region (point-min) (point-max) justify :nosqueeze :to-eop)
(goto-char (point-min))
(while (search-forward "\n\n" nil :noerror)
(replace-match "\n"))
(when (> indent 0)
(let ((spc (make-string indent ? )))
(goto-char (point-min))
(while (not (eobp))
(insert spc)
(goto-char (line-beginning-position))
(forward-line 1))))
(buffer-string))))
(init-message 2 "Org Website: Publish HTML")
(init-message 3 "Org Website: Publish HTML: Derived Backend")
(org-export-define-derived-backend 'org-website-html 'html
:translate-alist '((template . org-website-html-template)
(inner-template . org-website-html-inner-template)
(headline . org-website-html-headline)
(section . org-website-html-section)))
(init-message 3 "Org Website: Publish HTML: Publish to HTML")
(defun org-website-html-publish-to-html (plist file-name pub-dir)
"Publish a Website org file to HTML and return output file name.
FILE-NAME is the file name of the Org file to be published.
PLIST is the property list for the given project.
PUB-DIR is the publishing directory."
(org-publish-org-to 'org-website-html file-name
(concat "." (or (plist-get plist :html-extension)
org-html-extension
"html"))
plist pub-dir))
(init-message 3 "Org Website: Publish HTML: Template")
(defun org-website-html-template (contents info)
"Return complete document string after HTML conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(let* ((property-list (org-website-get-property-list info))
(site (org-website-get-property-element property-list :site))
(title (org-website-get-property-element property-list :title)))
(concat
"<!DOCTYPE html>\n"
(format "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"%s\">\n" (org-website-get-property-element property-list :language))
"\n"
"<head>\n"
"\n"
(format " <title>%s</title>\n" title)
"\n"
(format " <meta http-equiv=\"Content-Type\" content=\"text/html; charset=%s\" />\n" (or (coding-system-get org-html-coding-system 'mime-charset) "utf-8"))
" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n"
(format " <meta name=\"author\" content=\"%s\" />\n" (org-website-get-property-element property-list :author))
(format " <meta name=\"keywords\" content=\"%s\" />\n" (org-website-get-property-element property-list :keywords))
(format " <meta name=\"description\" content=\"%s\" />\n" (org-website-get-property-element property-list :description))
" <meta name=\"generator\" content=\"org-mode\" />\n"
" <meta name=\"robots\" content=\"all\" />\n"
" <meta name=\"google-site-verification\" content=\"" (org-website-get-property-element property-list :google-site-verification) "\" />\n"
"\n"
" <link rel=\"alternate\" type=\"application/rss+xml\" title=\"RSS Feed\" href=\"http://nulldot.net/index.rss\" />\n"
" <link rel=\"author\" href=\"http://nullman.net/about.html\" />\n"
" <link rel=\"home\" href=\"/\" />\n"
(cond
((and (string= site "kylesherman") (string= title "Resume"))
" <link rel=\"stylesheet\" type=\"text/css\" media=\"all\" href=\"/styles/resume.css\" />\n")
(t
" <link rel=\"stylesheet\" type=\"text/css\" media=\"all\" href=\"/styles/default.css\" />\n"))
" <link rel=\"stylesheet\" type=\"text/css\" media=\"print\" href=\"/styles/print.css\" />\n"
"\n"
" <!-- Google Analytics -->\n"
" <script><!--\n"
" var _gaq = _gaq || [];\n"
" _gaq.push(['_setAccount', '" (org-website-get-property-element property-list :google_analytics) "']);\n"
" _gaq.push(['_trackPageview']);\n"
" (function() {\n"
" var ga = document.createElement('script'); ga.async = true;\n"
" ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';\n"
" var s = document.getElementsByTagName('script')[0];\n"
" s.parentNode.insertBefore(ga, s);\n"
" })();\n"
" // --></script>\n"
"\n"
(concat
(org-element-normalize-string (plist-get info :html-head))
(org-element-normalize-string (plist-get info :html-head-extra)))
"\n"
"</head>\n"
"\n"
"<body>\n"
"\n"
" <div id=\"container\">\n"
"\n"
(cond
((and (string= site "kylesherman") (string= title "Resume"))
"")
(t
(concat
" <!-- header start -->\n"
"\n"
" <div id=\"header\">\n"
" <h1 class=\"title\">\n"
(format " <span>%s</span>\n" title)
" </h1>\n"
" </div>\n"
"\n"
" <!-- header end -->\n"
"\n")))
(if (> (length (org-website-get-property-element property-list :menu)) 0)
(concat
" <!-- menu start -->\n"
"\n"
" <div id=\"menu\">\n"
"\n"
(mapconcat
(lambda (x)
(let* ((plist (cdr x))
(name (plist-get plist :name))
(title (plist-get plist :title))
(url (plist-get plist :url))
(current (string= (org-website-get-property-element property-list :menu) name)))
(concat " <div class=\"" (if current "menu-item-current" "menu-item") "\">\n"
" <a title=\"" title "\" href=\"" url "\">" name "</a>\n"
" </div>\n")))
(if (string= site "shermanwest")
org-website-shermanwest-menu-list
org-website-menu-list)
"")
"\n"
" <!-- search start -->\n"
"\n"
" <div class=\"search\">\n"
" <form method=\"get\" action=\"http://www.google.com/search\">\n"
" <fieldset>\n"
" <input type=\"hidden\" name=\"q\" value=\"site:http://nullman.net/ OR site:http://nulldot.net/ OR site:http://nullware.com/\" />\n"
" <input type=\"hidden\" name=\"hl\" value=\"en\" />\n"
" <input type=\"text\" name=\"q\" maxlength=\"2048\" value=\"\" title=\"Search\" style=\"width: 5.5em\" />\n"
" <input type=\"image\" name=\"btnG\" src=\"/img/search.png\" alt=\"Search\" style=\"height: 100%; vertical-align: middle\" />\n"
" </fieldset>\n"
" </form>\n"
" </div>\n"
"\n"
" <!-- search end -->\n"
"\n"
" </div>\n"
"\n"
" <!-- menu end -->\n"
"\n")
"")
(cond
((string= site "nulldot")
(org-website-html-blog-contents-template contents info property-list))
((string= site "kylesherman")
(concat
" <!-- content start -->\n"
"\n"
(if (string= title "Resume")
contents
(concat
" <div id=\"content-generic\">\n"
"\n"
contents
"\n"
" </div>\n"))
"\n"
" <!-- content end -->\n"
"\n"))
(t
(concat
" <!-- content start -->\n"
"\n"
" <div id=\"content\">\n"
"\n"
contents
"\n"
" </div>\n"
"\n"
" <!-- content end -->\n"
"\n")))
(cond
((string= site "kylesherman")
"")
(t
(concat
" <!-- footer start -->\n"
"\n"
" <div id=\"footer\">\n"
"\n"
" <div class=\"validator\">\n"
" <a title=\"Check the validity of this page using W3C's unified validator\"\n"
(format " href=\"http://validator.w3.org/unicorn/check?ucn_task=conformance&ucn_uri=%s\">unicorn</a>\n" (org-website-get-property-element property-list :link-home))
" </div>\n"
"\n"
" <div class=\"validator\">\n"
" <a title=\"Check the validity of this page's XHTML\"\n"
" href=\"http://validator.w3.org/check?uri=referer\">xhtml</a>\n"
" </div>\n"
"\n"
" <div class=\"validator\">\n"
" <a title=\"Check the validity of this page's CSS\"\n"
" href=\"http://jigsaw.w3.org/css-validator/check/referer\">css</a>\n"
" </div>\n"
"\n"
" <div class=\"validator\">\n"
" <a title=\"Check the performance this page\"\n"
(format " href=\"https://developers.google.com/speed/pagespeed/insights/?url=%s\">pagespeed</a>\n" (org-website-get-url property-list))
" </div>\n"
"\n"
" <!--\n"
" <div class=\"validator\">\n"
" <a title=\"Check the accessibility of this page according to U.S. Section 508\"\n"
(format " href=\"http://www.contentquality.com/mynewtester/cynthia.exe?Url1=%s\">508</a>\n" (org-website-get-property-element property-list :link-home))
" </div>\n"
" -->\n"
"\n"
" <div class=\"license\">\n"
" <span>Last Modified: " (org-website-get-property-element property-list :last-modified) "<br />\n"
" " (org-website-get-property-element property-list :copyright) "<br />\n"
" <span class=\"license\">Creative Commons\n"
" <a title=\"View details of the license of this site\"\n"
" href=\"http://creativecommons.org/licenses/by-nc-sa/3.0/\">\n"
" Attribution-NonCommercial-ShareAlike\n"
" </a> license</span></span>\n"
" </div>\n"
"\n"
" </div>\n"
"\n"
" <!-- footer end -->\n"
"\n")))
" </div>\n"
"\n"
"</body>\n"
"\n"
"</html>\n")))
(init-message 3 "Org Website: Publish HTML: Blog Contents Template")
(defun org-website-html-blog-contents-template (contents info property-list)
"Return blog contents string after HTML conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options.
PROPERTY-LIST is the list of org properties found in INFO."
(let ((post (org-website-is-blog-post property-list))
(site-url (org-website-get-property-element property-list :link-home)))
(concat
(with-temp-buffer
(insert-file-contents "~/web/sites/nulldot/site/menu-index.html-nopub")
(goto-char (point-min))
(while (re-search-forward "^" nil :noerror)
(replace-match " "))
(buffer-string))
"\n"
" <!-- content-index start -->\n"
"\n"
" <div id=\"content-index\">\n"
"\n"
(if post
(concat
" <div class=\"timestamp\">"
(substring (org-website-get-property-element property-list :posted) 0 10)
"</div>\n"
(concat
" <h2><a href=\"" (org-website-get-url property-list) "\">"
(org-website-get-property-element property-list :description)
"</a></h2>\n"))
"")
contents
(if post
(concat
"\n"
" <div class=\"tags\">Tags: " (org-website-get-property-element property-list :tags) "</div>\n"
"\n"
)
"")
"\n"
" </div>\n"
"\n"
" <!-- content-index end -->\n"
"\n")))
(init-message 3 "Org Website: Publish HTML: Inner Template")
(defun org-website-html-inner-template (contents info)
"Return body of document string after HTML conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(require 'ox-html)
(concat
(let ((depth (plist-get info :with-toc)))
(when depth
(org-html-toc depth info)))
contents
(org-website-html-footnote-section info)))
(init-message 3 "Org Website: Publish HTML: Headline")
(defun org-website-html-headline (headline contents info)
"Transcode a HEADLINE element from Org to HTML.
CONTENTS holds the contents of the headline.
INFO is a plist holding contextual information."
(let ((level (+ (org-export-get-relative-level headline info)
(1- (or (plist-get info :html-toplevel-hlevel) 1))))
(id (org-export-data (org-element-property :CUSTOM_ID headline) info))
(title (org-export-data (org-element-property :title headline) info))
(contents (or contents "")))
(concat
(if id
(format "\n<h%d id=\"%s\">%s</h%d>\n" level id title level)
(format "\n<h%d>%s</h%d>\n" level title level))
contents)))
(init-message 3 "Org Website: Publish HTML: Section")
(defun org-website-html-section (section contents info)
"Transcode a SECTION element from Org to HTML.
CONTENTS holds the contents of the section.
INFO is a plist holding contextual information."
(or contents ""))
(init-message 3 "Org Website: Publish HTML: Footnote Reference")
(defun org-website-html-footnote-reference (footnote-reference _contents info)
"Transcode a FOOTNOTE-REFERENCE element from Org to HTML.
CONTENTS is nil.
INFO is a plist holding contextual information."
(require 'ox-html)
(concat
(let ((prev (org-export-get-previous-element footnote-reference info)))
(when (eq (org-element-type prev) 'footnote-reference)
(plist-get info :html-footnote-separator)))
(let* ((n (org-export-get-footnote-number footnote-reference info))
(id (format "fnr.%d%s"
n
(if (org-export-footnote-first-reference-p
footnote-reference info)
""
".100"))))
(format
(plist-get info :html-footnote-format)
(org-html--anchor
id n (format " class=\"footnote-reference\" href=\"#fn.%d\"" n) info)))))
(init-message 3 "Org Website: Publish HTML: Footnote Section")
(defun org-website-html-footnote-section (info)
"Format the footnote section.
INFO is a plist used as a communication channel."
(let* ((fn-alist (org-export-collect-footnote-definitions info))
(fn-alist
(cl-loop for (n type raw) in fn-alist
collect (cons n (if (eq (org-element-type raw) 'org-data)
(org-trim (org-export-data raw info))
(format "<p>%s</p>" (org-trim (org-export-data raw info))))))))
(when fn-alist
(format
"<div class=\"footnotes\">\n%s</div>"
(mapconcat
(lambda (fn)
(let ((n (car fn))
(def (cdr fn)))
(format
"<div class=\"footnote\">\n%s\n%s\n</div>\n"
(format
org-html-footnote-format
(org-html--anchor
(format "fn.%s" n)
n
(format " class=\"footnote-number\" href=\"#fnr.%s\"" n)
info))
def)))
fn-alist "\n")))))
(init-message 2 "Org Website: Publish RSS")
(init-message 3 "Org Website: Publish RSS: Derived Backend")
(org-export-define-derived-backend 'org-website-rss 'html
:translate-alist '((template . org-website-rss-template)
(inner-template . org-website-rss-inner-template)))
(init-message 3 "Org Website: Publish RSS: Publish to RSS")
(defun org-website-rss-publish-to-rss (plist file-name pub-dir)
"Publish a Website org file to RSS and return output file name.
FILE-NAME is the file name of the Org file to be published.
PLIST is the property list for the given project.
PUB-DIR is the publishing directory."
(org-publish-org-to 'org-website-rss file-name ".rss" plist pub-dir))
(init-message 3 "Org Website: Publish RSS: Template")
(defun org-website-rss-template (contents info)
"Return complete document string after RSS conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(let* ((property-list (org-website-get-property-list info))
(link-home (org-website-get-property-element property-list :link-home))
(title (org-website-get-property-element property-list :title)))
(concat
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n"
" xmlns=\"http://purl.org/rss/1.0/\"\n"
" xmlns:slash=\"http://purl.org/rss/1.0/modules/slash/\"\n"
" xmlns:taxo=\"http://purl.org/rss/1.0/modules/taxonomy/\"\n"
" xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n"
" xmlns:syn=\"http://purl.org/rss/1.0/modules/syndication/\"\n"
" xmlns:admin=\"http://webns.net/mvcb/\"\n"
" xmlns:feedburner=\"http://rssnamespace.org/feedburner/ext/1.0\">\n\n"
" <channel rdf:about=\"" link-home "\">\n"
" <title>" title "</title>\n"
" <link>" link-home "</link>\n"
" <description>" (org-website-get-property-element property-list :description) "</description>\n"
" <dc:language>en-us</dc:language>\n"
" <dc:rights>" (org-website-get-property-element property-list :copyright) "</dc:rights>\n"
" <dc:date>" (format-time-string "%FT%TZ" nil t) "</dc:date>\n"
" <dc:publisher>" (org-website-get-property-element property-list :author) "</dc:publisher>\n"
" <dc:creator>" (org-website-get-property-element property-list :author) "</dc:creator>\n"
" <dc:subject>Software Engineering</dc:subject>\n"
" <syn:updatePeriod>daily</syn:updatePeriod>\n"
" <syn:updateFrequency>1</syn:updateFrequency>\n"
" <syn:updateBase>2007-06-04T00:00:00Z</syn:updateBase>\n"
" <items>\n"
" <rdf:Seq>\n"
" </rdf:Seq>\n"
" </items>\n"
" <image rdf:resource=\"" link-home "img/image.jpg\" />\n"
" </channel>\n\n"
" <image rdf:about=\"" link-home "img/image.jpg\">\n"
" <title>" title "</title>\n"
" <url>" link-home "img/image.jpg</url>\n"
" <link>" link-home "</link>\n"
" </image>\n"
contents
"\n"
" <textinput rdf:about=\"" link-home "search.html\">\n"
" <title>Search " title "</title>\n"
" <description>Search " title " entries</description>\n"
" <name>query</name>\n"
" <link>" link-home "search.html</link>\n"
" </textinput>\n\n"
"</rdf:RDF>\n")))
(init-message 3 "Org Website: Publish RSS: Inner Template")
(defun org-website-rss-inner-template (contents info)
"Return body of document string after RSS conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(let ((property-list (org-website-get-property-list info)))
(concat
"\n"
" <item rdf:about=\"" (org-website-get-url property-list) "\">\n"
" <title>" (org-website-get-property-element property-list :description) "</title>\n"
" <link>" (org-website-get-url property-list) "</link>\n"
" <description>\n"
" <![CDATA[\n"
contents
" ]]>\n"
" </description>\n"
" </item>\n"
(org-website-html-footnote-section info))))
(init-message 2 "Org Website: Publish Gopher")
(init-message 3 "Org Website: Publish Gopher: Derived Backend")
(org-export-define-derived-backend 'gopher 'ascii
:translate-alist '((template . org-website-gopher-template)
(inner-template . org-website-gopher-inner-template)
(headline . org-website-gopher-headline)
(section . org-website-gopher-section)))
(init-message 3 "Org Website: Publish Gopher: Publish to Gopher")
(defun org-website-gopher-publish-to-gopher (plist file-name pub-dir)
"Publish a Website org file to Gopher and return output file name.
FILE-NAME is the file name of the Org file to be published.
PLIST is the property list for the given project.
PUB-DIR is the publishing directory."
(org-publish-org-to 'gopher file-name ".gopher" plist pub-dir))
(init-message 3 "Org Website: Publish Gopher: Template")
(defun org-website-gopher-template (contents info)
"Return complete document string after Gopher conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(let* ((property-list (org-website-get-property-list info))
(site (org-website-get-property-element property-list :site))
(title (org-website-get-property-element property-list :title)))
(concat
(format "%s\n\n" (org-website-format-headline title))
(if (string= (downcase title) "nullman")
(concat
(format "%s\n\n" (org-website-format-headline "menu"))
(mapconcat
(lambda (x)
(let* ((plist (cdr x))
(name (plist-get plist :name))
(title (plist-get plist :title))
(selector (plist-get plist :selector)))
(format "%s\t%s\t%s\n" gopher-type-submenu title (org-website-get-gopher-selector-hostname-port selector))))
(if (string= site "shermanwest")
org-website-shermanwest-menu-list
org-website-menu-list)
"")
"\n")
"")
(cond
((string= site "nulldot")
(org-website-gopher-blog-contents-template contents info property-list))
(t
(concat contents "\n")))
(cond
((string= site "kylesherman")
"")
(t
(concat
(format "%s\n\n" (make-string gopher-text-width ?=))
(format "Last Modified: %s\n" (org-website-get-property-element property-list :last-modified))
(format "%s\n" (org-website-get-property-element property-list :copyright))
(format "%s\t%s\t%s\t%s\n"
gopher-type-html-file
"Creative Commons Attribution-NonCommercial-ShareAlike license"
"http://creativecommons.org/licenses/by-nc-sa/3.0/"
gopher-port))))
)))
(init-message 3 "Org Website: Publish Gopher: Inner Template")
(defun org-website-gopher-inner-template (contents info)
"Return body of document string after Gopher conversion.
CONTENTS is the transcoded contents string.
INFO is a plist holding export options."
(require 'ox-ascii)
(concat
(replace-regexp-in-string "^ " "" contents)
(org-website-gopher-footnote-section info)))
(init-message 3 "Org Website: Publish Gopher: Headline")
(defun org-website-gopher-headline (headline contents info)
"Transcode a HEADLINE element from Org to Gopher.
CONTENTS holds the contents of the headline.
INFO is a plist holding contextual information."
(let ((level (+ (org-export-get-relative-level headline info)
(1- (or (plist-get info :gopher-toplevel-hlevel) 1))))
(text (org-export-data (org-element-property :title headline) info))
(contents (or contents "")))
(concat
(format "\n%s\n" (if (< level 3)
(org-website-format-headline text ?= gopher-text-width)
(org-website-format-headline text ?- gopher-text-width)))
contents)))
(init-message 3 "Org Website: Publish Gopher: Section")
(defun org-website-gopher-section (section contents info)
"Transcode a SECTION element from Org to Gopher.
CONTENTS holds the contents of the section.
INFO is a plist holding contextual information."
(or contents ""))
(init-message 3 "Org Website: Publish Gopher: Footnote Reference")
(defun org-website-gopher-footnote-reference (footnote-reference _contents info)
"Transcode a FOOTNOTE-REFERENCE element from Org to Gopher.
CONTENTS is nil.
INFO is a plist holding contextual information."
(require 'ox-ascii)
(concat
(let ((prev (org-export-get-previous-element footnote-reference info)))
(when (eq (org-element-type prev) 'footnote-reference)
(plist-get info :ascii-footnote-separator)))
(let ((n (org-export-get-footnote-number footnote-reference info)))
(format
(plist-get info :ascii-footnote-format)
(format "%d" n)))))
(init-message 3 "Org Website: Publish Gopher: Footnote Section")
(defun org-website-gopher-footnote-section (info)
"Format the footnote section.
INFO is a plist used as a communication channel."
(let* ((fn-alist (org-export-collect-footnote-definitions info))
(fn-alist
(cl-loop for (n type raw) in fn-alist
collect (cons n (if (eq (org-element-type raw) 'org-data)
(org-trim (org-export-data raw info))
(format "%s" (org-trim (org-export-data raw info))))))))
(when fn-alist
(format
"%s"
(mapconcat
(lambda (fn)
(let ((n (car fn))
(def (cdr fn)))
(format
"%s\n%s\n"
(format
org-ascii-footnote-format
(format "%s" n))
def)))
fn-alist "\n")))))
(init-message 2 "Org Website: Helper Functions")
(init-message 3 "Org Website: Helper Functions: Publish")
(defun org-website-publish (&optional project force)
"Publish org-website projects.
If PROJECT is non-nil, only publish that project.
If FORCE is non-nil, force publish all files in project."
(interactive)
(let ((files (directory-files "~/web/org/" nil "\.org\\'")))
(when (member "styles.org" files)
(setq files (append "styles.org" (remove "styles.org" files))))
(dolist (file files)
(let ((site (file-name-sans-extension file)))
(when (or (not project)
(string= project site))
(org-publish site force))))))
(defun org-website-publish-async (&optional project force)
"Asynchronous version of `org-website-publish'."
(interactive)
(eval
`(async-spinner
(lambda ()
(load "~/web/bin/init-emacs-website.el")
(org-website-publish ,project ,force))
(lambda (result)
(message "Website publish finished")))))
(init-message 3 "Org Website: Helper Functions: Tangle Publish")
(defun org-website-tangle-publish (&optional project force)
"Tangle and publish org-website projects.
If PROJECT is non-nil, only tangle/publish that project.
If FORCE is non-nil, force publish all files in project."
(interactive)
(let ((files (directory-files "~/web/org/" nil "\.org\\'"))
(org-html-htmlize-output-type 'css))
(when (member "styles.org" files)
(setq files (append "styles.org" (remove "styles.org" files))))
(dolist (file files)
(let ((site (file-name-sans-extension file)))
(when (or (not project)
(string= project site))
(org-babel-tangle-file (concat "~/web/org/" file))
(org-publish site force))))))
(defun org-website-tangle-publish-async (&optional project force)
"Asynchronous version of `org-website-tangle-publish'."
(interactive)
(eval
`(async-spinner
(lambda ()
(load "~/web/bin/init-emacs-website.el")
(org-website-tangle-publish ,project ,force))
(lambda (result)
(message "Website tangle/publish finished")))))
(init-message 3 "Org Website: Helper Functions: Blog Post Create")
(defun org-website-blog-post-create (&optional title)
"Create empty blog post entry with TITLE.
If TITLE is nil, caller is prompted for one."
(interactive "sTitle: ")
(save-match-data
(setq title (titleize title))
(find-file "~/web/org/nulldot.org")
(goto-char (point-min))
(re-search-forward "^\*\*\* Blog Posts$")
(org-forward-heading-same-level 1 t)
(forward-line -1)
(newline)
(let* ((ts (current-time))
(time (format-time-string "%Y.%m.%d.%H%M" ts))
(name (concat time "-" (org-generate-custom-id-from-title title)))
(path (format-time-string "%Y/%m" ts))
(file (concat "~/web/sites/nulldot/site/" path "/" name ".org"))
(posted (format-time-string "%Y-%m-%d %H:%M" ts)))
(insert
(concat
"******* " time " " title "\n"
" :PROPERTIES:\n"
" :CUSTOM_ID: site-blog-posts-" time "\n"
" :END:\n"
"\n"
"#+NAME: blog-" time "\n"
"#+BEGIN_SRC org :tangle " file "\n"
" <<level-2>>\n"
" ,#+TITLE: " title "\n"
" ,#+DESCRIPTION: \n"
" ,#+POSTED: " posted "\n"
" ,#+LAST_MODIFIED: " posted "\n"
" ,#+UUID: " (uuid) "\n"
" ,#+TAGS: \n"
"\n"
" ,#+ATTR_HTML: :class blog-img :title " title "\n"
" [[][<<site-url>>/" path "/img/]]\n"
"\n"
"\n"
"\n"
" ,#+BEGIN_QUOTE\n"
" ,#+END_QUOTE\n"
"#+END_SRC\n"))
(forward-line -14)
(goto-char (line-end-position)))))
(init-message 3 "Org Website: Helper Functions: Blog Post Update Posted")
(defun org-website-blog-post-update-posted (&optional date)
"Update posted time of current blog post entry.
Set blog timestamp to `current-time' or DATE, if non-nil."
(interactive)
(when (string= (expand-file-name "~/web/org/nulldot.org") buffer-file-name)
(save-mark-and-excursion
(save-match-data
(let* ((case-fold-search t)
(start (progn (org-previous-visible-heading 1) (point)))
(end (progn (org-next-visible-heading 1) (point)))
(title (progn (goto-char start) (re-search-forward "#\\+TITLE: \\(.*\\)" end) (match-string 1)))
(ts (if date (date-to-time date) (current-time)))
(time (format-time-string "%Y.%m.%d.%H%M" ts))
(name (concat time "-" (org-generate-custom-id-from-title title)))
(path (format-time-string "%Y/%m" ts))
(file (concat "~/web/sites/nulldot/site/" path "/" name ".org"))
(posted (format-time-string "%Y-%m-%d %H:%M" ts)))
(goto-char start)
(re-search-forward "^\*+ \\(.*\\)" (line-end-position))
(replace-match (concat time " " title) nil nil nil 1)
(re-search-forward "^[ \t]*:CUSTOM_ID: site-blog-posts-\\(.*\\)" end)
(replace-match time nil nil nil 1)
(re-search-forward "^[ \t]*#\\+NAME: blog-\\(.*\\)" end)
(replace-match time nil nil nil 1)
(re-search-forward "^[ \t]*#\\+BEGIN_SRC org :tangle \\(.*\\)" end)
(let ((old-file (match-string 1)))
(when (file-exists-p old-file)
(delete-file old-file)))
(replace-match file nil nil nil 1)
(re-search-forward "^[ \t]*#\\+POSTED: \\(.*\\)" end)
(replace-match posted nil nil nil 1)
(re-search-forward "^[ \t]*#\\+LAST_MODIFIED: \\(.*\\)" end)
(replace-match posted nil nil nil 1))))))
(init-message 3 "Org Website: Helper Functions: Unflatten")
(defun unflatten (xs &optional fn-value fn-level)
"Unflatten a list XS into a tree, e.g. (1 2 3 1) => (1 (2 (3)) 1).
FN-VALUE specifies how to extract the values from each element,
which are included in the output tree, FN-LEVEL tells how to
extract the level of each element. By default these are the
`identity' function so it will work on a list of numbers."
(let* ((level 1)
(tree (cons nil nil))
(start tree)
(stack nil)
(fn-value (or fn-value #'identity))
(fn-level (or fn-level #'identity)))
(dolist (x xs)
(let ((x-value (funcall fn-value x))
(x-level (funcall fn-level x)))
(cond
((> x-level level)
(setcdr tree (cons (cons x-value nil) nil))
(setq tree (cdr tree))
(push tree stack)
(setq tree (car tree))
(setq level x-level))
((= x-level level)
(setcdr tree (cons x-value nil))
(setq tree (cdr tree)))
((< x-level level)
(while (< x-level level)
(setq tree (pop stack))
(setq level (- level 1)))
(setcdr tree (cons x-value nil))
(setq tree (cdr tree))
(setq level x-level)))))
(cdr start)))
(init-message 2 "Org Website: Generate Website Emacs Initialization File")
(defun org-website-generate-website-emacs-initialization-file ()
"Generate minimal version of init-emacs.el called
init-emacs-website.el to be used with batch commands."
(save-mark-and-excursion
(save-match-data
(let ((source-file (expand-file-name "init-emacs.el" emacs-home-dir))
(target-file (expand-file-name "init-emacs-website.el" "~/web/bin"))
(sections (append '( ";;; Package Manager: Straight"
";; set emacs home directory"
";; do not make backup files"
";;;; Org Mode: Functions: org-get-file-data"
";;;; Org Mode: Babel: Setup"
";;;; Org Mode: Babel: Tangle Update Timestamps"
";;;; Org Mode: Babel: Tangle Case-Sensitive"
";;;; Functions: Emacs Functions: delete-line"
";;; Packages: htmlize"
";;; Packages: w3m")
(let ((start (progn
(goto-char (point-min))
(re-search-forward "^[ \t]*:CUSTOM_ID: org-website$")))
(end (re-search-forward "^[ \t]*:CUSTOM_ID: org-website-generate-website-emacs-initialization-file$"))
list)
(goto-char start)
(while (re-search-forward "^[ \t]*\\(;;;; .*\\)$" end :noerror)
(push (match-string-no-properties 1) list))
(nreverse list))))
(prefix (concat "(require 'cl-macs)\n"
"(require 'subr-x)\n"
"(require 'org)\n"
"(require 'ox)\n")))
(org-copy-tangled-sections source-file target-file sections prefix)))))
(defun after-save-hook--generate-init-emacs-website-elisp-file ()
"Hook to generate init-emacs-website.el file on save."
(when (and buffer-file-name
(string= (file-truename buffer-file-name) init-emacs-true-file-name))
(org-website-generate-website-emacs-initialization-file)))
(add-hook 'after-save-hook #'after-save-hook--generate-init-emacs-website-elisp-file :append)
(init-message 2 "Org Website: Remote Synchronization")
(init-message 3 "Org Website: Remote Synchronization: Rsync to Morpheus")
(defun org-website-rsync-to-morpheus (&optional property-list)
"Synchronize published site with morpheus server."
(interactive)
(shell-command (concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" \"${HOME}/public_html/\""
" \"morpheus:${HOME}/public_html/\""))
(shell-command (concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" \"${HOME}/public_gopher/\""
" \"morpheus:${HOME}/public_gopher/\""))
(shell-command (concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" \"${HOME}/public_gemini/\""
" \"morpheus:${HOME}/public_gemini/\"")))
(defun org-website-rsync-to-morpheus-async (&optional property-list)
"Asynchronous version of `org-website-rsync-to-morpheus'."
(interactive)
(eval
`(async-spinner
(lambda ()
(fset 'org-website-rsync-to-morpheus ,(symbol-function 'org-website-rsync-to-morpheus))
(org-website-rsync-to-morpheus ,property-list))
(lambda (result)
(message "Website rsync to morpheus finished")))))
(init-message 3 "Org Website: Remote Synchronization: Rsync to DigitalOcean")
(defun org-website-rsync-to-digitalocean (&optional application force)
"Synchronize published site with digitalocean server.
Normally, applications are not synced. If APPLICATION is non-nil,
sync it instead. Supported applications:
\"powerhouse\"
\"bloodmoon\"
If FORCE is non-nil, do not prompt before synchronizing
applicaitons."
(interactive)
(let ((digitalocean "159.203.165.79"))
(if application
(when (or force
(yes-or-no-p (format "Website rsync %s to DigitalOcean" application)))
(shell-command
(concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" --rsh=\"ssh -l kyle\""
" \"${HOME}/public_html/sites/nullware/" application "/\""
" \"" digitalocean ":/home/kyle/public_html/sites/nullware/" application "/\"")))
(progn
(shell-command
(concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" --exclude=\"nullware/powerhouse/*\""
" --exclude=\"nullware/bloodmoon/*\""
" --rsh=\"ssh -l kyle\""
" \"${HOME}/public_html/sites/\""
" \"" digitalocean ":/home/kyle/public_html/sites/\""))
(shell-command
(concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" --rsh=\"ssh -l kyle\""
" \"${HOME}/public_gopher/\""
" \"" digitalocean ":/home/kyle/public_gopher/\""))
(shell-command
(concat "rsync -rlptx --delete --force"
" --exclude=\".git*\""
" --rsh=\"ssh -l kyle\""
" \"${HOME}/public_gemini/\""
" \"" digitalocean ":/home/kyle/public_gemini/\""))))))
(defun org-website-rsync-to-digitalocean-async (&optional application force)
"Asynchronous version of `org-website-rsync-to-digitalocean'."
(interactive)
(when (or (not application)
force
(yes-or-no-p (format "Website rsync %s to DigitalOcean" application)))
(eval
`(async-spinner
(lambda ()
(fset 'org-website-rsync-to-digitalocean ,(symbol-function 'org-website-rsync-to-digitalocean))
(org-website-rsync-to-digitalocean ,application ,force))
(lambda (result)
(message "Website rsync to DigitalOcean finished"))))))
(init-message 2 "Org Website: Deployment")
(init-message 1 "Functions")
(init-message 2 "Functions: Initialization Functions")
(init-message 3 "Functions: Initialization Functions: require-if-available")
(defun require-if-available (&rest args)
"Require symbols and load library strings.
Fails quietly if some are not available."
(let (lib)
(condition-case nil
(mapc (lambda (e)
(setq lib e)
(cond
((stringp e) (load-library e))
((symbolp e) (require e))))
args)
('file-error
(progn (message "Could not load extension: %s" lib) nil)))))
(init-message 3 "Functions: Initialization Functions: load-file-if-available")
(defun load-file-if-available (file)
"Load emacs lisp file, if it exists.
Fails quietly if file does not exist."
(when (file-exists-p file)
(load-file file)))
(init-message 3 "Functions: Initialization Functions: compile-file-if-needed")
(defun compile-file-if-needed-process-file (file)
"Byte-compile expanded FILE name."
(let* ((file (expand-file-name file))
(file-comp (concat file "c")))
(when (or
(not (file-exists-p file-comp))
(file-newer-than-file-p file file-comp))
(byte-compile-file file))))
(defun compile-file-if-needed (file)
"Byte-compile emacs lisp FILE if needed."
(unless (and (> (length file) 3)
(string= (substring file -3) ".el"))
(setq file (concat file ".el")))
(if (file-exists-p file)
(compile-file-if-needed-process-file file)
(dolist (path load-path)
(let ((file (concat path "/" file)))
(when (file-exists-p file)
(compile-file-if-needed-process-file file)))))
(when (get-buffer "*Compile-Log*")
(delete-other-windows)))
(init-message 3 "Functions: Initialization Functions: with-eval-after-load")
(unless (fboundp 'with-eval-after-load)
(defmacro with-eval-after-load (file &rest body)
(declare (indent 1))
`(eval-after-load ,file
`(funcall (function ,(lambda () ,@body))))))
(init-message 3 "Functions: Initialization Functions: eval-after-load-with-byte-compile")
(defmacro eval-after-load-with-byte-compile (file &rest body)
"After FILE is loaded, evaluate BODY.
BODY is byte compiled.
FILE may be a named feature or a file name, see `eval-after-load'
for details."
(declare (indent 1) (debug t))
`(,(if (or (not byte-compile-current-file)
(if (symbolp file)
(require file nil :no-error)
(load file :no-message :no-error)))
'progn
(message "eval-after-load-with-byte-compile: cannot find %s" file)
'with-no-warnings)
(with-eval-after-load ',file ,@body)))
(init-message 3 "Functions: Initialization Functions: safe-load")
(defvar safe-load-error-list ""
"List of files that reported errors when loaded with `safe-load'.")
(defun safe-load (file &optional noerror nomessage nosuffix)
"Load FILE safely.
If an error occurs when loading, report it and add FILE to
`safe-load-error-list'."
(interactive "f")
(condition-case nil
(load file noerror nomessage nosuffix)
('error
(setq safe-load-error-list (concat safe-load-error-list " " file))
(message "Error loading %s" file)
nil)))
(defun safe-load-check ()
"Check for any previous `safe-load' loading errors."
(interactive)
(unless (string= safe-load-error-list "")
(message "Error loading: %s" safe-load-error-list)))
(defun safe-load-compile (file &optional noerror nomessage nosuffix)
"Calls `compile-file-if-needed' followed by `safe-load'."
(interactive "f")
(compile-file-if-needed file)
(safe-load file noerror nomessage nosuffix))
(init-message 2 "Functions: Advice Functions")
(init-message 3 "Functions: Advice Functions: Compile Goto Error Org")
(defun compile-goto-error--org (&optional event)
"Open compilation bugs in org file for errors in tangled elisp code."
(when (eq major-mode 'emacs-lisp-mode)
(ignore-errors (org-babel-tangle-jump-to-org))))
(defun compilation-mode-hook--compile-goto-error ()
"Hook to advise `compile-goto-error'."
(advice-add 'compile-goto-error :after #'compile-goto-error--org))
(add-hook 'compilation-mode-hook #'compilation-mode-hook--compile-goto-error)
(init-message 2 "Functions: General Functions")
(init-message 3 "Functions: General Functions: list-to-string")
(defun list-to-string (list &optional delimiter)
"Return concatenated characters in LIST using optional DELIMITER."
(let ((delimiter (or delimiter "")))
(mapconcat 'string list delimiter)))
(init-message 3 "Functions: General Functions: string-to-list")
(defun string-to-list (string)
"Return list of characters in STRING."
(cl-loop for x across string collect x))
(init-message 3 "Functions: General Functions: join-strings")
(defun join-strings (list &optional delim)
"Convert LIST of strings into a single string.
Use optional DELIM as a delimiter."
(if delim
(cl-reduce (lambda (x y) (concat x delim y)) list)
(cl-reduce (lambda (x y) (concat x y)) list)))
(init-message 3 "Functions: General Functions: file-to-string")
(defun file-to-string (file)
"Return the contents of FILE as a string."
(if (file-exists-p file)
(with-temp-buffer
(insert-file-contents file)
(buffer-string))
nil))
(init-message 3 "Functions: General Functions: safe-substring")
(defun safe-substring (string from &optional to)
"Calls the `substring' function safely.
No errors will be returned for out of range values of FROM and
TO. Instead an empty string is returned."
(let* ((len (length string))
(to (or to len)))
(when (< from 0)
(setq from (+ len from)))
(when (< to 0)
(setq to (+ len to)))
(if (or (< from 0) (> from len)
(< to 0) (> to len)
(< to from))
""
(substring string from to))))
(init-message 3 "Functions: General Functions: for-each")
(defun for-each (fn list)
"Call FN for each element in list LIST."
(when list
(funcall fn (car list))
(for-each fn (cdr list))))
(init-message 3 "Functions: General Functions: is-single")
(defun is-single (list)
"Return true if LIST is a list of one element."
(and (consp list) (null (cdr list))))
(init-message 3 "Functions: General Functions: append-element")
(defun append-element (list elm)
"Append ELM to end of list LIST."
(append list (list elm)))
(init-message 3 "Functions: General Functions: map-integer")
(defun map-integer (fn n)
"Call function FN once for every number from 0 to N-1."
(let ((acc nil))
(dotimes (i n)
(push (funcall fn i) acc))
(nreverse acc)))
(init-message 3 "Functions: General Functions: filter")
(defun filter (fn list)
"Call function FN for each element in list LIST and return the non-nil results."
(let (acc)
(dolist (x list (nreverse acc))
(let ((val (funcall fn x)))
(when val (push val acc))))))
(init-message 3 "Functions: General Functions: most")
(defun most (fn list)
"Call function FN for each element in LIST and return the highest score.
The function FN must return a number as a score for a given element.
The element with the highest result is returned with its score."
(if (null list)
(list nil nil)
(let* ((wins (car list))
(max (funcall fn wins)))
(dolist (x (cdr list))
(let ((score (funcall fn x)))
(when (> score max)
(setq wins x
max score))))
(list wins max))))
(init-message 3 "Functions: General Functions: queue")
(defun make-queue ()
"Return FIFO (first-in first-out) queue function.
Then call the queue function with one of the following commands:
'push X = Add X to the back of the queue
'pop = Remove element from the front of the queue and return it
'peek = Return the element in the front of the queue
'show = Display the queue's contents
'fb = Display the front and back queues (for debugging)
Source: http://irreal.org/blog/?p=40"
(lexical-let (front
back)
(lambda (cmd &optional data)
(cl-labels
((exchange ()
(setq front (reverse back))
(setq back '())))
(cl-case cmd
((push) (push data back))
((pop) (or (pop front)
(progn
(exchange)
(pop front))))
((peek) (unless front
(exchange))
(car front))
((show) (format "%s" (append front (reverse back))))
((fb) (format "front: %s, back: %s" front back))
(t (error "Illegal command given to queue object: %s" cmd)))))))
(init-message 3 "Functions: General Functions: quicksort")
(defun quicksort (list)
"Return sorted LIST (using the Quicksort algorithm)."
(if (null list) nil
(let* ((elt (car list))
(rst (cdr list))
(left-p (lambda (x) (< x elt))))
(append (quicksort (cl-remove-if-not left-p rst))
(list elt)
(quicksort (cl-remove-if left-p rst))))))
(init-message 3 "Functions: General Functions: hash-table-dump")
(defun hash-table-dump (table)
"Return contents of hash TABLE as an association list."
(let (result)
(maphash (lambda (k v) (push (cons k v) result)) table)
(nreverse result)))
(init-message 2 "Functions: Emacs Functions")
(init-message 3 "Functions: Emacs Functions: inside-string")
(defun inside-string ()
"Return non-nil if point is inside a string."
(not (not (nth 3 (syntax-ppss)))))
(init-message 3 "Functions: Emacs Functions: inside-comment")
(defun inside-comment ()
"Return non-nil if point is inside a comment."
(nth 4 (syntax-ppss)))
(init-message 3 "Functions: Emacs Functions: try-finally")
(defmacro try-finally (fn &rest finally)
"Evaluate FN catching and returning any errors after FINALLY is
evaluated."
`(unwind-protect
(let (result)
(condition-case err
(setq result (progn ,fn))
('error
(message (format "Caught error: %s" err))
(setq result (cons 'error (list err)))))
result)
,@finally))
(init-message 3 "Functions: Emacs Functions: save-buffer-always")
(defun save-buffer-always ()
"Save current buffer in visited file even if it has not been modified."
(interactive)
(set-buffer-modified-p t)
(save-buffer))
(init-message 3 "Functions: Emacs Functions: save-buffer-always-maybe")
(defun save-buffer-always-maybe (arg)
"Call `save-buffer' if no prefix given, otherwise call
`save-buffer-always' to force a save."
(interactive "P")
(if arg
(save-buffer-always)
(save-buffer)))
(init-message 3 "Functions: Emacs Functions: describe-function-or-variable-at-point")
(defun describe-function-or-variable-at-point (&optional point)
"Describe function or variable at POINT (or `point' if not given).
Use `describe-function' or `describe-variable' as appropriate."
(interactive)
(let ((pos (or point (point))))
(save-mark-and-excursion
(goto-char pos)
(if (eq (variable-at-point) 0)
(call-interactively 'describe-function)
(call-interactively 'describe-variable)))))
(init-message 3 "Functions: Emacs Functions: mode-line-add")
(defun mode-line-add (item)
"Add ITEM to `global-mode-string' part of the mode line."
(or global-mode-string (setq global-mode-string '("")))
(add-to-list 'global-mode-string item t))
(init-message 3 "Functions: Emacs Functions: insert-line-below")
(defun insert-line-below ()
"Insert a line below current one."
(interactive)
(end-of-line)
(newline)
(indent-for-tab-command))
(init-message 3 "Functions: Emacs Functions: insert-line-above")
(defun insert-line-above ()
"Insert a line above current one."
(interactive)
(forward-line 0)
(newline)
(forward-line -1)
(indent-for-tab-command))
(init-message 3 "Functions: Emacs Functions: move-line-down")
(defun move-line-down ()
(interactive)
(let ((col (current-column))
(eol (line-end-position)))
(forward-line 1)
(unless (> (point) eol)
(goto-char eol)
(newline))
(transpose-lines 1)
(forward-line -1)
(move-to-column col)))
(init-message 3 "Functions: Emacs Functions: move-line-up")
(defun move-line-up ()
(interactive)
(let ((col (current-column))
(eol (line-end-position)))
(forward-line 1)
(unless (> (point) eol)
(goto-char eol)
(newline))
(ignore-errors (transpose-lines -1))
(forward-line -1)
(move-to-column col)))
(init-message 3 "Functions: Emacs Functions: kill-region-or-word")
(defun kill-region-or-word ()
"Call `kill-region' or `backward-kill-word' depending on
whether or not a region is selected."
(interactive "*")
(if (use-region-p)
(kill-region (point) (mark))
(backward-kill-word 1)))
(init-message 3 "Functions: Emacs Functions: kill-duplicate-lines")
(defun kill-duplicate-lines (&optional beg end)
"Kill duplicate lines in the pre-sorted selected region or entire buffer (if none)."
(interactive "*")
(let ((beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max)))))
(save-mark-and-excursion
(save-restriction
(narrow-to-region beg end)
(goto-char (point-min))
(while (not (eobp))
(kill-line 1)
(yank)
(let ((next-line (point)))
(while (re-search-forward (format "^%s" (regexp-quote (car kill-ring))) nil :noerror)
(replace-match "" nil nil))
(goto-char next-line)))))))
(init-message 3 "Functions: Emacs Functions: indent-or-expand")
(defun indent-or-expand ()
"Either indent according to mode, or expand the word preceding point."
(interactive "*")
(if (and
(not (bobp))
(not (eobp))
(= ?w (char-syntax (char-before)))
(not (= ?w (char-syntax (char-after)))))
(dabbrev-expand nil)
(indent-according-to-mode)))
(init-message 3 "Functions: Emacs Functions: swap-windows")
(defun swap-windows ()
"If you have two windows, swap them."
(interactive)
(if (not (= (count-windows) 2))
(message "You need exactly two windows to swap them.")
(let* ((w1 (first (window-list)))
(w2 (second (window-list)))
(b1 (window-buffer w1))
(b2 (window-buffer w2))
(s1 (window-start w1))
(s2 (window-start w2)))
(set-window-buffer w1 b2)
(set-window-buffer w2 b1)
(set-window-start w1 s2)
(set-window-start w2 s1))))
(init-message 3 "Functions: Emacs Functions: toggle-window-split")
(defun toggle-window-split ()
"If you have two windows, toggle them between horizontal and vertical layouts."
(interactive)
(if (not (= (count-windows) 2))
(message "You need exactly two windows to toggle them.")
(let* ((w1 (first (window-list)))
(w2 (second (window-list)))
(b1 (window-buffer w1))
(b2 (window-buffer w2))
(s1 (window-start w1))
(s2 (window-start w2))
(e1 (window-edges w1))
(e2 (window-edges w2))
(win-2nd (not (and (<= (car e1) (car e2))
(<= (cadr e1) (cadr e2)))))
(splitter
(if (= (car e1) (car e2))
'split-window-horizontally
'split-window-vertically)))
(delete-other-windows)
(funcall splitter)
(when win-2nd (other-window 1))
(set-window-buffer (selected-window) b1)
(set-window-buffer (next-window) b2)
(select-window w1)
(when win-2nd (other-window 1)))))
(init-message 3 "Functions: Emacs Functions: enlarge-window-5")
(defun enlarge-window-5 (arg)
"Make current window 5 lines bigger."
(interactive "P")
(if arg
(enlarge-window (* 5 arg))
(enlarge-window 5)))
(init-message 3 "Functions: Emacs Functions: shrink-window-5")
(defun shrink-window-5 (arg)
"Make current window 5 lines smaller."
(interactive "P")
(if arg
(enlarge-window (* -5 arg))
(enlarge-window -5)))
(init-message 3 "Functions: Emacs Functions: compile-elisp")
(defun compile-elisp (&optional dir)
"Byte compile DIR directory.
DIR defaults to `emacs-home-dir' or `~/.emacs.d'."
(interactive)
(byte-recompile-directory (or dir emacs-home-dir "~/.emacs.d") 0))
(init-message 3 "Functions: Emacs Functions: join-next-line")
(defun join-next-line (arg)
"Join next line with current one."
(interactive "*P")
(dotimes (n (or arg 1))
(join-line -1)))
(init-message 3 "Functions: Emacs Functions: sort-all-lines")
(defun sort-all-lines (&optional reverse)
"Sort all lines in current buffer.
If REVERSE is non-nil, then sort in reverse order."
(interactive "*")
(save-mark-and-excursion
(sort-lines reverse (point-min) (point-max))))
(init-message 3 "Functions: Emacs Functions: sort-lines-removing-duplicates")
(defun sort-lines-removing-duplicates (&optional reverse beg end)
"Call `sort-lines' to sort lines in region or between BEG and END,
then remove all duplicate lines.
If REVERSE is non-nil, then sort in reverse order."
(interactive "*P\nr")
(sort-lines reverse beg end)
(save-mark-and-excursion
(goto-char end)
(let ((prev (buffer-substring-no-properties
(line-beginning-position)
(line-end-position))))
(while (and (not (bobp))
(>= (point) beg))
(forward-line -1)
(let ((line (buffer-substring-no-properties
(line-beginning-position)
(line-end-position))))
(when (string= prev line)
(delete-region (line-beginning-position) (1+ (line-end-position))))
(setq prev line))))))
(init-message 3 "Functions: Emacs Functions: delete-word")
(defun delete-word (arg)
"Delete characters forward until encountering the end of the
type of character on point. Types are: whitespace, alphanumeric,
and symbol/other.
With argument ARG, do this that many times."
(interactive "p")
(let ((whitespace-regexp "[ \t\n]")
(alphanumeric-regexp "[[:alnum:]-_]"))
(dotimes (x arg)
(delete-region
(point)
(save-mark-and-excursion
(let ((type (cond ((looking-at whitespace-regexp) :whitespace)
((looking-at alphanumeric-regexp) :alphanumeric)
(t :other)))
(char (char-after)))
(forward-char 1)
(while (and (not (eobp))
(cl-case type
(:whitespace (looking-at whitespace-regexp))
(:alphanumeric (looking-at alphanumeric-regexp))
(:other (= char (char-after)))))
(forward-char 1))
(point)))))))
(init-message 3 "Functions: Emacs Functions: backward-delete-word")
(defun backward-delete-word (arg)
"Delete characters backward until encountering the end of the
type of character on point. Types are: whitespace, alphanumeric,
and symbol/other.
With argument ARG, do this that many times."
(interactive "p")
(let ((whitespace-regexp "[ \t\n]")
(alphanumeric-regexp "[[:alnum:]-_]"))
(dotimes (x arg)
(delete-region
(save-mark-and-excursion
(backward-char 1)
(let ((type (cond ((bobp) :bobp)
((looking-at whitespace-regexp) :whitespace)
((looking-at alphanumeric-regexp) :alphanumeric)
(t :other)))
(char (char-after)))
(unless (eq type :bobp)
(backward-char 1)
(while (cl-case type
(:bobp nil)
(:whitespace (looking-at whitespace-regexp))
(:alphanumeric (looking-at alphanumeric-regexp))
(:other (= char (char-after))))
(if (bobp)
(setq type :bobp)
(backward-char 1)))
(unless (eq type :bobp)
(forward-char 1)))
(point)))
(point)))))
(init-message 3 "Functions: Emacs Functions: copy-line")
(defun copy-line (&optional line)
"Copy the line containing the point or LINE."
(interactive)
(save-mark-and-excursion
(when line
(goto-char (point-min))
(forward-line (1- line)))
(goto-char (line-beginning-position))
(let ((beg (point)))
(if (eobp)
(goto-char (line-end-position))
(forward-line 1))
(copy-region-as-kill beg (point)))))
(init-message 3 "Functions: Emacs Functions: cut-line")
(defun cut-line (&optional line)
"Cut the line containing the point or LINE."
(interactive "*")
(save-mark-and-excursion
(when line
(goto-char (point-min))
(forward-line (1- line)))
(goto-char (line-beginning-position))
(let ((beg (point)))
(if (eobp)
(goto-char (line-end-position))
(forward-line 1))
(kill-region beg (point)))))
(init-message 3 "Functions: Emacs Functions: delete-line")
(defun delete-line (&optional line)
"Delete the line containing the point or LINE."
(interactive "*")
(let ((col (- (point) (line-beginning-position))))
(when line
(goto-char (point-min))
(forward-line (1- line)))
(goto-char (line-beginning-position))
(delete-region (point)
(progn
(forward-line 1)
(point)))
(if (<= (+ (point) col) (line-end-position))
(forward-char col)
(goto-char (line-end-position)))))
(init-message 3 "Functions: Emacs Functions: delete-to-end-of-line")
(defun delete-to-end-of-line (&optional arg)
"Delete from the point to the end of the line containing the point."
(interactive "*P")
(delete-region (point)
(progn
(if arg
(forward-line (prefix-numeric-value arg))
(if (not (eolp))
(goto-char (line-end-position))
(forward-char 1)))
(point))))
(init-message 3 "Functions: Emacs Functions: duplicate-line")
(defun duplicate-line (&optional comment line)
"Duplicate the line containing the point.
If COMMENT is non-nil, also comment out the original line.
If LINE is non-nil, duplicate that line instead.
Handles duplicating `org-table' lines correctly. Also fixes
closing s-expressions properly.
Cursor is left at current column in newly created line."
(interactive "*P")
(let ((col (current-column)))
(when line
(goto-char (point-min))
(forward-line (1- line)))
(let ((line (buffer-substring (line-beginning-position) (line-end-position))))
(when comment
(comment-region (line-beginning-position) (line-end-position)))
(when (and (fboundp 'org-at-table-p) (org-at-table-p))
(org-table-insert-row)
(delete-region (line-beginning-position) (1+ (line-end-position))))
(goto-char (line-end-position))
(newline)
(insert line)
(move-to-column col)
(when (or (eq major-mode 'emacs-lisp-mode)
(eq major-mode 'lisp-mode))
(save-mark-and-excursion
(ignore-errors
(forward-line -1)
(goto-char (line-beginning-position))
(forward-sexp)
(when (looking-at "\\()+\\)[ \t]*;")
(replace-match (make-string (length (match-string 1)) ?\s) nil nil nil 1))
(when (looking-at ")+")
(replace-match ""))
(forward-line 1)))))))
(init-message 3 "Functions: Emacs Functions: duplicate-line-inc")
(defun duplicate-line-inc (&optional line)
"Duplicate the line containing the point or LINE and increment any numbers by 1."
(interactive "*")
(let ((col (current-column)))
(save-mark-and-excursion
(when line
(goto-char (point-min))
(forward-line (1- line)))
(copy-region-as-kill (line-beginning-position) (line-end-position))
(goto-char (line-end-position))
(if (eobp)
(newline)
(forward-line 1))
(open-line 1)
(yank))
(forward-line 1)
(while (re-search-forward "[0-9]+" (line-end-position) :noerror)
(let ((num (string-to-number
(buffer-substring (match-beginning 0) (match-end 0)))))
(replace-match (int-to-string (1+ num)))))
(move-to-column col)))
(init-message 3 "Functions: Emacs Functions: yank-as-rectangle")
(defun yank-as-rectangle ()
"Yank the most recently killed text as a rectangle with upper left corner at point."
(interactive "*")
(with-temp-buffer
(yank)
(goto-char (point-min))
(rectangle-mark-mode 1)
(let ((width 0))
(while (not (eobp))
(end-of-line)
(when (> (current-column) width)
(setq width (current-column)))
(forward-line 1))
(forward-line 0)
(rectangle-right-char width))
(kill-rectangle (point-min) (point)))
(yank-rectangle))
(init-message 3 "Functions: Emacs Functions: display-line-numbers-type-toggle")
(defun display-line-numbers-type-toggle ()
"Toggle `display-line-numbers' between `t' and `relative' values."
(interactive)
(setq display-line-numbers
(if (eq display-line-numbers 'relative)
t
'relative)))
(init-message 3 "Functions: Emacs Functions: goto-line-enhanced")
(defun goto-line-enhanced ()
"Show line numbers while prompting for the line number to go to."
(interactive)
(if (or
display-line-numbers
current-prefix-arg)
(call-interactively 'goto-line)
(unwind-protect
(progn
(display-line-numbers-mode 1)
(call-interactively 'goto-line))
(display-line-numbers-mode -1))))
(bind-keys* ([remap goto-line] . goto-line-enhanced))
(init-message 3 "Functions: Emacs Functions: forward-sexp-enhanced")
(defun forward-sexp-enhanced (arg)
"Move point forward one balanced expression (sexp) or ARG sexp's (backward if ARG is negative)."
(interactive "P")
(let ((arg (or arg 1))
(p (point)))
(ignore-errors
(forward-sexp arg))
(when (= p (point))
(cond
((> arg 0)
(forward-char 1)
(when (> arg 1)
(forward-sexp-enhanced (1- arg))))
((< arg 0)
(forward-char -1)
(when (< arg -1)
(forward-sexp-enhanced (1+ arg))))
(t)))))
(bind-keys* ([remap forward-sexp] . forward-sexp-enhanced))
(init-message 3 "Functions: Emacs Functions: backward-sexp-enhanced")
(defun backward-sexp-enhanced (arg)
"Move point backward one balanced expression (sexp) or ARG sexp's (forward if ARG is negative)."
(interactive "P")
(let ((arg (or arg 1)))
(forward-sexp-enhanced (- 0 arg))))
(bind-keys* ([remap backward-sexp] . backward-sexp-enhanced))
(init-message 3 "Functions: Emacs Functions: scroll-up-enhanced")
(defun scroll-up-enhanced (arg)
"Scroll up one page or ARG amount.
If less than a page away, jump to the end of the buffer."
(interactive "P")
(let ((col (current-column)))
(condition-case nil
(if arg
(scroll-up arg)
(scroll-up))
('error
(goto-char (point-max))))
(move-to-column col)))
(bind-keys* ([remap scroll-up] . scroll-up-enhanced))
(init-message 3 "Functions: Emacs Functions: scroll-down-enhanced")
(defun scroll-down-enhanced (arg)
"Scroll down one page or ARG amount.
If less than a page away, jump to the beginning of the buffer."
(interactive "P")
(let ((col (current-column)))
(condition-case nil
(if arg
(scroll-down arg)
(scroll-down))
('error
(goto-char (point-min))))
(move-to-column col)))
(bind-keys* ([remap scroll-down] . scroll-down-enhanced))
(init-message 3 "Functions: Emacs Functions: scroll-up-command-enhanced")
(defun scroll-up-command-enhanced (arg)
"Scroll up one page or ARG amount.
If less than a page away, jump to the end of the buffer."
(interactive "P")
(let ((col (current-column)))
(condition-case nil
(if arg
(scroll-up-command arg)
(scroll-up-command))
('error
(goto-char (point-max))))
(move-to-column col)))
(bind-keys* ([remap scroll-up-command] . scroll-up-command-enhanced))
(init-message 3 "Functions: Emacs Functions: scroll-down-command-enhanced")
(defun scroll-down-command-enhanced (arg)
"Scroll down one page or ARG amount.
If less than a page away, jump to the beginning of the buffer."
(interactive "P")
(let ((col (current-column)))
(condition-case nil
(if arg
(scroll-down-command arg)
(scroll-down-command))
('error
(goto-char (point-min))))
(move-to-column col)))
(bind-keys* ([remap scroll-down-command] . scroll-down-command-enhanced))
(init-message 3 "Functions: Emacs Functions: downcase-region-enhanced")
(defun downcase-region-enhanced (&optional beg end)
"Convert region, or current line, to lower case."
(interactive "*")
(let ((beg (or beg (if (use-region-p) (region-beginning) (line-beginning-position))))
(end (or end (if (use-region-p) (region-end) (line-end-position)))))
(deactivate-mark)
(downcase-region beg end)))
(bind-keys* ("C-x C-l" . downcase-region-enhanced))
(init-message 3 "Functions: Emacs Functions: upcase-region-enhanced")
(defun upcase-region-enhanced (&optional beg end)
"Convert region, or current line, to upper case."
(interactive "*")
(let ((beg (or beg (if (use-region-p) (region-beginning) (line-beginning-position))))
(end (or end (if (use-region-p) (region-end) (line-end-position)))))
(deactivate-mark)
(upcase-region beg end)))
(bind-keys* ("C-x C-u" . upcase-region-enhanced))
(init-message 3 "Functions: Emacs Functions: downcase-word-enhanced")
(defun downcase-word-enhanced (arg)
"Convert word at point to lower case."
(interactive "*P")
(let ((p (point)))
(forward-word 1)
(when (> (point) p)
(forward-word -1)))
(downcase-word (or arg 1)))
(bind-keys* ([remap downcase-word] . downcase-word-enhanced))
(init-message 3 "Functions: Emacs Functions: upcase-word-enhanced")
(defun upcase-word-enhanced (arg)
"Convert word at point to upper case."
(interactive "*P")
(let ((p (point)))
(forward-word 1)
(when (> (point) p)
(forward-word -1)))
(upcase-word (or arg 1)))
(bind-keys* ([remap upcase-word] . upcase-word-enhanced))
(init-message 3 "Functions: Emacs Functions: capitalize-word-enhanced")
(defun capitalize-word-enhanced (arg)
"Capitalize word at point."
(interactive "*P")
(let ((syntax-table (copy-syntax-table (syntax-table))))
(modify-syntax-entry ?- "." syntax-table)
(with-syntax-table syntax-table
(let ((p (point)))
(forward-word 1)
(when (> (point) p)
(forward-word -1)))
(capitalize-word (or arg 1)))))
(bind-keys* ([remap capitalize-word] . capitalize-word-enhanced))
(init-message 3 "Functions: Emacs Functions: toggle-word-case")
(defun toggle-word-case (arg)
"Toggle between the following word states:
- lowercase
- capitalized
- uppercase"
(interactive "*P")
(save-mark-and-excursion
(let ((syntax-table (copy-syntax-table (syntax-table))))
(modify-syntax-entry ?- "." syntax-table)
(with-syntax-table syntax-table
(let ((p (point))
(arg (or arg 1)))
(forward-word 1)
(let ((w (point)))
(while (and (char-after)
(= (char-after) ?-))
(forward-word 1))
(let ((eow (point)))
(goto-char w)
(when (> (point) p)
(forward-word -1))
(let ((bow (point))
(word (buffer-substring-no-properties (point) eow)))
(goto-char bow)
(while (and (< (point) eow)
(or (= (point) bow)
(= (char-after) ?-)))
(cond
((s-lowercase-p word)
(capitalize-word arg))
((s-uppercase-p word)
(downcase-word arg))
(t
(upcase-word arg))))))))))))
(bind-keys* ("M-c" . toggle-word-case))
(init-message 3 "Functions: Emacs Functions: eval-current-sexp")
(defun eval-current-sexp (eval-last-sexp-arg-internal)
"Evaluate current sexp; print value in minibuffer.
Interactively, with prefix argument, print output into current buffer.
Calls `eval-last-sexp' to handle eval."
(interactive "P")
(save-mark-and-excursion
(end-of-defun)
(eval-last-sexp eval-last-sexp-arg-internal)))
(init-message 3 "Functions: Emacs Functions: eval-sexp-buffer")
(defun eval-sexp-buffer (&optional buffer)
"Evaluate all sexp's in BUFFER.
BUFFER defaults to the current buffer."
(interactive)
(save-mark-and-excursion
(when buffer
(set-buffer buffer))
(goto-char (point-min))
(let ((count 0))
(while (not (eobp))
(forward-sexp)
(eval-last-sexp nil)
(cl-incf count))
(message (format "Evaluated %d expressions." count)))))
(init-message 3 "Functions: Emacs Functions: eval-and-replace-last-sexp")
(defun eval-and-replace-last-sexp ()
"Replace sexp before point with its evaluation."
(interactive "*")
(backward-kill-sexp)
(condition-case nil
(prin1 (eval (read (current-kill 0)))
(current-buffer))
('error
(message "Invalid expression")
(insert (current-kill 0)))))
(init-message 3 "Functions: Emacs Functions: eval-and-replace-current-sexp")
(defun eval-and-replace-current-sexp ()
"Replace current sexp with its evaluation."
(interactive "*")
(save-mark-and-excursion
(end-of-defun)
(eval-and-replace-last-sexp)))
(init-message 3 "Functions: Emacs Functions: macroexpand-and-replace")
(defun macroexpand-and-replace ()
"Replace sexp before point with its macroexpand."
(interactive "*")
(backward-kill-sexp)
(condition-case nil
(prin1 (macroexpand (read (current-kill 0)))
(current-buffer))
('error
(message "Invalid expression")
(insert (current-kill 0)))))
(init-message 3 "Functions: Emacs Functions: calc-eval-and-replace-region")
(defun calc-eval-and-replace-region (beg end)
"Evaluate region using `calc-eval' and replace it with the result."
(interactive "*r")
(let ((result (calc-eval (buffer-substring-no-properties beg end))))
(kill-region beg end)
(insert result)))
(init-message 3 "Functions: Emacs Functions: calc-eval-and-replace-line")
(defun calc-eval-and-replace-line ()
"Evaluate line using `calc-eval' and replace it with the result."
(interactive "*")
(calc-eval-and-replace-region (line-beginning-position) (line-end-position)))
(init-message 3 "Functions: Emacs Functions: indent-current-sexp")
(defun indent-current-sexp ()
"Indent current sexp."
(interactive "*")
(save-mark-and-excursion
(end-of-defun)
(let ((end (point)))
(beginning-of-defun)
(indent-sexp nil)
(while (< (point) end)
(goto-char (line-end-position))
(when (eq (get-text-property (point) 'face) 'font-lock-comment-face)
(comment-indent))
(forward-line 1)))))
(init-message 3 "Functions: Emacs Functions: indent-sexp-buffer")
(defun indent-sexp-buffer (&optional buffer)
"Indent all sexp's in BUFFER.
BUFFER defaults to the current buffer."
(interactive "*")
(save-mark-and-excursion
(when buffer
(set-buffer buffer))
(goto-char (point-min))
(let ((count 0))
(while (not (eobp))
(forward-sexp 1)
(indent-current-sexp)
(cl-incf count))
(message (format "Indented %d expressions." count)))))
(init-message 3 "Functions: Emacs Functions: comment-or-uncomment-sexp")
(defun uncomment-sexp (&optional n)
"Uncomment an sexp around point."
(interactive "P")
(let* ((initial-point (point-marker))
(p)
(end (save-mark-and-excursion
(save-match-data
(when (elt (syntax-ppss) 4)
(search-backward-regexp comment-start-skip
(line-beginning-position)
:noerror))
(setq p (point-marker))
(comment-forward (point-max))
(point-marker))))
(beg (save-mark-and-excursion
(save-match-data
(forward-line 0)
(while (= end (save-mark-and-excursion
(comment-forward (point-max))
(point)))
(forward-line -1))
(goto-char (line-end-position))
(search-backward-regexp comment-start-skip
(line-beginning-position)
:noerror)
(while (looking-at-p comment-start-skip)
(forward-char -1))
(point-marker)))))
(unless (= beg end)
(uncomment-region beg end)
(goto-char p)
(while (and (ignore-errors (backward-up-list) t)
(>= (point) beg))
(skip-chars-backward (rx (syntax expression-prefix)))
(setq p (point-marker)))
(ignore-errors
(comment-region beg p))
(goto-char p)
(forward-sexp (or n 1))
(skip-chars-forward "\r\n[:blank:]")
(if (< (point) end)
(ignore-errors
(comment-region (point) end))
(goto-char end)
(skip-chars-forward "\r\n[:blank:]")
(when (= 5 (car (syntax-after (point))))
(delete-indentation))))
(unless n
(goto-char initial-point))))
(defun comment-or-uncomment-sexp (&optional n)
"Comment the sexp at point and move past it.
If already inside (or before) a comment, uncomment instead.
With a prefix argument N, (un)comment that many sexps."
(interactive "P")
(if (or (elt (syntax-ppss) 4)
(< (save-mark-and-excursion
(skip-chars-forward "\r\n[:blank:]")
(point))
(save-mark-and-excursion
(comment-forward 1)
(point))))
(uncomment-sexp n)
(dotimes (_ (or n 1))
(pcase (or (bounds-of-thing-at-point 'sexp)
(save-mark-and-excursion
(skip-chars-forward "\r\n[:blank:]")
(bounds-of-thing-at-point 'sexp)))
(`(,l . ,r)
(goto-char r)
(skip-chars-forward "\r\n[:blank:]")
(comment-region l r)
(skip-chars-forward "\r\n[:blank:]"))))))
(init-message 3 "Functions: Emacs Functions: rename-buffer-and-file")
(defun rename-buffer-and-file (file-name &optional confirm)
"Rename current buffer and file to FILE-NAME."
(interactive
(list (if buffer-file-name
(read-file-name "Rename buffer to: " default-directory)
(error "Current buffer is not visiting a file"))
(not current-prefix-arg)))
(or (not file-name) (string-equal file-name "")
(let ((source-file-name buffer-file-name))
(unless source-file-name
(error "Buffer '%s' is not visiting a file" (buffer-name)))
(write-file file-name confirm)
(when (file-exists-p file-name)
(delete-file source-file-name)))))
(init-message 3 "Functions: Emacs Functions: move-buffer-and-file")
(defun move-buffer-and-file (dir &optional confirm)
"Move current buffer and file to DIR."
(interactive
(list (if buffer-file-name
(read-directory-name "Move to directory: " default-directory
(file-name-directory buffer-file-name))
(error "Current buffer is not visiting a file"))
(not current-prefix-arg)))
(let* ((source-file-name buffer-file-name)
(dir (if (or (string= dir "")
(not (string= (substring dir -1) "/")))
(concat dir "/")
dir))
(file-name (concat dir (file-name-nondirectory source-file-name))))
(if (not source-file-name)
(message "Buffer '%s' is not visiting a file" (buffer-name))
(progn
(unless (and confirm
(file-exists-p file-name)
(not (yes-or-no-p (format "File `%s' exists; overwrite? " file-name)))
(message "Canceled"))
(copy-file source-file-name file-name t)
(delete-file source-file-name)
(set-visited-file-name file-name)
(set-buffer-modified-p nil)
(vc-refresh-state))))))
(init-message 3 "Functions: Emacs Functions: delete-buffer-and-file")
(defun delete-buffer-and-file (&optional buffer)
"Delete BUFFER and file associated with it.
BUFFER defaults to the current buffer."
(interactive)
(let* ((buffer-name (or buffer (current-buffer)))
(file-name (buffer-file-name buffer-name)))
(if (not (and file-name (file-exists-p file-name)))
(if (fboundp 'ido-kill-buffer)
(ido-kill-buffer)
(kill-buffer))
(unless (and
(not (yes-or-no-p (format "Are you sure you want to delete '%s'? " file-name)))
(message "Canceled"))
(delete-file file-name)
(kill-buffer buffer-name)
(message "File '%s' successfully deleted" file-name)))))
(init-message 3 "Functions: Emacs Functions: expand-relative-file-name")
(defun expand-relative-file-name (file-name)
"Expand FILE-NAME found in current directory."
(file-truename (expand-file-name file-name (file-name-directory (or load-file-name buffer-file-name)))))
(init-message 3 "Functions: Emacs Functions: remove-trailing-blanks")
(defun remove-trailing-blanks (&optional ask)
"Remove trailing spaces and tabs from every line in the current buffer.
Also remove trailing newlines from the end of the buffer, apart
from one.
If ASK is non-nil, ask for confirmation."
(when (and (not (zerop (buffer-size)))
(char-equal (char-after (buffer-size)) ?\n)
(save-mark-and-excursion
(save-restriction
(save-match-data
(widen)
(goto-char (point-min))
(or (search-forward " \n" nil :noerror)
(search-forward "\t\n" nil :noerror)
(re-search-forward "\n\n$" nil :noerror)))))
(if ask
(yes-or-no-p "Remove trailing spaces and newlines before saving? ")
(message "Removing trailing spaces and newlines...")
t))
(save-mark-and-excursion
(save-restriction
(save-match-data
(widen)
(goto-char (point-min))
(while (re-search-forward "[ \t]+$" nil 'move)
(replace-match ""))
(when (bolp)
(skip-chars-backward "\n")
(delete-region (1+ (point)) (point-max)))))))
nil)
(defun remove-trailing-blanks-ask ()
(remove-trailing-blanks t))
(defun install-remove-trailing-blanks ()
(add-hook 'write-contents-functions #'remove-trailing-blanks))
(defun install-remove-trailing-blanks-ask ()
(add-hook 'write-contents-functions #'remove-trailing-blanks-ask))
(init-message 3 "Functions: Emacs Functions: remove-tabs")
(defun remove-tabs (&optional ask)
"Remove tabs from every line in the current buffer.
If ASK is non-nil, ask for confirmation.
If buffer is read-only quietly do nothing."
(when (not buffer-read-only)
(when (and (not (zerop (buffer-size)))
(char-equal (char-after (buffer-size)) ?\n)
(save-mark-and-excursion
(save-restriction
(save-match-data
(widen)
(goto-char (point-min))
(search-forward "\t" nil :noerror))))
(if ask
(yes-or-no-p "Remove tabs before saving? ")
(message "Removing tabs...")
t))
(save-mark-and-excursion
(save-restriction
(save-match-data
(goto-char (point-min))
(while (re-search-forward "[ \t]+$" nil :noerror)
(delete-region (match-beginning 0) (match-end 0)))
(goto-char (point-min))
(when (search-forward "\t" nil :noerror)
(untabify (1- (point)) (point-max))))))))
nil)
(defcustom remove-tabs-exceptions '((:file . "\.tsv\\'")
(:file . "\.gopher\\'")
(:file . "\\'.gopherus.bookmarks\\'")
(:file . "\\'Makefile\\'")
(:mode . "Makefile"))
"List of mode name and file name regexp patterns to exclude
from tab removal on file save."
:type 'list
:group 'files)
(defun remove-tabs-with-exceptions (&optional ask)
(let ((file-name (file-name-nondirectory buffer-file-name)))
(unless
(cl-remove-if (lambda (x)
(let ((type (car x))
(name (cdr x)))
(and
(not (and (eq type :mode)
(stringp mode-name)
(string= mode-name name)))
(not (and (eq type :file)
(string-match name file-name))))))
remove-tabs-exceptions)
(remove-tabs ask))))
(defun remove-tabs-ask ()
(remove-tabs t))
(defun remove-tabs-with-exceptions-ask ()
(remove-tabs-with-exceptions t))
(defun install-remove-tabs ()
(add-hook 'write-contents-functions #'remove-tabs-with-exceptions))
(defun install-remove-tabs-ask ()
(add-hook 'write-contents-functions #'remove-tabs-with-exceptions-ask))
(add-hook 'write-contents-functions #'remove-tabs-with-exceptions)
(init-message 3 "Functions: Emacs Functions: indent-down")
(defun indent-down ()
"Indent current line via `lisp-indent-line' then go down one line via `next-line'."
(interactive "*")
(lisp-indent-line)
(forward-line 1))
(init-message 3 "Functions: Emacs Functions: server-start-maybe")
(defun server-start-maybe ()
"Safe way to start or restart an emacs server."
(unless (or window-system-windows
(and (fboundp 'server-runningp)
(server-running-p)))
(server-start :leave-dead)
(server-start)))
(init-message 3 "Functions: Emacs Functions: load-bookmarks")
(defun load-bookmarks (&optional file)
"Load bookmarks html FILE.
FILE defaults to `~/lynx_bookmarks.html'."
(interactive)
(let ((file (or file "~/lynx_bookmarks.html")))
(eww-open-in-new-buffer (file-truename (expand-file-name file)))))
(init-message 3 "Functions: Emacs Functions: find-file-updir")
(defun find-file-updir (name &optional directory)
"Return the absolute file name of NAME if it is found in the
current buffer's default directory or in any parent directory.
If DIRECTORY is non-nil, then it is used instead of the current
buffer's default directory."
(let ((name (file-truename (expand-file-name name directory))))
(while (and
(not (file-exists-p name))
(not (string= name (concat "/" (file-name-nondirectory name)))))
(setq name (file-truename (expand-file-name (concat
(file-name-directory name)
"../"
(file-name-nondirectory name))))))
(when (file-exists-p name) name)))
(init-message 3 "Functions: Emacs Functions: find-file-eof")
(defun find-file-eof (file)
"Run `find-file' with FILE, then move the point to the end of buffer."
(find-file file)
(goto-char (point-max)))
(init-message 3 "Functions: Emacs Functions: mark-full-word")
(defun mark-full-word (&optional arg allow-extend)
"Set mark ARG words away from start of word at point.
Point is moved to the beginning of the word at point, then
`mark-word' is called with the given arguments."
(interactive "P\np")
(beginning-of-thing 'word)
(mark-word arg allow-extend))
(init-message 3 "Functions: Emacs Functions: term-buffer")
(defun term-buffer ()
"Create or visit a persistent terminal buffer."
(interactive)
(let ((name "*ansi-term*"))
(if (not (get-buffer name))
(progn
(split-window-sensibly (selected-window))
(other-window 1)
(ansi-term (getenv "SHELL")))
(switch-to-buffer-other-window name))))
(init-message 3 "Functions: Emacs Functions: term-ansi")
(when (fboundp 'term-ansi-make-term)
(defun term-ansi (name cmd &rest switches)
"Run an application in an ansi-term window."
(let ((buffer (apply #'term-ansi-make-term
(generate-new-buffer-name (concat "*" name "*"))
cmd nil switches)))
(set-buffer buffer)
(when (fboundp 'term-mode) (term-mode))
(when (fboundp 'term-char-mode) (term-char-mode))
(when (fboundp 'term-set-escape-char) (term-set-escape-char ?\C-x))
(switch-to-buffer buffer))))
(init-message 3 "Functions: Emacs Functions: pop-up-shell")
(defun pop-up-shell (arg)
"Pop-up a shell in a side window passing ARG."
(interactive "P")
(select-window
(display-buffer-in-side-window
(save-window-excursion
(let ((prefix-arg arg))
(call-interactively #'shell))
(current-buffer))
'((side . bottom)))))
(init-message 3 "Functions: Emacs Functions: pop-up-shell-toggle")
(defun pop-up-shell-toggle (arg)
"Toggle visibility of `pop-up-shell'.
ARG is passed along if shell is being toggled on."
(interactive "P")
(let ((buffer-window (get-buffer-window "*shell*")))
(if buffer-window
(delete-window buffer-window)
(pop-up-shell arg))))
(init-message 3 "Functions: Emacs Functions: switch-to-scratch")
(defun switch-to-scratch ()
"Switch to `*scratch*' buffer, creating it if needed."
(interactive)
(switch-to-buffer "*scratch*"))
(init-message 3 "Functions: Emacs Functions: switch-to-scratch-for-current-mode")
(defun switch-to-scratch-for-current-mode ()
"Switch to `*scratch-MODE*' buffer, creating it if needed."
(interactive)
(let* ((mode major-mode)
(buffer-name (concat "*scratch-" (symbol-name mode) "*")))
(switch-to-buffer buffer-name)
(funcall mode)))
(init-message 3 "Functions: Emacs Functions: new-scratch")
(defun new-scratch ()
"Create a new scratch buffer."
(interactive)
(switch-to-buffer (generate-new-buffer-name "*scratch*")))
(init-message 3 "Functions: Emacs Functions: new-emacs-lisp-scratch")
(defun new-emacs-lisp-scratch ()
"Create a new scratch buffer with `emacs-lisp-mode'."
(interactive)
(switch-to-buffer (generate-new-buffer-name "*scratch-emacs-lisp-mode*"))
(emacs-lisp-mode))
(init-message 3 "Functions: Emacs Functions: recreate-scratch-when-killed")
(defun recreate-scratch-when-killed ()
"Recreate scratch buffer, when it is killed.
Add the following to your init.el file for this to work:
\(add-hook 'kill-buffer-query-functions #'recreate-scratch-when-killed)"
(interactive)
(let ((buffer-name "*scratch*"))
(if (string= (buffer-name (current-buffer)) buffer-name)
(let ((kill-buffer-query-functions kill-buffer-query-functions))
(remove-hook 'kill-buffer-query-functions 'recreate-scratch-when-killed)
(kill-buffer (current-buffer))
(set-buffer (get-buffer-create buffer-name))
nil)
t)))
(add-hook 'kill-buffer-query-functions #'recreate-scratch-when-killed)
(init-message 3 "Functions: Emacs Functions: switch-to-messages")
(defun switch-to-messages ()
"Switch to `*Messages*' buffer, creating it if needed."
(interactive)
(switch-to-buffer "*Messages*"))
(init-message 3 "Functions: Emacs Functions: diff-current-buffer")
(defun diff-current-buffer ()
"Show a diff of the current buffer with its file contents."
(interactive)
(diff-buffer-with-file (current-buffer)))
(init-message 3 "Functions: Emacs Functions: get-char-property-here")
(defun get-char-property-here ()
"Get character property at current point."
(interactive)
(let (face)
(setq face (get-char-property (point) 'face))
(when (called-interactively-p 'any)
(message "%s" face))
face))
(init-message 3 "Functions: Emacs Functions: comments-in-buffer")
(defun comments-in-buffer (&optional beg end)
"Return a list of all the comments in the current buffer.
Optional START and END parameters will limit the search to a region."
(interactive)
(let ((beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max))))
comments)
(save-mark-and-excursion
(save-restriction
(save-match-data
(narrow-to-region beg end)
(goto-char (point-min))
(while (comment-search-forward (point-max) t)
(push (buffer-substring-no-properties (point) (line-end-position)) comments))))
(nreverse comments))))
(init-message 3 "Functions: Emacs Functions: count-words")
(defun count-words (&optional beg end)
"Count the number of words in the selected region or entire buffer (if none)."
(interactive)
(let* ((beg (or beg (if (use-region-p) (region-beginning) (point-min))))
(end (or end (if (use-region-p) (region-end) (point-max))))
(count (how-many "\\w+" beg end)))
(when (called-interactively-p 'any)
(message "%s" count))
count))
(init-message 3 "Functions: Emacs Functions: count-words-paragraph")
(defun count-words-paragraph ()
"Count the number of words in the current paragraph."
(interactive)
(save-mark-and-excursion
(let (end
(count 0))
(forward-paragraph 1)
(setq end (point))
(backward-paragraph 1)
(setq count (how-many "\\w+" (point) end))
(when (called-interactively-p 'any)
(message "%s" count))
count)))
(init-message 3 "Functions: Emacs Functions: date-offset")
(defun date-offset (&optional offset timezone format)
"Return current date/time plus OFFSET seconds.
OFFSET is the number of seconds to add to the current
time (defaults to 0).
TIMEZONE changes the timezone (defaults to local system setting).
FORMAT is a 'date' format string (defaults to
'+%Y-%m-%dT%H:%M:%SZ')."
(interactive)
(let* ((offset (or offset 0))
(format (or format (setq format "+%Y-%m-%dT%H:%M:%SZ")))
(date (replace-regexp-in-string
"^ +\\|[ \n]+$" ""
(shell-command-to-string
(concat
(if timezone
(concat "TZ=" (shell-quote-argument timezone) " ")
"")
"date -d \"" (shell-quote-argument (number-to-string offset))
" sec\" " (shell-quote-argument format))))))
(when (called-interactively-p 'any)
(message "%s" date))
date))
(init-message 3 "Functions: Emacs Functions: ascii-table")
(defun ascii-table ()
"Print a table of the ASCII characters from 0 to 254 in a buffer."
(interactive)
(let ((special-chars ["NUL " "SOH " "STX " "ETX " "EOT "
"ENQ " "ACK " "BEL " "BS " "HT "
"LF " "VT " "FF " "CR " "SO "
"SI " "DLE " "DC1 " "DC2 " "DC3 "
"DC4 " "NAK " "SYN " "ETB " "CAN "
"EM " "SUB " "ESC " "FS " "GS "
"RS " "US "]))
(switch-to-buffer "*ASCII Table*")
(buffer-disable-undo (current-buffer))
(let (buffer-read-only)
(erase-buffer)
(dotimes (y 32)
(dotimes (x 8)
(when (and (> y 0) (zerop (mod x 8)))
(newline))
(let ((c (+ y (* x 32))))
(insert (format "%4d " c)
(cond
((< c 32)
(aref special-chars c))
((= c 127)
"DEL ")
((or (< c 127) (> c 159))
(format "%-4c" c))
(t " ")))))))
(setq buffer-read-only t)
(goto-char (point-min))))
(init-message 3 "Functions: Emacs Functions: http-status-code-table")
(defun http-status-code-table ()
"Print a table of the HTTP status codes in a buffer."
(interactive)
(let ((status-codes
'((100 . "Continue")
(101 . "Switching Protocols")
(102 . "Processing")
(103 . "Early Hints")
(104 . "Unassigned")
(200 . "OK")
(201 . "Created")
(202 . "Accepted")
(203 . "Non-Authoritative Information")
(204 . "No Content")
(205 . "Reset Content")
(206 . "Partial Content")
(207 . "Multi-Status")
(208 . "Already Reported")
(209 . "Unassigned")
(226 . "IM Used")
(227 . "Unassigned")
(300 . "Multiple Choices")
(301 . "Moved Permanently")
(302 . "Found")
(303 . "See Other")
(304 . "Not Modified")
(305 . "Use Proxy")
(306 . "(Unused)")
(307 . "Temporary Redirect")
(308 . "Permanent Redirect")
(400 . "Bad Request")
(401 . "Unauthorized")
(402 . "Payment Required")
(403 . "Forbidden")
(404 . "Not Found")
(405 . "Method Not Allowed")
(406 . "Not Acceptable")
(407 . "Proxy Authentication Required")
(408 . "Request Timeout")
(409 . "Conflict")
(410 . "Gone")
(411 . "Length Required")
(412 . "Precondition Failed")
(413 . "Payload Too Large")
(414 . "URI Too Long")
(415 . "Unsupported Media Type")
(416 . "Range Not Satisfiable")
(417 . "Expectation Failed")
(421 . "Misdirected Request")
(422 . "Unprocessable Entity")
(423 . "Locked")
(424 . "Failed Dependency")
(425 . "Too Early")
(426 . "Upgrade Required")
(427 . "Unassigned")
(428 . "Precondition Required")
(429 . "Too Many Requests")
(430 . "Unassigned")
(431 . "Request Header Fields Too Large")
(451 . "Unavailable For Legal Reasons")
(500 . "Internal Server Error")
(501 . "Not Implemented")
(502 . "Bad Gateway")
(503 . "Service Unavailable")
(504 . "Gateway Timeout")
(505 . "HTTP Version Not Supported")
(506 . "Variant Also Negotiates")
(507 . "Insufficient Storage")
(508 . "Loop Detected")
(509 . "Unassigned")
(510 . "Not Extended")
(511 . "Network Authentication Required"))))
(switch-to-buffer "*HTTP Status Code Table*")
(buffer-disable-undo (current-buffer))
(let (buffer-read-only)
(erase-buffer)
(mapc (lambda (c) (insert (format "%5d %s\n" (car c) (cdr c))))
status-codes))
(setq buffer-read-only t)
(goto-char (point-min))))
(init-message 3 "Functions: Emacs Functions: powers-of-two-table")
(defun powers-of-two-table ()
"Print a table of the first 64 Powers of two in a buffer."
(interactive)
(switch-to-buffer "*Powers of Two Table*")
(buffer-disable-undo (current-buffer))
(let (buffer-read-only)
(erase-buffer)
(insert "POWER DECIMAL HEX\n")
(insert "----- -------------------- -----------------\n")
(dotimes (x 65)
(if (<= x 60)
(let ((pow (expt 2 x)))
(insert (format "%5d %20d %17X\n" x pow pow)))
(let ((dec (progn (calc-radix 10)
(calc-eval (format "2^%d" x))))
(hex (progn (calc-radix 16)
(substring (calc-eval (format "2^%d" x)) 3))))
(insert (format "%5d %20s %17s\n" x dec hex))))))
(setq buffer-read-only t)
(goto-char (point-min)))
(init-message 3 "Functions: Emacs Functions: memory-use-counts-pretty")
(defun memory-use-counts-pretty ()
"Pretty print version of `memory-use-counts'."
(interactive)
(let ((tags '(Conses Floats Vector-Cells Symbols String-Chars Miscs Intervals Strings))
(muc (memory-use-counts))
(str ""))
(dotimes (n (length tags))
(setq str (concat str (if (zerop (length str)) "" ", ")
(symbol-name (nth n tags)) ": " (number-to-string (nth n muc)))))
str))
(init-message 3 "Functions: Emacs Functions: git-paste-cleanup")
(defun git-paste-cleanup (beg end)
"Remove `+' characters from the start of lines in region."
(interactive "*r")
(save-mark-and-excursion
(goto-char beg)
(when (> (point) (line-beginning-position))
(forward-line 1)
(goto-char (line-beginning-position)))
(while (< (point) end)
(when (looking-at "^+")
(delete-char 1))
(forward-line 1))))
(init-message 3 "Functions: Emacs Functions: execute-buffer")
(defun execute-buffer ()
"Execute or compile current file."
(interactive)
(let* ((file-name (shell-quote-argument buffer-file-name))
(file-type (substring (shell-command-to-string (concat "file " file-name)) 0 -1))
(type-map '(("Lisp" . "clisp")
("bash" . "bash")
("perl" . "perl")
("python" . "python")
("java" . "javac")
("kotlin" . "kotlinc")
("php" . "php")
(" c " . "gcc")))
cmd)
(delete-other-windows)
(cl-do ((type type-map (cdr type)))
((or (not type) cmd))
(when (cl-search (car type) file-type)
(setq cmd (cdr type))))
(shell-command (concat cmd " " file-name))))
(init-message 3 "Functions: Emacs Functions: file-in-exec-path")
(defun file-in-exec-path (name)
"Return non-nil if NAME is a file found in `exec-path'."
(catch 'done
(dolist (dir exec-path)
(when (file-exists-p (concat (file-name-as-directory dir) name))
(throw 'done t)))
nil))
(init-message 3 "Functions: Emacs Functions: unicode-shell")
(defun unicode-shell ()
"Execute the shell buffer in UTF-8 encoding.
Note that you need to set the environment variable LANG and
others appropriately."
(interactive)
(let ((coding-system-for-read 'utf-8)
(coding-system-for-write 'utf-8)
(coding-system-require-warning t))
(call-interactively 'shell)))
(init-message 3 "Functions: Emacs Functions: async-spinner")
(defmacro async-spinner (start-func &optional finish-func)
"Return `async-start' command for given params with a spinner."
(require 'async)
(require 'spinner)
(let ((spinner (spinner-start 'horizontal-moving))
(result (gensym)))
`(async-start
(lambda ()
(funcall ,start-func))
(lambda (,result)
(funcall ,spinner)
(funcall ,finish-func ,result)))))
(init-message 3 "Functions: Emacs Functions: with-time")
(defmacro with-time (&rest body)
"Return the time it takes (in seconds) to evaluate BODY."
(declare (indent 0))
`(let ((time (current-time)))
,@body
(float-time (time-since time))))
(init-message 3 "Functions: Emacs Functions: package-desc-summary-to-kill-ring")
(defun package-desc-summary-to-kill-ring ()
"When `thing-at-point' is a package library, return package
description summary and put it on the kill ring."
(interactive)
(let* ((name (thing-at-point 'symbol t))
(summary (package-desc-summary
(with-temp-buffer
(insert-file-contents-literally
(find-library-name name))
(package-buffer-info)))))
(kill-new summary)
(message "%s: %s" name summary)))
(init-message 3 "Functions: Emacs Functions: toggle-case-fold-search")
(defun toggle-case-fold-search ()
"Toggle search case sensitivity."
(interactive)
(setq case-fold-search (not case-fold-search))
(message "case-fold-search: %s" (if case-fold-search "ON" "OFF")))
(init-message 2 "Functions: derived-modes")
(defun derived-modes (&optional mode)
"Return a list of the ancestor modes that MODE is derived from.
MODE defaults to `major-mode'."
(let* ((mode (or mode major-mode))
(mode-list (list mode)))
(while (setq mode (get mode 'derived-mode-parent))
(push mode mode-list))
(nreverse mode-list)))
(init-message 2 "Functions: Emacs Grouped Functions")
(init-message 3 "Functions: Emacs Grouped Functions: Buffer Kill")
(init-message 4 "Functions: Emacs Grouped Functions: Buffer Kill: kill-buffer-query-functions-maybe-bury")
(defconst bury-buffer-names '("*Messages*"))
(defun kill-buffer-query-functions-maybe-bury ()
"Bury certain buffers instead of killing them.
Return nil if buffer should be buried instead of killed.
Used as a `kill-buffer-query-functions' hook."
(if (member (buffer-name (current-buffer)) bury-buffer-names)
(progn
(kill-region (point-min) (point-max))
(bury-buffer)
nil)
t))
(add-hook 'kill-buffer-query-functions #'kill-buffer-query-functions-maybe-bury)
(init-message 4 "Functions: Emacs Grouped Functions: Buffer Kill: kill-other-window-buffer")
(defun kill-other-window-buffer (&optional delete-window)
"Kill buffer in other window, prompting user to select a window
if there are more than two.
When DELETE-WINDOW is non-nil, also delete the window."
(interactive)
(let ((orig-window (selected-window)))
(cond
((and (fboundp 'switch-window)
(> (length (window-list)) 1))
(switch-window)
(kill-buffer (current-buffer))
(when delete-window
(delete-window))
(select-window orig-window))
((= (length (window-list)) 2)
(other-window 1)
(kill-buffer (current-buffer))
(when delete-window
(delete-window))
(select-window orig-window))
(t
(message "No other window to kill")))))
(init-message 4 "Functions: Emacs Grouped Functions: Buffer Kill: kill-other-window-buffer-and-delete-window")
(defun kill-other-window-buffer-and-delete-window ()
"Kill buffer in other window, prompting user to select a window
if there are more than two. Then delete that window."
(interactive)
(kill-other-window-buffer t))
(init-message 3 "Functions: Emacs Grouped Functions: Clipboard")
(when (and (not window-system)
(executable-find "xsel"))
(init-message 4 "xclipboard-kill-region")
(defun xclipboard-kill-region (beg end)
"Kill the region, and save it in the X clipboard."
(interactive "*r")
(async-shell-command
(concat "echo "
(shell-quote-argument (buffer-substring-no-properties beg end))
" | xsel -i"))
(kill-region beg end))
(init-message 4 "xclipboard-kill-ring-save")
(defun xclipboard-kill-ring-save (beg end)
"Copy region to kill ring, and save in the X clipboard."
(interactive "r")
(async-shell-command
(concat "echo "
(shell-quote-argument (buffer-substring-no-properties beg end))
" | xsel -i"))
(kill-ring-save beg end))
(init-message 4 "xclipboard-yank")
(defun xclipboard-yank ()
"Insert the clipboard contents, or the last stretch of killed text."
(interactive "*")
(insert (shell-command-to-string "xsel -o"))))
(init-message 3 "Functions: Emacs Grouped Functions: Occur")
(init-message 4 "Functions: Emacs Grouped Functions: Occur: occur-inverse")
(defun occur-inverse (regexp)
"Show all lines in the current buffer not containing a match for REGEXP.
If a non-match spreads across multiple lines, all those lines are shown.
Otherwise, behaves the same as `occur'."
(interactive "sRegexp: ")
(let ((filtered
(mapconcat
(lambda (line)
(if (string-match-p regexp line)
""
line))
(split-string
(buffer-substring-no-properties (point-min) (point-max)) "\n")
"\n")))
(with-temp-buffer
(insert filtered)
(occur ".+"))))
(init-message 4 "Functions: Emacs Grouped Functions: Occur: occur-remove")
(defun occur-remove (regexp)
"Remove all lines in the *Occur* buffer containing a match for REGEXP."
(interactive "sRegexp: ")
(unless (string= (buffer-name) "*Occur*")
(error "This function can only be run within an *Occur* buffer."))
(let ((inhibit-read-only t))
(save-mark-and-excursion
(goto-char (point-min))
(while (not (eobp))
(goto-char (line-beginning-position))
(if (re-search-forward regexp (line-end-position) :noerror)
(delete-line)
(forward-line 1))))))
(init-message 2 "Functions: Text Conversion Functions")
(init-message 3 "Functions: Text Conversion Functions: set-coding-system")
(defun set-coding-system (coding-system)
"Change buffer file coding system to CODING-SYSTEM.
CODING-SYSTEM could be:
'unix
'dos
'mac
Or any coding system returned by `list-coding-systems'."
(interactive)
(set-buffer-file-coding-system coding-system :force))
(init-message 3 "Functions: Text Conversion Functions: escape-xml")
(defun escape-xml (string)
"Escape XML in STRING."
(setq string (replace-regexp-in-string "&" "&" string))
(setq string (replace-regexp-in-string "'" "'" string))
(setq string (replace-regexp-in-string ">" ">" string))
(setq string (replace-regexp-in-string "<" "<" string))
(setq string (replace-regexp-in-string "\"" """ string))
string)
(init-message 3 "Functions: Text Conversion Functions: unescape-xml")
(defun unescape-xml (string)
"Unescape XML in STRING."
(setq string (replace-regexp-in-string "'" "'" string))
(setq string (replace-regexp-in-string ">" ">" string))
(setq string (replace-regexp-in-string "<" "<" string))
(setq string (replace-regexp-in-string """ "\"" string))
(setq string (replace-regexp-in-string "&" "&" string))
string)
(init-message 3 "Functions: Text Conversion Functions: titleize")
(defun titleize (string &optional do-not-cap-ends)
"Capitalize STRING according to titling conventions.
If a word should be capitalized, `capitalize-word' is called,
otherwise `downcase-word' is called.
If DO-NOT-CAP-ENDS is non-nil, the first and last words will not
be automatically capitalized."
(interactive "*")
(let ((case-fold-search nil) (words-single
'( "and" "as" "be" "into" "is" "it" "nor" "or" "so" "the" "that" "yet"
"a" "abaft" "aboard" "about" "above" "absent" "across" "afore"
"after" "against" "along" "alongside" "amid" "amidst" "among"
"amongst" "an" "anenst" "apropos" "apud" "around" "as" "aside"
"astride" "at" "athwart" "atop" "barring" "before" "behind" "below"
"beneath" "beside" "besides" "between" "beyond" "but" "by" "circa"
"concerning" "despite" "down" "during" "except" "excluding"
"failing" "following" "for" "forenenst" "from" "given" "in"
"including" "inside" "into" "like" "mid" "midst" "minus" "modulo"
"near" "next" "notwithstanding" "o'" "of" "off" "on" "onto"
"opposite" "out" "outside" "over" "pace" "past" "per" "plus" "pro"
"qua" "regarding" "round" "sans" "save" "since" "than" "through"
"thru" "throughout" "thruout" "till" "times" "to" "toward" "towards"
"under" "underneath" "unlike" "until" "unto" "up" "upon" "versus"
"vs" "via" "vice" "vis-à-vis" "vis-a-vis" "whereas" "with" "within"
"without" "worth"))
(words-double
'( "according to" "ahead of" "apart from" "as for" "as of" "as per"
"as regards" "aside from" "back to" "because of" "close to"
"due to" "except for" "far from" "in to" "inside of" "instead of"
"left of" "near to" "next to" "on to" "out from" "out of"
"outside of" "owing to" "prior to" "pursuant to" "rather than"
"regardless of" "right of" "subsequent to" "such as" "thanks to"
"that of" "up to"))
(words-triple
'( "as far as" "as long as" "as opposed to" "as well as" "as soon as"
"at the behest of" "by means of" "by virtue of" "for the sake of"
"in accordance with" "in addition to" "in case of" "in front of"
"in lieu of" "in order to" "in place of" "in point of"
"in spite of" "on account of" "on behalf of" "on top of"
"with regard to" "with respect to" "with a view to")))
(let ((words-single-regexp (regexp-opt (mapcar #'capitalize words-single) 'words))
(words-double-regexp (regexp-opt (mapcar #'capitalize words-double) 'words))
(words-triple-regexp (regexp-opt (mapcar #'capitalize words-triple) 'words))
(abbreviation-word-regexp "\\b[A-Z][.A-Z]+[^ \t]*\\b")
(mixed-word-regexp "\\b[A-Z]*[a-z]+[A-Z]+[^ \t]*\\b")
(first-word-regexp "\\(^[ \t]*\\(\\w+\\)\\|[\.!:&\*()/][ \t]*\\(\\w+\\)\\)")
(last-word-regexp "\\(\\(\\w+\\)[ \t]*$\\|\\(\\w+\\)[ \t]*[\.!:&\*()\[]\\)"))
(cl-labels
((get-fixed (string regexp)
(let ((case-fold-search nil)
(pos 0)
fixed)
(while (string-match regexp string pos)
(push (list (match-beginning 0)
(match-end 0)
(match-string 0 string))
fixed)
(setq pos (match-end 0)))
(nreverse fixed)))
(set-fixed (string fixed)
(let ((string string))
(dolist (a fixed)
(setq string
(concat (substring string 0 (car a))
(caddr a)
(substring string (cadr a)))))
string))
(cap (string)
(replace-regexp-in-string
words-single-regexp 'downcase
(replace-regexp-in-string
words-double-regexp 'downcase
(replace-regexp-in-string
words-triple-regexp 'downcase
(capitalize string) t t) t t) t t)))
(let ((fixed (append (get-fixed string abbreviation-word-regexp)
(get-fixed string mixed-word-regexp))))
(if do-not-cap-ends
(set-fixed (cap string) fixed)
(set-fixed
(replace-regexp-in-string
first-word-regexp 'capitalize
(replace-regexp-in-string
last-word-regexp 'capitalize
(cap string) t t) t t) fixed)))))))
(init-message 3 "Functions: Text Conversion Functions: titleize-word-enhanced")
(defun titleize-word-enhanced (arg)
"Titleize word at point."
(interactive "*p")
(let ((syntax-table (copy-syntax-table (syntax-table))))
(modify-syntax-entry ?- "." syntax-table)
(modify-syntax-entry ?_ "." syntax-table)
(modify-syntax-entry ?' "w" syntax-table)
(with-syntax-table syntax-table
(dotimes (x (or arg 1))
(let ((p (point)))
(forward-word 1)
(forward-word -1)
(when (< (point) p)
(forward-word 1)))
(let ((bounds (bounds-of-thing-at-point 'word)))
(when bounds
(goto-char (car bounds)))
(when (re-search-forward "\\(\\w+\\)" nil :noerror)
(replace-match (titleize (match-string 0) t) t)))))))
(init-message 3 "Functions: Text Conversion Functions: titleize-line-or-region")
(defun titleize-line-or-region (&optional beg end)
"Capitalize the current line or selected region according to
titling conventions.
If a word should be capitalized, `capitalize-word' is called,
otherwise `downcase-word' is called."
(interactive "*")
(let* ((pos (point))
(beg (or beg (cond
((use-region-p)
(region-beginning))
((eq major-mode 'wdired-mode)
(point))
(t
(beginning-of-line-text) (point)))))
(end (or end (cond
((use-region-p)
(region-end))
((eq major-mode 'wdired-mode)
(if (re-search-forward "\.[^.]+$" (line-end-position) :noerror)
(match-beginning 0)
(line-end-position)))
(t
(line-end-position)))))
(col (- pos beg)))
(let ((syntax-table (copy-syntax-table (syntax-table)))
(str (buffer-substring-no-properties beg end)))
(modify-syntax-entry ?- "." syntax-table)
(modify-syntax-entry ?_ "." syntax-table)
(modify-syntax-entry ?' "w" syntax-table)
(with-syntax-table syntax-table
(kill-region beg end)
(goto-char beg)
(insert (titleize str))
(goto-char (+ beg col))))))
(init-message 3 "Functions: Text Conversion Functions: unfill-paragraph")
(defun unfill-paragraph ()
"Convert a multi-line paragraph into a single line of text."
(interactive)
(let ((fill-column (point-max)))
(fill-paragraph nil)))
(init-message 3 "Functions: Text Conversion Functions: single-space-punctuation")
(defun single-space-punctuation (&optional beg end)
"Single-space sentence ending punctuation in the current
paragraph or selected region."
(interactive "*")
(save-mark-and-excursion
(save-match-data
(let ((beg (or beg (and (use-region-p) (region-beginning))))
(end (or end (and (use-region-p) (region-end)))))
(unless (and beg end)
(mark-paragraph)
(setq beg (point)
end (mark-marker)))
(goto-char beg)
(while (and (< (point) end)
(re-search-forward "\\([^[:blank:]][.?!]['\"”)]?\\)[[:blank:]]\\([^[:blank:]]\\)" end :noerror))
(replace-match "\\1 \\2"))))))
(init-message 3 "Functions: Text Conversion Functions: double-space-punctuation")
(defun double-space-punctuation (&optional beg end)
"Double-space sentence ending punctuation in the current
paragraph or selected region."
(interactive "*")
(save-mark-and-excursion
(save-match-data
(let ((beg (or beg (and (use-region-p) (region-beginning))))
(end (or end (and (use-region-p) (region-end)))))
(unless (and beg end)
(mark-paragraph)
(setq beg (point)
end (mark-marker)))
(goto-char beg)
(while (and (< (point) end)
(re-search-forward "\\([^[:blank:]][.?!]['\"”)]?\\)[[:blank:]]\\([^[:blank:]]\\)" end :noerror))
(replace-match "\\1 \\2"))))))
(init-message 2 "Functions: Text Inserting Functions")
(init-message 3 "Functions: Text Inserting Functions: insert-timestamp")
(defun insert-timestamp (&optional pos)
"Insert a timestamp at point or POS."
(interactive "*")
(if pos
(save-mark-and-excursion
(goto-char pos)
(insert (format-time-string "%Y-%m-%d %H:%M:%S")))
(insert (format-time-string "%Y-%m-%d %H:%M:%S"))))
(init-message 3 "Functions: Text Inserting Functions: insert-path")
(defun insert-path (path)
"Insert path."
(interactive "*FPath: ")
(insert (expand-file-name path)))
(init-message 3 "Functions: Text Inserting Functions: uuid")
(defmacro uuid ()
"Return a UUID.
Example: 5ac55464-24e6-419c-99cf-5e1682bb3819"
(cond
((executable-find "uuid")
`(replace-regexp-in-string
"^ +\\|[ \n]+$" ""
(shell-command-to-string "uuid")))
((executable-find "uuidgen")
`(replace-regexp-in-string
"^ +\\|[ \n]+$" ""
(shell-command-to-string "uuidgen")))
((executable-find "mcookie")
`(let ((uuid (replace-regexp-in-string
"^ +\\|[ \n]+$" ""
(shell-command-to-string "mcookie"))))
(concat (substring uuid 0 8)
"-" (substring uuid 8 12)
"-" (substring uuid 12 16)
"-" (substring uuid 16 20)
"-" (substring uuid 20 32))))
(t
`(error "Could not find a suitable system command to produce a UUID"))))
(defalias 'guid 'uuid)
(init-message 3 "Functions: Text Inserting Functions: insert-uuid")
(defun insert-uuid ()
"Insert a UUID at point.
Example: 5ac55464-24e6-419c-99cf-5e1682bb3819"
(interactive "*")
(insert (uuid)))
(defalias 'insert-guid 'insert-uuid)
(init-message 3 "Functions: Text Inserting Functions: uuid-decimal")
(defun uuid-decimal ()
"Return a UUID as a 128-bit decimal number.
Example: 206479166935211742515584900341856848185"
(string-to-number (replace-regexp-in-string "-" "" (uuid)) 16))
(defalias 'guid-decimal 'uuid-decimal)
(init-message 3 "Functions: Text Inserting Functions: uuid-string")
(defun uuid-string ()
"Return a UUID as a 21 character ASCII string.
Example: 23MNvqBpz7dP53kZVeGmvR"
(cl-labels
( (n-to-s (num)
(cond
((< num 10)
(byte-to-string (+ num 48))) ((< num 36)
(byte-to-string (+ num 55))) ((< num 62)
(byte-to-string (+ num 61))) ((< num 63)
(byte-to-string 43)) ((< num 64)
(byte-to-string 45))))) (cl-do* ((n 0 (mod u 64))
(s "" (concat (n-to-s n) s))
(u (uuid-decimal) (/ u 64)))
((= u 0) s))))
(defalias 'guid-decimal 'uuid-string)
(init-message 3 "Functions: Text Inserting Functions: uuid-xml")
(defmacro uuid-xml ()
"Return a Java UUID serialized for XML.
Example:
<java.util.UUID>
<default>
<leastSigBits>-8689645201391190588</leastSigBits>
<mostSigBits>-4837091181110474279</mostSigBits>
</default>
</java.util.UUID>"
(let ((cmd "uuid-xml"))
(if (executable-find cmd)
`(shell-command-to-string (concat ,cmd " | tail -n +2"))
`(error "Could not find %s command" ,cmd))))
(init-message 3 "Functions: Text Inserting Functions: insert-uuid-xml")
(defun insert-uuid-xml ()
"Insert a Java UUID serialized for XML at point.
Example:
<java.util.UUID>
<default>
<leastSigBits>-8689645201391190588</leastSigBits>
<mostSigBits>-4837091181110474279</mostSigBits>
</default>
</java.util.UUID>"
(interactive "*")
(insert (uuid-xml)))
(init-message 3 "Functions: Text Inserting Functions: insert-incrementing-vertical-numbers")
(defun insert-incrementing-vertical-numbers (bound1 &optional bound2 repeat)
"Insert incrementing numbers vertically in the current column.
If BOUND2 is nil, number from 1 to BOUND1, inclusive.
If BOUND2 is non-nil, number from BOUND1 to BOUND2, inclusive.
If REPEAT is non-nil, repeat each number that many times."
(interactive "*nMaximum number: ")
(let ((start (if bound2 bound1 1))
(end (if bound2 bound2 bound1))
(repeat (or repeat 1))
(col (- (point) (line-beginning-position))))
(cl-do ((x start (1+ x)))
((> x end))
(cl-do ((y 1 (1+ y)))
((> y repeat))
(insert (number-to-string x))
(when (or (< x end) (< y repeat))
(or (zerop (forward-line 1))
(progn
(goto-char (line-end-position))
(newline)))
(let ((pos (+ (line-beginning-position) col)))
(while (< (point) pos)
(if (eobp)
(insert " ")
(forward-char 1)))))))))
(init-message 3 "Functions: Text Inserting Functions: insert-column-position-ruler")
(defun insert-column-position-ruler (&optional tens)
"Insert a column poisition ruler.
If TENS is non-nil, insert that many ruler segments of ten digits.
TENS defaults to 12."
(interactive "*")
(let ((tens (or tens 12)))
(dotimes (x tens)
(insert "1234567890"))))
(init-message 3 "Functions: Text Inserting Functions: append-char-to-column")
(defun append-char-to-column (char col)
"Append character CHAR up to column COL and delete any past that point."
(save-mark-and-excursion
(goto-char (line-end-position))
(while (< (- (point) (line-beginning-position)) col)
(insert char))
(goto-char (+ (line-beginning-position) col))
(while (and
(char-after)
(char-equal (char-after) (string-to-char char)))
(delete-char 1))))
(init-message 3 "Functions: Text Inserting Functions: append-equal-to-column-80")
(defun append-equal-to-column-80 ()
"Insert equal characters up to column 80."
(interactive "*")
(append-char-to-column "=" 80))
(init-message 3 "Functions: Text Inserting Functions: append-dash-to-column-80")
(defun append-dash-to-column-80 ()
"Insert dash characters up to column 80."
(interactive "*")
(append-char-to-column "-" 80))
(init-message 3 "Functions: Text Inserting Functions: append-asterisk-to-column-80")
(defun append-asterisk-to-column-80 ()
"Insert asterisk characters up to column 80."
(interactive "*")
(append-char-to-column "*" 80))
(init-message 3 "Functions: Text Inserting Functions: insert-lisp-comment-block-equal")
(defun insert-lisp-comment-block-equal ()
"Insert lisp comment block (equal)."
(interactive "*")
(indent-according-to-mode)
(insert ";;")
(append-equal-to-column-80)
(end-of-line)
(newline-and-indent)
(insert ";;")
(newline-and-indent)
(insert ";;")
(append-equal-to-column-80)
(end-of-line)
(newline)
(forward-line -2)
(end-of-line)
(insert " "))
(init-message 3 "Functions: Text Inserting Functions: insert-lisp-comment-block-dash")
(defun insert-lisp-comment-block-dash ()
"Insert lisp comment block (dash)."
(interactive "*")
(indent-according-to-mode)
(insert ";;")
(append-dash-to-column-80)
(end-of-line)
(newline-and-indent)
(insert ";;")
(newline-and-indent)
(insert ";;")
(append-dash-to-column-80)
(end-of-line)
(newline)
(forward-line -2)
(end-of-line)
(insert " "))
(init-message 3 "Functions: Text Inserting Functions: insert-center-lisp-comment")
(defun insert-center-lisp-comment ()
"Insert center lisp comment (in comment block)."
(interactive "*")
(save-mark-and-excursion
(save-match-data
(goto-char (line-beginning-position))
(while (looking-at " +") (forward-char 1))
(while (looking-at ";+") (forward-char 1))
(let ((start (point)))
(forward-line -1)
(let ((len (- (line-end-position) (line-beginning-position)))
(spacer (char-before (line-end-position))))
(forward-line 1)
(while (search-forward (char-to-string spacer) (line-end-position) :noerror)
(replace-match ""))
(goto-char start)
(while (looking-at " ")
(delete-char 1 t))
(goto-char (line-end-position))
(while (eq (char-before (point)) ? )
(delete-char -1 t))
(let ((spacers (- (floor (/ (- len (- (point) start)) 2)) 4)))
(goto-char start)
(insert " " (make-string spacers spacer) " ")
(goto-char (line-end-position))
(insert " ")
(insert (make-string (- len (- (point) (line-beginning-position))) ?=))))))))
(init-message 3 "Functions: Text Inserting Functions: insert-c-comment-block")
(defun insert-c-comment-block ()
"Insert c/c++/java comment block."
(interactive "*")
(indent-according-to-mode)
(insert "/")
(append-asterisk-to-column-80)
(end-of-line)
(newline-and-indent)
(insert "*")
(indent-according-to-mode)
(newline-and-indent)
(insert "*")
(indent-according-to-mode)
(append-asterisk-to-column-80)
(end-of-line)
(delete-char -1)
(insert "/")
(newline)
(forward-line -2)
(end-of-line)
(insert " "))
(init-message 3 "Functions: Text Inserting Functions: insert-c-comment-stub")
(defun insert-c-comment-stub ()
"Insert c/c++/java comment stub."
(interactive "*")
(end-of-line)
(indent-according-to-mode)
(insert "/**")
(newline-and-indent)
(insert "*")
(indent-according-to-mode)
(newline-and-indent)
(insert "*/")
(indent-according-to-mode)
(newline)
(forward-line -2)
(end-of-line)
(insert " "))
(init-message 3 "Functions: Text Inserting Functions: insert-db-change-log-template-line")
(defun insert-db-change-log-template-line ()
"Insert Everest DB Change Log template line at point."
(interactive "*")
(insert (format-time-string "%m/%d" (current-time)))
(insert " | | | E_ | .D.Q.S.T.P. | yes")
(newline)
(forward-line -1)
(forward-char 8))
(init-message 3 "Functions: Text Inserting Functions: insert-db-change-log-template-line-legacy")
(defun insert-db-change-log-template-line-legacy ()
"Insert Legacy DB Change Log template line at point."
(interactive "*")
(insert (format-time-string "%m/%d" (current-time)))
(insert " | | | AwardCafe_Client | .D.S.P. | yes")
(newline)
(forward-line -1)
(forward-char 8))
(init-message 3 "Functions: Text Inserting Functions: insert-xml-header")
(defun insert-xml-header ()
"Insert standard XML header.
Specifically: <?xml version=\"1.0\" encoding=\"utf-8\"?>"
(interactive "*")
(insert "<?xml version=\"1.0\" encoding=\"utf-8\"?>"))
(init-message 3 "Functions: Text Inserting Functions: insert-lexical-binding")
(defun insert-lexical-binding ()
"Insert file local variable `lexical-binding' in the first line
of the current buffer."
(interactive "*")
(save-mark-and-excursion
(goto-char (point-min))
(if (looking-at ";; -\\*-.*-\\*-")
(unless (looking-at ";; -\\*-.*lexical-binding:.*-\\*-")
(goto-char (line-end-position))
(forward-char -4)
(when (looking-at " -\\*-")
(forward-char -1)
(if (looking-at ";")
(forward-char 1)
(progn
(forward-char 1)
(insert ";")))
(insert " lexical-binding: t;")))
(insert ";; -*- lexical-binding: t; -*-\n;;\n"))))
(init-message 3 "Functions: Text Inserting Functions: insert-toc-header")
(defun insert-toc-header ()
"Insert `org-mode' table of contents (TOC) header."
(interactive "*")
(let ((text
`("* Table of Contents"
" :PROPERTIES:"
" :CUSTOM_ID: table-of-contents"
" :TOC: :include all"
" :END:"
""
" :CONTENTS:"
" :END:"
"")))
(dolist (x text)
(insert x)
(newline))))
(init-message 3 "Functions: Text Inserting Functions: insert-figlet")
(defun insert-figlet (text)
"Insert figlet version of TEXT, if figlet is installed."
(interactive "*sText: ")
(if (executable-find "figlet")
(insert (shell-command-to-string (concat "figlet " text)))
(error "Could not find figlet command")))
(init-message 3 "Functions: Text Inserting Functions: insert-password")
(defun insert-password (length)
"Insert generated password of LENGTH characters."
(interactive "*nLength: ")
(cl-labels
((string-to-list (string) (cl-loop for x across string collect x))
(list-to-string (list) (mapconcat 'string list "")))
(let* ((upper (string-to-list "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
(lower (string-to-list "abcdefghijklmnopqrstuvwxyz"))
(numbers (string-to-list "0123456789")) (symbols (string-to-list "!@#$%^&*"))
(letters (append upper lower numbers symbols))
(letters-size (length letters))
(bookends (append upper lower numbers))
(bookends-size (length bookends))
(min-numbers 1)
(min-symbols 1)
(number-count 0)
(symbol-count 0)
password
valid)
(when (< length 6)
(error "Password LENGTH must be at least 6."))
(while (or (< (length password) length)
(not valid))
(when (= (length password) length)
(setq password nil))
(let ((char (if (and (> (length password) 0)
(< (length password) (1- length)))
(elt letters (random letters-size))
(elt bookends (random bookends-size)))))
(push char password)
(when (member char numbers)
(incf number-count))
(when (member char symbols)
(incf symbol-count))
(when (and (> number-count 0)
(> symbol-count 0))
(setq valid t))))
(insert (list-to-string password)))))
(defun insert-password-14 ()
"Call `insert-password' with a LENGTH of 14"
(interactive "*")
(insert-password 14))
(init-message 3 "Functions: Text Inserting Functions: insert-password-phrase")
(defun insert-password-phrase (count &optional output)
"Insert generated password phrase containing COUNT words.
OUTPUT (defaults to 'phrase):
'phrase \"threewordphrase\"
'space \"three word phrase\"
'hyphen \"three-word-phrase\"
'list (\"three\" \"word\" \"phrase\")"
(interactive "*nCount: ")
(let* ((words
'("abandon" "ability" "able" "about" "above" "absent" "absorb" "abstract" "absurd"
"abuse" "access" "accident" "account" "accuse" "achieve" "acid" "acoustic"
"acquire" "across" "act" "action" "actor" "actress" "actual" "adapt" "add" "addict"
"address" "adjust" "admit" "adult" "advance" "advice" "aerobic" "affair" "afford"
"afraid" "again" "age" "agent" "agree" "ahead" "aim" "air" "airport" "aisle" "alarm"
"album" "alcohol" "alert" "alien" "all" "alley" "allow" "almost" "alone" "alpha"
"already" "also" "alter" "always" "amateur" "amazing" "among" "amount" "amused"
"analyst" "anchor" "ancient" "anger" "angle" "angry" "animal" "ankle" "announce"
"annual" "another" "answer" "antenna" "antique" "anxiety" "any" "apart" "apology"
"appear" "apple" "approve" "april" "arch" "arctic" "area" "arena" "argue" "arm" "armed"
"armor" "army" "around" "arrange" "arrest" "arrive" "arrow" "art" "artefact" "artist"
"artwork" "ask" "aspect" "assault" "asset" "assist" "assume" "asthma" "athlete"
"atom" "attack" "attend" "attitude" "attract" "auction" "audit" "august" "aunt"
"author" "auto" "autumn" "average" "avocado" "avoid" "awake" "aware" "away" "awesome"
"awful" "awkward" "axis" "baby" "bachelor" "bacon" "badge" "bag" "balance" "balcony"
"ball" "bamboo" "banana" "banner" "bar" "barely" "bargain" "barrel" "base" "basic"
"basket" "battle" "beach" "bean" "beauty" "because" "become" "beef" "before" "begin"
"behave" "behind" "believe" "below" "belt" "bench" "benefit" "best" "betray" "better"
"between" "beyond" "bicycle" "bid" "bike" "bind" "biology" "bird" "birth" "bitter"
"black" "blade" "blame" "blanket" "blast" "bleak" "bless" "blind" "blood" "blossom"
"blouse" "blue" "blur" "blush" "board" "boat" "body" "boil" "bomb" "bone" "bonus" "book"
"boost" "border" "boring" "borrow" "boss" "bottom" "bounce" "box" "boy" "bracket"
"brain" "brand" "brass" "brave" "bread" "breeze" "brick" "bridge" "brief" "bright"
"bring" "brisk" "broccoli" "broken" "bronze" "broom" "brother" "brown" "brush"
"bubble" "buddy" "budget" "buffalo" "build" "bulb" "bulk" "bullet" "bundle" "bunker"
"burden" "burger" "burst" "bus" "business" "busy" "butter" "buyer" "buzz" "cabbage"
"cabin" "cable" "cactus" "cage" "cake" "call" "calm" "camera" "camp" "can" "canal"
"cancel" "candy" "cannon" "canoe" "canvas" "canyon" "capable" "capital" "captain"
"car" "carbon" "card" "cargo" "carpet" "carry" "cart" "case" "cash" "casino" "castle"
"casual" "cat" "catalog" "catch" "category" "cattle" "caught" "cause" "caution"
"cave" "ceiling" "celery" "cement" "census" "century" "cereal" "certain" "chair"
"chalk" "champion" "change" "chaos" "chapter" "charge" "chase" "chat" "cheap" "check"
"cheese" "chef" "cherry" "chest" "chicken" "chief" "child" "chimney" "choice"
"choose" "chronic" "chuckle" "chunk" "churn" "cigar" "cinnamon" "circle" "citizen"
"city" "civil" "claim" "clap" "clarify" "claw" "clay" "clean" "clerk" "clever" "click"
"client" "cliff" "climb" "clinic"