(defun load-file-if-exists (filename)
(if (file-exists-p filename)
(load filename)))
(defun goto-line-with-feedback ()
"Show line numbers temporarily, while prompting for the line number input"
(interactive)
(unwind-protect
(progn
(setq-local display-line-numbers t)
(let ((target (read-number "Goto line: ")))
(avy-push-mark)
(goto-line target)))
(setq-local display-line-numbers nil)))
;; These come from the emacs starter kit
(defun esk-add-watchwords ()
(font-lock-add-keywords
nil '(("\\<\\(FIX\\(ME\\)?\\|TODO\\|DEBUG\\|HACK\\|REFACTOR\\|NOCOMMIT\\)"
1 font-lock-warning-face t))))
(defun esk-sudo-edit (&optional arg)
(interactive "p")
(if (or arg (not buffer-file-name))
(find-file (concat "/sudo:root@localhost:" (read-file-name "File: ")))
(find-alternate-file (concat "/sudo:root@localhost:" buffer-file-name))))
;; Open Fefes blog
(defun fefes-blog ()
(interactive)
(eww "https://blog.fefe.de/"))
;; Open the NixOS man page
(defun nixos-man ()
(interactive)
(man "configuration.nix"))
;; Open my monorepo in magit
(defun depot-status ()
(interactive)
(magit-status "~/depot"))
;; Get the nix store path for a given derivation.
;; If the derivation has not been built before, this will trigger a build.
(defun nix-store-path (derivation)
(let ((expr (concat "with import <nixos> {}; " derivation)))
(s-chomp (shell-command-to-string (concat "nix-build -E '" expr "'")))))
(defun insert-nix-store-path ()
(interactive)
(let ((derivation (read-string "Derivation name (in <nixos>): ")))
(insert (nix-store-path derivation))))
(defun toggle-force-newline ()
"Buffer-local toggle for enforcing final newline on save."
(interactive)
(setq-local require-final-newline (not require-final-newline))
(message "require-final-newline in buffer %s is now %s"
(buffer-name)
require-final-newline))
;; Helm includes a command to run external applications, which does
;; not seem to exist in ivy. This implementation uses some of the
;; logic from Helm to provide similar functionality using ivy.
(defun list-external-commands ()
"Creates a list of all external commands available on $PATH
while filtering NixOS wrappers."
(cl-loop
for dir in (split-string (getenv "PATH") path-separator)
when (and (file-exists-p dir) (file-accessible-directory-p dir))
for lsdir = (cl-loop for i in (directory-files dir t)
for bn = (file-name-nondirectory i)
when (and (not (s-contains? "-wrapped" i))
(not (member bn completions))
(not (file-directory-p i))
(file-executable-p i))
collect bn)
append lsdir into completions
finally return (sort completions 'string-lessp)))
(defvar external-command-flag-overrides
'(("google-chrome" . "--force-device-scale-factor=1.4"))
"This setting lets me add additional flags to specific commands
that are run interactively via `ivy-run-external-command'.")
(defun run-external-command (cmd)
"Execute the specified command and notify the user when it
finishes."
(let* ((extra-flags (cdr (assoc cmd external-command-flag-overrides)))
(cmd (if extra-flags (s-join " " (list cmd extra-flags)) cmd)))
(message "Starting %s..." cmd)
(set-process-sentinel
(start-process-shell-command cmd nil cmd)
(lambda (process event)
(when (string= event "finished\n")
(message "%s process finished." process))))))
(defun ivy-run-external-command ()
"Prompts the user with a list of all installed applications and
lets them select one to launch."
(interactive)
(let ((external-commands-list (list-external-commands)))
(ivy-read "Command:" external-commands-list
:require-match t
:history 'external-commands-history
:action #'run-external-command)))
(defun ivy-password-store (&optional password-store-dir)
"Custom version of password-store integration with ivy that
actually uses the GPG agent correctly."
(interactive)
(ivy-read "Copy password of entry: "
(password-store-list (or password-store-dir (password-store-dir)))
:require-match t
:keymap ivy-pass-map
:action (lambda (entry)
(let ((password (auth-source-pass-get 'secret entry)))
(password-store-clear)
(kill-new password)
(setq password-store-kill-ring-pointer kill-ring-yank-pointer)
(message "Copied %s to the kill ring. Will clear in %s seconds."
entry (password-store-timeout))
(setq password-store-timeout-timer
(run-at-time (password-store-timeout)
nil 'password-store-clear))))))
(defun ivy-browse-repositories ()
"Select a git repository and open its associated magit buffer."
(interactive)
(ivy-read "Repository: "
(magit-list-repos)
:require-match t
:sort t
:action #'magit-status))
(defun bottom-right-window-p ()
"Determines whether the last (i.e. bottom-right) window of the
active frame is showing the buffer in which this function is
executed."
(let* ((frame (selected-frame))
(right-windows (window-at-side-list frame 'right))
(bottom-windows (window-at-side-list frame 'bottom))
(last-window (car (seq-intersection right-windows bottom-windows))))
(eq (current-buffer) (window-buffer last-window))))
(defhydra mc/mark-more-hydra (:color pink)
("<up>" mmlte--up "Mark previous like this")
("<down>" mc/mmlte--down "Mark next like this")
("<left>" mc/mmlte--left (if (eq mc/mark-more-like-this-extended-direction 'up)
"Skip past the cursor furthest up"
"Remove the cursor furthest down"))
("<right>" mc/mmlte--right (if (eq mc/mark-more-like-this-extended-direction 'up)
"Remove the cursor furthest up"
"Skip past the cursor furthest down"))
("f" nil "Finish selecting"))
;; Mute the message that mc/mmlte wants to print on its own
(advice-add 'mc/mmlte--message :around (lambda (&rest args) (ignore)))
(defun mc/mark-dwim (arg)
"Select multiple things, but do what I mean."
(interactive "p")
(if (not (region-active-p)) (mc/mark-next-lines arg)
(if (< 1 (count-lines (region-beginning)
(region-end)))
(mc/edit-lines arg)
;; The following is almost identical to `mc/mark-more-like-this-extended',
;; but uses a hydra (`mc/mark-more-hydra') instead of a transient key map.
(mc/mmlte--down)
(mc/mark-more-hydra/body))))
(defun memespace-region ()
"Make a meme out of it."
(interactive)
(let* ((start (region-beginning))
(end (region-end))
(memed
(message
(s-trim-right
(apply #'string
(-flatten
(nreverse
(-reduce-from (lambda (acc x)
(cons (cons x (-repeat (+ 1 (length acc)) 32)) acc))
'()
(string-to-list (buffer-substring-no-properties start end))))))))))
(save-excursion (delete-region start end)
(goto-char start)
(insert memed))))
(defun insert-todo-comment (prefix todo)
"Insert a comment at point with something for me to do."
(interactive "P\nsWhat needs doing? ")
(save-excursion
(move-end-of-line nil)
(insert (format " %s TODO(%s): %s"
(s-trim-right comment-start)
(if prefix (read-string "Who needs to do this? ")
(getenv "USER"))
todo))))
;; Custom text scale adjustment functions that operate on the entire instance
(defun modify-text-scale (factor)
(set-face-attribute 'default nil
:height (+ (* factor 5) (face-attribute 'default :height))))
(defun increase-default-text-scale (prefix)
"Increase default text scale in all Emacs frames, or just the
current frame if PREFIX is set."
(interactive "P")
(if prefix (text-scale-increase 1)
(modify-text-scale 1)))
(defun decrease-default-text-scale (prefix)
"Increase default text scale in all Emacs frames, or just the
current frame if PREFIX is set."
(interactive "P")
(if prefix (text-scale-decrease 1)
(modify-text-scale -1)))
(defun set-default-text-scale (prefix &optional to)
"Set the default text scale to the specified value, or the
default. Restores current frame's text scale only, if PREFIX is
set."
(interactive "P")
(if prefix (text-scale-adjust 0)
(set-face-attribute 'default nil :height (or to 120))))
(defun notmuch-depot-apply-patch ()
"Apply the currently opened notmuch message as a patch on the
depot."
(interactive)
;; The implementation works by letting notmuch render a raw message
;; and capturing it by overriding the `view-buffer' function it
;; calls after rendering.
;;
;; The buffer is then passed to `git-am'.
(cl-letf (((symbol-function 'view-buffer)
(lambda (buffer &optional exit-action) buffer)))
(if-let ((raw-buffer (notmuch-show-view-raw-message)))
(progn
(with-current-buffer raw-buffer
(call-shell-region (point-min) (point-max) "git am -C ~/depot")
(message "Patch applied!")
(kill-buffer))
(magit-status "~/depot"))
(warn "notmuch failed to render the raw message buffer"))))
(defun scrot-select ()
"Take a screenshot based on a mouse-selection and save it to
~/screenshots."
(interactive)
(shell-command "scrot '$a_%s.png' -s -e 'mv $f ~/screenshots/'"))
(provide 'functions)
