11 files changed, 122 insertions, 89 deletions

@@ -120,9 +120,9 @@ ARGS are ignored here, but passed on for later processing."
   ;; along with the rest of the args, in a list to the original caller (probably
   ;; `browse-url'.)
   (apply 'list
-         (cl-loop with url =  (substring-no-properties
-                               (if (consp url) (car url) url))
-          for (regex . transformation) in +browse-url-transformations
+         (cl-loop with url = (substring-no-properties
+                              (if (consp url) (car url) url))
+                  for (regex . transformation) in +browse-url-transformations
                   if (string-match regex url)
                   return (replace-match transformation nil nil url)
                   ;; else
@@ -5,7 +5,7 @@
 (defun +consult-project-root ()
   "Return either the current project, or the VC root, of current file."
   (if (and (functionp 'project-current)
-       (project-current))
+           (project-current))
       (car (project-roots (project-current)))
     (vc-root-dir)))
 
@@ -2,18 +2,17 @@
 
 ;;; Code:
 
-(require 'vertico)
-
-(defun +dired-goto-file (file)
-  "ADVICE for `dired-goto-file' to make RET call `vertico-exit'."
-  (interactive                          ; stolen from `dired-goto-file'
-   (prog1
-       (list (dlet ((vertico-map (copy-keymap vertico-map)))
-               (define-key vertico-map (kbd "RET") #'vertico-exit)
-               (expand-file-name (read-file-name "Goto file: "
-                                                 (dired-current-directory)))))
-     (push-mark)))
-  (dired-goto-file file))
+(with-eval-after-load 'vertico
+ (defun +dired-goto-file (file)
+   "ADVICE for `dired-goto-file' to make RET call `vertico-exit'."
+   (interactive                         ; stolen from `dired-goto-file'
+    (prog1
+        (list (dlet ((vertico-map (copy-keymap vertico-map)))
+                (define-key vertico-map (kbd "RET") #'vertico-exit)
+                (expand-file-name (read-file-name "Goto file: "
+                                                  (dired-current-directory)))))
+      (push-mark)))
+   (dired-goto-file file)))
 
 ;;; [[https://www.reddit.com/r/emacs/comments/u2lf9t/weekly_tips_tricks_c_thread/i4n9aoa/?context=3][Dim files in .gitignore]]
 
@@ -72,11 +72,10 @@ are sorted lexigraphically."
                 ;; otherwise, sort lexigraphically
                 (t (string< s1 s2)))))))))
     ;; Return to original point relative to the defun we were in
-    (goto-char (point-min))
-    (re-search-forward current-defun-re)
-    (beginning-of-defun)
-    (goto-char (+ (point) defun-point))
-    ))
+    (ignore-errors (goto-char (point-min))
+                   (re-search-forward current-defun-re)
+                   (beginning-of-defun)
+                   (goto-char (+ (point) defun-point)))))
 
 (defun +init-sort-then-save ()
   "Sort init.el, then save it."
@@ -10,6 +10,18 @@
 (require 'jabber)
 (require 'tracking)
 
+(defgroup +jabber nil
+  "Extra jabber.el customizations."
+  :group 'jabber)
+
+(defcustom +jabber-ws-prefix 0
+  "Width to pad left side of chats."
+  :type 'string)
+
+(defcustom +jabber-pre-prompt "\n"
+  "String to put before the prompt."
+  :type 'string)
+
 (defvar +jabber-tracking-show-p #'jabber-activity-show-p-default
   "Function that checks if the given JID should be shown in the mode line.
 This does the same as `jabber-activity-show-p', but for the
@@ -19,9 +19,9 @@
 
 ;; I need to define this map before the proper mode map.
 (defvar +key-leader-map (let ((map (make-sparse-keymap))
-                               (c-z (global-key-binding "\C-z")))
-                           (define-key map "\C-z" c-z)
-                           map)
+                              (c-z (global-key-binding "\C-z")))
+                          ;;(define-key map "\C-z" c-z)
+                          map)
   "A leader keymap under the \"C-z\" bind.")
 
 ;; http://xahlee.info/emacs/emacs/emacs_menu_app_keys.html and
@@ -588,19 +588,6 @@ and POST-PROCESS are passed to `org-export-to-file'."
                        ("—" "---"))))
         (replace-match replace nil nil)))))
 
-;;; Toggle org-hide-emphasis-markers
-
-(define-minor-mode +org-show-mode
-  "Show emphasis markers and full links in `org-mode'."
-  :lighter "/*/"
-  (setq org-hide-emphasis-markers (not +org-show-mode)
-        org-link-descriptive (not +org-show-mode))
-  (funcall (if +org-show-mode
-               #'remove-from-invisibility-spec
-             #'add-to-invisibility-spec)
-           '(org-link))
-  (font-lock-update))
-
 ;;; go forward and backward in the tree, ~ cleanly ~
 ;; https://stackoverflow.com/a/25201697/10756297
 
@@ -29,23 +29,37 @@
   "Warn the user that something bad happened in `setup'."
   (display-warning 'setup (format message args)))
 
+(defun +setup-wrap-to-demote-errors (body name)
+  "Wrap BODY in a `with-demoted-errors' block.
+This behavior is prevented if `setup-attributes' contains the
+symbol `without-error-demotion'.
+
+This function differs from `setup-wrap-to-demote-errors' in that
+it includes the NAME of the setup form in the warning output."
+  (if (memq 'without-error-demotion setup-attributes)
+      body
+    `(with-demoted-errors ,(format "Error in setup form on line %d (%s): %%S"
+                                   (line-number-at-pos)
+                                   name)
+       ,body)))
+
 (setup-define :quit
   'setup-quit
   :documentation "Quit the current `setup' form.
 Good for commenting.")
 
 (setup-define :face
-    (lambda (face spec)
-      `(custom-set-faces (list ,face ,spec 'now "Customized by `setup'.")))
+  (lambda (face spec)
+    `(custom-set-faces (list ,face ,spec 'now "Customized by `setup'.")))
   :documentation "Customize FACE with SPEC using `custom-set-faces'."
   :repeatable t)
 
 (setup-define :load-after
-    (lambda (&rest features)
-      (let ((body `(require ',(setup-get 'feature))))
-    (dolist (feature (nreverse features))
-      (setq body `(with-eval-after-load ',feature ,body)))
-    body))
+  (lambda (&rest features)
+    (let ((body `(require ',(setup-get 'feature))))
+      (dolist (feature (nreverse features))
+        (setq body `(with-eval-after-load ',feature ,body)))
+      body))
   :documentation "Load the current feature after FEATURES.")
 
 (setup-define :load-from
@@ -88,50 +102,7 @@ If PATH does not exist, abort the evaluation."
                                                  ',recipe)
                                     ,(setup-quit))
                                    (:success t)))
-(defun setup--straight-handle-arg (arg var)
-  (cond
-   ((and (boundp var) (symbol-value var)) t)
-   ((keywordp arg) (set var t))
-   ((functionp arg) (set var nil) (funcall arg))
-   ((listp arg) (set var nil) (eval arg :lexical))))
-
-(setup-define :straight
-  (lambda (recipe &rest predicates)
-    (let* ((skp (make-symbol "straight-keyword-p"))
-           (straight-use-p
-            (cl-every (lambda (f) (setup--straight-handle-arg f skp))
-                      predicates))
-           (form `(unless (and ,straight-use-p
-                               (condition-case e
-                                   (straight-use-package ',recipe)
-                                 (error
-                                  (+setup-warn ":straight error: %S"
-                                               ',recipe)
-                                  ,(setup-quit))
-                                 (:success t)))
-                    ,(setup-quit))))
-      ;; Keyword arguments --- :quit is special and should short-circuit
-      (if (memq :quit predicates)
-          (setq form `,(setup-quit))
-        ;; Otherwise, handle the rest of them ...
-        (when-let ((after (cadr (memq :after predicates))))
-          (setq form `(with-eval-after-load ,(if (eq after t)
-                                                 (setup-get 'feature)
-                                               after)
-                        ,form))))
-      ;; Finally ...
-      form))
-  :documentation "Install RECIPE with `straight-use-package'.
-If PREDICATES are given, only install RECIPE if all of them return non-nil.
-The following keyword arguments are also recognized:
-- :quit          --- immediately stop evaluating.  Good for commenting.
-- :after FEATURE --- only install RECIPE after FEATURE is loaded.
-                     If FEATURE is t, install RECIPE after the current feature."
-  :repeatable nil
-  :indent 1
-  :shorthand (lambda (sexp)
-               (let ((recipe (cadr sexp)))
-                 (or (car-safe recipe) recipe))))                      ,(setup-quit))))
+                      ,(setup-quit))))
         ;; Keyword arguments --- :quit is special and should short-circuit
         (if (memq :quit predicates)
             (setq form `,(setup-quit))
@@ -155,6 +126,13 @@ The following keyword arguments are also recognized:
                  (let ((recipe (cadr sexp)))
                    (or (car-safe recipe) recipe)))))
 
+(setup-define :needs
+  (lambda (executable)
+    `(unless (executable-find ,executable)
+       ,(setup-quit)))
+  :documentation "If EXECUTABLE is not in the path, stop here."
+  :repeatable 1)
+
 
 ;;; Redefines of `setup' forms
 
@@ -34,6 +34,7 @@ all of them, for reasons that should be obvious.
 
 With a prefix argument, it also pulls the packages FROM-UPSTREAM."
   (interactive "P")
+  (straight-pull-recipe-repositories)
   (straight-pull-all from-upstream)
   (straight-rebuild-all))
 
@@ -138,6 +138,10 @@ active, or else the entire buffer."
                   (= (line-beginning-position) (line-end-position)))
         (insert "\n")))))
 
+(defcustom +open-paragraph-ignore-modes '(special-mode lui-mode comint-mode)
+  "Modes in which `+open-paragraph' makes no sense."
+  :type '(repeat function))
+
 (defun +open-paragraph (&optional arg)
   "Open a paragraph after paragraph at point.
 A paragraph is defined as continguous non-empty lines of text
@@ -148,7 +152,7 @@ Called with prefix ARG, open a paragraph before point."
   ;; TODO: Take an integer as ARG, allowing for skipping paragraphs up and down.
   (interactive "*P")
   ;; TODO: add `+open-paragraph-ignore-modes'
-  (unless (derived-mode-p 'special-mode 'lui-mode 'comint-mode)
+  (unless (apply #'derived-mode-p +open-paragraph-ignore-modes)
     ;; 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.
     (unless (looking-at "^$") (forward-line (if arg -1 +1)))
@@ -426,5 +430,22 @@ This calls `indent-rigidly' and passes ARG to it."
     (goto-char (line-end-position)))
   (call-interactively #'indent-rigidly))
 
+(defun +sort-lines (reverse beg end)
+  "Sort lines in region, ignoring leading whitespace.
+REVERSE non-nil means descending order; interactively, REVERSE is
+the prefix argument, and BEG and END are the region.  The
+variable `sort-fold-case' determines whether case affects the
+sort order."
+  (interactive "P\nr")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region beg end)
+      (goto-char (point-min))
+      (let ((inhibit-field-text-motion t))
+        (sort-subr reverse
+                   #'forward-line
+                   #'end-of-line
+                   #'beginning-of-line-text)))))
+
 (provide 'acdw)
 ;;; acdw.el ends here
@@ -0,0 +1,36 @@
+;;; find-script.el --- Find a script in $PATH -*- lexical-binding: t; -*-
+
+;;; Commentary:
+
+;; This package makes it easier to find a script to edit in $PATH.  The initial
+;; `rehash-exes' is slow, but it's stored in `*exes*' as a caching mechanism.
+;; However, I'm sure it could be improved.
+
+;; In addition, `*exes*' currently contains /all/ executables in $PATH, which
+;; ... maybe only the ones stored in some text format should be shown.
+
+;;; Code:
+
+(defvar *exes* nil
+  "All the exectuables in $PATH.
+Run `rehash-exes' to refresh this variable.")
+
+(defun rehash-exes ()
+  "List all the executables in $PATH.
+Also sets `*exes*' parameter."
+  (setq *exes*
+        (cl-loop for dir in exec-path
+                 append (file-expand-wildcards (concat dir "*"))
+                 into exes
+                 finally return exes)))
+
+;;;###autoload
+(defun find-script (script)
+  "Find a file in $PATH."
+  (interactive
+   (list (let ((exes (or *exes* (rehash-exes))))
+           (completing-read "Script> " exes nil t))))
+  (find-file script))
+
+(provide 'find-script)
+;;; find-script.el ends here