7 files changed, 168 insertions, 1 deletions

@@ -75,5 +75,7 @@ Otherwise, it calls `capitalize-word' on the word at point (using
   (define-key +key-mode-map (kbd "M-c") (when +casing-mode
                                           +casing-mode-map)))
 
+(defvaralias '+casing-map '+casing-mode-map)
+
 (provide '+casing)
 ;;; +casing.el ends here
@@ -165,6 +165,7 @@ See `circe-network-options' for a list of common options."
                      (funcall +circe-server-buffer-action buffer))))
 
 ;;; Chat commands
+;; TODO: Actually ... write these~!?!?!
 
 (defun circe-command-SHORTEN (url)
   "Shorten URL using `0x0-shorten-uri'.")
@@ -172,6 +173,9 @@ See `circe-network-options' for a list of common options."
 (defun circe-command-SLAP (nick)
   "Slap NICK around a bit with a large trout.")
 
+(defun circe-command-POKE (nick)
+  "Poke NICK like in the old Facebook days.")
+
 ;;; Pure idiocy
 
 (define-minor-mode circe-cappy-hour-mode
@@ -220,6 +220,15 @@ kill without asking."
         (save-buffers-kill-emacs))
     (delete-frame nil :force)))
 
+(defun +kill-word-backward-or-region (&optional arg backward-kill-word-fn)
+  "Kill active region or ARG words backward.
+BACKWARD-KILL-WORD-FN is the function to call to kill a word
+backward.  It defaults to `backward-kill-word'."
+  (interactive "P")
+  (call-interactively (if (region-active-p)
+                          #'kill-region
+                        (or backward-kill-word-fn #'backward-kill-word))))
+
 ;; ... and advice
 
 ;; Indent the region after a yank.
@@ -0,0 +1,12 @@
+;;; +flyspell-correct.el ---                         -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(defun +flyspell-correct-buffer (&rest _)  ; Enables this to be run as a hook
+  "Run `flyspell-correct-wrapper' on all misspelled words in the buffer."
+  (interactive)
+  (+with-message "Checking spelling"
+    (flyspell-correct-move (point-min) :forward :rapid)))
+
+(provide '+flyspell-correct)
+;;; +flyspell-correct.el ends here
@@ -15,9 +15,12 @@
   :keymap (let ((map (make-sparse-keymap)))
              (define-key map "f" #'find-function)
              (define-key map "l" #'find-library)
+             (define-key map "v" #'find-variable)
              map)
   (define-key +key-mode-map (kbd "C-c l") (when +lookup-mode
                                             +lookup-mode-map)))
 
+(defvaralias '+lookup-map '+lookup-mode-map)
+
 (provide '+lookup)
 ;;; +lookup.el ends here
@@ -44,7 +44,6 @@ the filesystem, unless INHIBIT-MKDIR is non-nil."
            (make-directory (file-name-directory file-name) :parents))
          file-name))))
 
-
 (defun +suppress-messages (oldfn &rest args) ; from pkal
   "Advice wrapper for suppressing `message'.
 OLDFN is the wrapped function, that is passed the arguments
@@ -126,5 +125,65 @@ I keep forgetting how they differ."
   (declare (doc-string 3))
   `(setq ,var ,value))
 
+(defmacro +with-message (message &rest body)
+  "Execute BODY, with MESSAGE.
+If body executes without errors, MESSAGE...Done will be displayed."
+  ;; ^ TODO
+  `(prog1 (progn (message ,(concat message "..."))
+                 ,@body)
+          (message ,(concat message "...Done."))))
+
+(defun +mapc-some-buffers (func &optional predicate)
+  "Perform FUNC on all buffers satisfied by PREDICATE.
+By default, act on all buffers.
+
+PREDICATE is a function called with one argument, the current
+buffer.  FUNC is called with no arguments.  Both are called
+within a `with-current-buffer' form."
+  (let ((pred (or predicate t)))
+    (dolist (buf (buffer-list))
+      (with-current-buffer buf
+        (when (funcall pred buf)
+          (funcall func))))))
+
+;; https://github.com/cstby/emacs.d/blob/main/init.el#L67
+(defun +clean-empty-lines (&optional begin end)
+  "Remove duplicate empty lines from BEGIN to END.
+Called interactively, this function acts on the region, if
+active, or else the entire buffer."
+  (interactive "*r")
+  (unless (region-active-p)
+    (setq begin (point-min)
+          end (save-excursion
+                (goto-char (point-max))
+                (skip-chars-backward "\n[:space:]")
+                (point))))
+  (save-excursion
+    (save-restriction
+      (narrow-to-region begin end)
+      (goto-char (point-min))
+      (while (re-search-forward "\n\n\n+" nil :move)
+        (replace-match "\n\n"))
+      ;; Insert a newline at the end.
+      (goto-char (point-max))
+      (unless (= (line-beginning-position) (line-end-position))
+        (insert "\n")))))
+
+(defun +open-paragraph ()
+  "Open a paragraph after paragraph at point.
+A paragraph is defined as continguous non-empty lines of text
+surrounded by empty lines, so opening a paragraph means to make
+three blank lines, then place the point on the second one."
+  (interactive "*")
+  (unless (derived-mode-p 'special-mode 'lui-mode 'comint-mode)
+   ;; Go to next blank line.  This /isn't/ `end-of-paragraph-text' because
+   ;; that's weird with org, and I'm guessing other modes too.
+   (while (not (looking-at "^$"))
+     (forward-line 1))
+   (newline)
+   (delete-blank-lines)
+   (newline 2)
+   (previous-line)))
+
 (provide 'acdw)
 ;;; acdw.el ends here
@@ -0,0 +1,78 @@
+;;; user-save.el -*- lexical-binding: t; -*-
+
+;; Because `super-save-mode' automatically saves every time we move away from a
+;; buffer, it tends to run a lot of `before-save-hook's that don't need to be
+;; run that often.  For that reason, I'm writing a mode where C-x C-s saves
+;; /and/ runs all the "real" before-save-hooks, so that super-save won't
+;; automatically do things like format the buffer all the time.
+
+;;; Code:
+
+(defgroup user-save nil
+  "Group for `user-save-mode' customizations."
+  :group 'emacs
+  :prefix "user-save-")
+
+(defcustom user-save-hook-into-kill-emacs nil
+  "Add a hook to perform `user-save' to `kill-emacs-hook'.
+This option is only useful is `user-save-mode' is active when
+Emacs is killed."
+  :type 'boolean)
+
+(defvar user-save-hook nil
+  "Hook to run when the user, not Emacs, saves the buffer.")
+
+(defvar user-save-mode-map (let ((map (make-sparse-keymap)))
+                             (define-key map (kbd "C-x C-s") #'user-save-buffer)
+                             map)
+  "Keymap for `user-save-mode'.
+This map shadows the default map for `save-buffer'.")
+
+(defun user-save-buffer (&optional arg)
+  "Save current buffer in visited file if modified.
+This function is precisely the same as `save-buffer', but with
+one modification: it also runs functions in `user-save-hook'.
+This means that if you have some functionality in Emacs to
+automatically save buffers periodically, but have hooks you want
+to automatically run when the buffer saves that are
+computationally expensive or just aren't something you want to
+run all the time, put them in `user-save-hook'.
+
+ARG is passed directly to `save-buffer'."
+  (interactive '(called-interactively))
+  (message "Saving the buffer...")
+  (with-demoted-errors (run-hooks 'user-save-hook))
+  (save-buffer arg)
+  (message "Saving the buffer...Done."))
+
+(defun user-save-some-buffers (&optional pred)
+  "Save some buffers as though the user saved them.
+This function does not ask the user about each buffer, but PRED
+is used in almost the same way as `save-some-buffers': if it's
+nil or t, it will save all file-visiting modified buffers; if
+it's a zero-argument function, that will be called to determine
+whether the buffer needs to be saved."
+  ;; This could maybe be much better.
+  (interactive "P")
+  (unless pred (setq pred save-some-buffers-default-predicate))
+  (dolist (buf (buffer-list))
+    (with-current-buffer buf
+      (when (and (buffer-modified-p)
+                 (buffer-file-name)
+                 (or (null pred)
+                     (if (functionp pred) (funcall pred) pred)))
+        (user-save-buffer)))))
+
+;;;###autoload
+(define-minor-mode user-save-mode
+  "Mode to enable an an extra user-save hook."
+  :lighter " US"
+  :global t
+  :keymap 'user-save-mode-map
+  (if user-save-mode
+      (when user-save-hook-into-kill-emacs
+        (add-hook 'kill-emacs-hook #'user-save-some-buffers))
+    (remove-hook 'kill-emacs-hook #'user-save-some-buffers)))
+
+(provide 'user-save)
+;;; user-save.el ends here