yeet

.config/emacs/modules/config/default/autoload/default.el

@@ -0,0 +1,68 @@
+;; config/default/autoload/default.el -*- lexical-binding: t; -*-
+
+;;;###autoload
+(defun +default/compile (arg)
+  "Runs `compile' from the root of the current project.
+
+If a compilation window is already open, recompile that instead.
+
+If ARG (universal argument), runs `compile' from the current directory."
+  (interactive "P")
+  (if (and (bound-and-true-p compilation-in-progress)
+           (buffer-live-p compilation-last-buffer))
+      (recompile)
+    (call-interactively
+     (if arg
+         #'projectile-compile-project
+       #'compile))))
+
+;;;###autoload
+(defun +default/man-or-woman ()
+  "Invoke `man' if man is installed and the platform is not MacOS, otherwise use `woman'.
+
+`man -k \"^\"` is very slow on MacOS, which is what `Man-completion-table' uses to
+generate `completing-read' candidates."
+  (interactive)
+  (call-interactively
+   (if (and (not IS-MAC) (executable-find "man"))
+       #'man
+     #'woman)))
+
+;;;###autoload
+(defun +default/new-buffer ()
+  "TODO"
+  (interactive)
+  (if (featurep! 'evil)
+      (call-interactively #'evil-buffer-new)
+    (let ((buffer (generate-new-buffer "*new*")))
+      (set-window-buffer nil buffer)
+      (with-current-buffer buffer
+        (funcall (default-value 'major-mode))))))
+
+;;;###autoload
+(defun +default/restart-server ()
+  "Restart the Emacs server."
+  (interactive)
+  (server-force-delete)
+  (while (server-running-p)
+    (sleep-for 1))
+  (server-start))
+
+;;;###autoload
+(defun +default/diagnostics (&rest arg)
+  "List diagnostics for the current buffer/project.
+If the the vertico and lsp modules are active, list lsp diagnostics for the
+current project. Otherwise list them for the current buffer"
+  (interactive)
+  (cond ((and (featurep! :completion vertico)
+              (featurep! :tools lsp)
+              (bound-and-true-p lsp-mode))
+         (consult-lsp-diagnostics arg))
+        ((and (featurep! :checkers syntax)
+              (bound-and-true-p flycheck-mode))
+         (flycheck-list-errors))
+        ((bound-and-true-p flymake-mode)
+         (flymake-show-diagnostics-buffer))
+        (t
+         (user-error "No diagnostics backend detected. Enable flycheck or \
+flymake, or set up lsp-mode if applicable (see :lang lsp)"))))

.config/emacs/modules/config/default/autoload/deferred.el

@@ -0,0 +1,20 @@
+;;; config/default/autoload/deferred.el -*- lexical-binding: t; -*-
+
+;; TODO generalize this
+;;;###autoload
+(defun +default/lsp-command-map ()
+  "Lazily invoke `lsp-command-map'."
+  (interactive)
+  (require 'lsp-mode)
+  (map! :leader "c l" lsp-command-map)
+  (dolist (leader-key (list doom-leader-key doom-leader-alt-key))
+    (let ((lsp-keymap-prefix (concat leader-key " c l")))
+      (lsp-enable-which-key-integration)))
+  (setq prefix-arg current-prefix-arg
+        unread-command-events
+        (mapcar (lambda (e) (cons t e))
+                (vconcat (when (bound-and-true-p evil-this-operator)
+                           (where-is-internal evil-this-operator
+                                              evil-normal-state-map
+                                              t))
+                         (this-command-keys)))))

.config/emacs/modules/config/default/autoload/files.el

@@ -0,0 +1,66 @@
+;;; config/default/autoload/files.el -*- lexical-binding: t; -*-
+
+;;;###autoload
+(defun +default/browse-project ()
+  "Browse files from the current project's root."
+  (interactive) (doom-project-browse (doom-project-root)))
+;; NOTE No need for find-in-project, use `projectile-find-file'
+
+;;;###autoload
+(defun +default/browse-templates ()
+  "Browse files from `+file-templates-dir'."
+  (interactive) (doom-project-browse +file-templates-dir))
+;;;###autoload
+(defun +default/find-in-templates ()
+  "Find a file under `+file-templates-dir', recursively."
+  (interactive) (doom-project-find-file +file-templates-dir))
+
+;;;###autoload
+(defun +default/browse-notes ()
+  "Browse files from `org-directory'."
+  (interactive)
+  (unless (bound-and-true-p org-directory)
+    (require 'org))
+  (doom-project-browse org-directory))
+;;;###autoload
+(defun +default/find-in-notes ()
+  "Find a file under `org-directory', recursively."
+  (interactive)
+  (unless (bound-and-true-p org-directory)
+    (require 'org))
+  (doom-project-find-file org-directory))
+
+;;;###autoload
+(defun +default/find-file-under-here ()
+  "Perform a recursive file search from the current directory."
+  (interactive)
+  (doom-project-find-file default-directory))
+
+;;;###autoload
+(defun +default/discover-projects (arg)
+  "Discover projects in `projectile-project-search-path'.
+If prefix ARG is non-nil, prompt for the search path."
+  (interactive "P")
+  (if arg
+      (call-interactively #'projectile-discover-projects-in-directory)
+    (if (not projectile-project-search-path)
+        (user-error "`projectile-project-search-path' is empty; don't know where to search")
+      (letf! (defun projectile-add-known-project (project-root)
+               (unless (projectile-ignored-project-p project-root)
+                 (funcall projectile-add-known-project project-root)
+                 (message "Added %S to known project roots" project-root)))
+        (dolist (dir projectile-project-search-path)
+          (cl-destructuring-bind (dir . depth) (if (consp dir) dir (cons dir nil))
+            (if (not (file-accessible-directory-p dir))
+                (message "%S was inaccessible and couldn't be searched" dir)
+              (projectile-discover-projects-in-directory dir depth))))))))
+
+;;;###autoload
+(defun +default/dired (arg)
+  "Open a directory in dired.
+If prefix ARG is non-nil, prompt for a known project to open in dired."
+  (interactive "P")
+  (apply #'dired
+         (if arg
+             (list (completing-read "Open dired in project: " projectile-known-projects))
+           (dired-read-dir-and-switches ""))))

.config/emacs/modules/config/default/autoload/search.el

@@ -0,0 +1,144 @@
+;;; config/default/autoload/search.el -*- lexical-binding: t; -*-
+
+;;;###autoload
+(defun +default/search-cwd (&optional arg)
+  "Conduct a text search in files under the current folder.
+If prefix ARG is set, prompt for a directory to search from."
+  (interactive "P")
+  (let ((default-directory
+          (if arg
+              (read-directory-name "Search directory: ")
+            default-directory)))
+    (call-interactively
+     (cond ((featurep! :completion ivy)     #'+ivy/project-search-from-cwd)
+           ((featurep! :completion helm)    #'+helm/project-search-from-cwd)
+           ((featurep! :completion vertico) #'+vertico/project-search-from-cwd)
+           (#'rgrep)))))
+
+;;;###autoload
+(defun +default/search-other-cwd ()
+  "Conduct a text search in another directory."
+  (interactive)
+  (+default/search-cwd 'other))
+
+;;;###autoload
+(defun +default/search-emacsd ()
+  "Conduct a text search in files under `user-emacs-directory'."
+  (interactive)
+  (let ((default-directory user-emacs-directory))
+    (call-interactively
+     (cond ((featurep! :completion ivy)     #'+ivy/project-search-from-cwd)
+           ((featurep! :completion helm)    #'+helm/project-search-from-cwd)
+           ((featurep! :completion vertico) #'+vertico/project-search-from-cwd)
+           (#'rgrep)))))
+
+;;;###autoload
+(defun +default/search-buffer ()
+  "Conduct a text search on the current buffer.
+
+If a selection is active and multi-line, perform a search restricted to that
+region.
+
+If a selection is active and not multi-line, use the selection as the initial
+input and search the whole buffer for it."
+  (interactive)
+  (let (start end multiline-p)
+    (save-restriction
+      (when (region-active-p)
+        (setq start (region-beginning)
+              end   (region-end)
+              multiline-p (/= (line-number-at-pos start)
+                              (line-number-at-pos end)))
+        (deactivate-mark)
+        (when multiline-p
+          (narrow-to-region start end)))
+      (cond ((or (featurep! :completion helm)
+                 (featurep! :completion ivy))
+             (call-interactively
+              (if (and start end (not multiline-p))
+                  #'swiper-isearch-thing-at-point
+                #'swiper-isearch)))
+            ((featurep! :completion vertico)
+             (if (and start end (not multiline-p))
+                 (consult-line
+                  (replace-regexp-in-string
+                   " " "\\\\ "
+                   (rxt-quote-pcre
+                    (buffer-substring-no-properties start end))))
+               (call-interactively #'consult-line)))))))
+
+;;;###autoload
+(defun +default/search-project (&optional arg)
+  "Conduct a text search in the current project root.
+If prefix ARG is set, include ignored/hidden files."
+  (interactive "P")
+  (let* ((projectile-project-root nil)
+         (disabled-command-function nil)
+         (current-prefix-arg (unless (eq arg 'other) arg))
+         (default-directory
+           (if (eq arg 'other)
+               (if-let (projects (projectile-relevant-known-projects))
+                   (completing-read "Search project: " projects nil t)
+                 (user-error "There are no known projects"))
+             default-directory)))
+    (call-interactively
+     (cond ((featurep! :completion ivy)     #'+ivy/project-search)
+           ((featurep! :completion helm)    #'+helm/project-search)
+           ((featurep! :completion vertico) #'+vertico/project-search)
+           (#'projectile-ripgrep)))))
+
+;;;###autoload
+(defun +default/search-other-project ()
+  "Conduct a text search in a known project."
+  (interactive)
+  (+default/search-project 'other))
+
+;;;###autoload
+(defun +default/search-project-for-symbol-at-point (symbol dir)
+  "Search current project for symbol at point.
+If prefix ARG is set, prompt for a known project to search from."
+  (interactive
+   (list (rxt-quote-pcre (or (doom-thing-at-point-or-region) ""))
+         (let ((projectile-project-root nil))
+           (if current-prefix-arg
+               (if-let (projects (projectile-relevant-known-projects))
+                   (completing-read "Search project: " projects nil t)
+                 (user-error "There are no known projects"))
+             (doom-project-root default-directory)))))
+  (cond ((featurep! :completion ivy)
+         (+ivy/project-search nil symbol dir))
+        ((featurep! :completion helm)
+         (+helm/project-search nil symbol dir))
+        ((featurep! :completion vertico)
+         (+vertico/project-search nil symbol dir))
+        ((rgrep (regexp-quote symbol)))))
+
+;;;###autoload
+(defun +default/search-notes-for-symbol-at-point (symbol)
+  "Conduct a text search in the current project for symbol at point. If prefix
+ARG is set, prompt for a known project to search from."
+  (interactive
+   (list (rxt-quote-pcre (or (doom-thing-at-point-or-region) ""))))
+  (require 'org)
+  (+default/search-project-for-symbol-at-point
+   symbol org-directory))
+
+;;;###autoload
+(defun +default/org-notes-search (query)
+  "Perform a text search on `org-directory'."
+  (interactive
+   (list (if (doom-region-active-p)
+             (buffer-substring-no-properties
+              (doom-region-beginning)
+              (doom-region-end))
+           "")))
+  (require 'org)
+  (+default/search-project-for-symbol-at-point
+   query org-directory))
+
+;;;###autoload
+(defun +default/org-notes-headlines ()
+  "Jump to an Org headline in `org-agenda-files'."
+  (interactive)
+  (doom-completing-read-org-headings
+   "Jump to org headline: " org-agenda-files 3 t))

.config/emacs/modules/config/default/autoload/text.el

@@ -0,0 +1,166 @@
+;;; config/default/autoload/text.el -*- lexical-binding: t; -*-
+
+;;;###autoload
+(defalias '+default/newline #'electric-indent-just-newline)
+
+;;;###autoload
+(defun +default/newline-above ()
+  "Insert an indented new line before the current one."
+  (interactive)
+  (if (featurep 'evil)
+      (call-interactively 'evil-open-above)
+    (beginning-of-line)
+    (save-excursion (newline))
+    (indent-according-to-mode)))
+
+;;;###autoload
+(defun +default/newline-below ()
+  "Insert an indented new line after the current one."
+  (interactive)
+  (if (featurep 'evil)
+      (call-interactively 'evil-open-below)
+    (end-of-line)
+    (newline-and-indent)))
+
+;;;###autoload
+(defun +default/yank-pop ()
+  "Interactively select what text to insert from the kill ring."
+  (interactive)
+  (call-interactively
+   (cond ((fboundp 'consult-yank-pop)    #'consult-yank-pop) ;HACK see @ymarco's comment on #5013 and TODO.org in the selecturm module.
+         ((fboundp 'counsel-yank-pop)    #'counsel-yank-pop)
+         ((fboundp 'helm-show-kill-ring) #'helm-show-kill-ring)
+         ((error "No kill-ring search backend available. Enable ivy, helm or vertico!")))))
+
+;;;###autoload
+(defun +default/yank-buffer-path (&optional root)
+  "Copy the current buffer's path to the kill ring."
+  (interactive)
+  (if-let (filename (or (buffer-file-name (buffer-base-buffer))
+                        (bound-and-true-p list-buffers-directory)))
+      (message "Copied path to clipboard: %s"
+               (kill-new (abbreviate-file-name
+                          (if root
+                              (file-relative-name filename root)
+                            filename))))
+    (error "Couldn't find filename in current buffer")))
+
+;;;###autoload
+(defun +default/yank-buffer-path-relative-to-project (&optional include-root)
+  "Copy the current buffer's path to the kill ring.
+With non-nil prefix INCLUDE-ROOT, also include the project's root."
+  (interactive "P")
+  (+default/yank-buffer-path
+   (if include-root
+       (file-name-directory (directory-file-name (doom-project-root)))
+     (doom-project-root))))
+
+;;;###autoload
+(defun +default/insert-file-path (arg)
+  "Insert the file name (absolute path if prefix ARG).
+If `buffer-file-name' isn't set, uses `default-directory'."
+  (interactive "P")
+  (let ((path (or buffer-file-name default-directory)))
+    (insert
+     (if arg
+         (abbreviate-file-name path)
+       (file-name-nondirectory path)))))
+
+;;;###autoload
+(defun doom/backward-delete-whitespace-to-column ()
+  "Delete back to the previous column of whitespace, or as much whitespace as
+possible, or just one char if that's not possible."
+  (interactive)
+  (let* ((context
+          (if (bound-and-true-p smartparens-mode)
+              (ignore-errors (sp-get-thing))))
+         (op (plist-get context :op))
+         (cl (plist-get context :cl))
+         open-len close-len current-column)
+    (cond ;; When in strings (sp acts weird with quotes; this is the fix)
+          ;; Also, skip closing delimiters
+          ((and op cl
+                (string= op cl)
+                (and (string= (char-to-string (or (char-before) 0)) op)
+                     (setq open-len (length op)))
+                (and (string= (char-to-string (or (char-after) 0)) cl)
+                     (setq close-len (length cl))))
+           (delete-char (- open-len))
+           (delete-char close-len))
+
+          ;; Delete up to the nearest tab column IF only whitespace between
+          ;; point and bol.
+          ((and (not indent-tabs-mode)
+                (> tab-width 1)
+                (not (bolp))
+                (not (doom-point-in-string-p))
+                (>= (abs (save-excursion (skip-chars-backward " \t")))
+                    (setq current-column (current-column))))
+           (delete-char (- (1+ (% (1- current-column) tab-width)))))
+
+          ;; Otherwise do a regular delete
+          ((delete-char -1)))))
+
+;;;###autoload
+(defun +default--delete-backward-char-a (n &optional killflag)
+  "Same as `delete-backward-char', but preforms these additional checks:
+
++ If point is surrounded by (balanced) whitespace and a brace delimiter ({} []
+  ()), delete a space on either side of the cursor.
++ If point is at BOL and surrounded by braces on adjacent lines, collapse
+  newlines:
+  {
+  |
+  } => {|}
++ Otherwise, resort to `doom/backward-delete-whitespace-to-column'.
++ Resorts to `delete-char' if n > 1"
+  (interactive "p\nP")
+  (or (integerp n)
+      (signal 'wrong-type-argument (list 'integerp n)))
+  (cond ((and (use-region-p)
+              delete-active-region
+              (= n 1))
+         ;; If a region is active, kill or delete it.
+         (if (eq delete-active-region 'kill)
+             (kill-region (region-beginning) (region-end) 'region)
+           (funcall region-extract-function 'delete-only)))
+        ;; In Overwrite mode, maybe untabify while deleting
+        ((null (or (null overwrite-mode)
+                   (<= n 0)
+                   (memq (char-before) '(?\t ?\n))
+                   (eobp)
+                   (eq (char-after) ?\n)))
+         (let ((ocol (current-column)))
+           (delete-char (- n) killflag)
+           (save-excursion
+             (insert-char ?\s (- ocol (current-column)) nil))))
+        ;;
+        ((= n 1)
+         (cond ((or (not (featurep! +smartparens))
+                    (not (bound-and-true-p smartparens-mode))
+                    (and (memq (char-before) (list ?\  ?\t))
+                         (save-excursion
+                           (and (/= (skip-chars-backward " \t" (line-beginning-position)) 0)
+                                (bolp)))))
+                (doom/backward-delete-whitespace-to-column))
+               ((let* ((pair (ignore-errors (sp-get-thing)))
+                       (op   (plist-get pair :op))
+                       (cl   (plist-get pair :cl))
+                       (beg  (plist-get pair :beg))
+                       (end  (plist-get pair :end)))
+                  (cond ((and end beg (= end (+ beg (length op) (length cl))))
+                         (delete-char (- (length op))))
+                        ((doom-surrounded-p pair 'inline 'balanced)
+                         (delete-char -1 killflag)
+                         (delete-char 1)
+                         (when (= (point) (+ (length cl) beg))
+                           (sp-backward-delete-char 1)
+                           (sp-insert-pair op)))
+                        ((and (bolp) (doom-surrounded-p pair nil 'balanced))
+                         (delete-region beg end)
+                         (sp-insert-pair op)
+                         t)
+                        ((run-hook-with-args-until-success 'doom-delete-backward-functions))
+                        ((doom/backward-delete-whitespace-to-column)))))))
+        ;; Otherwise, do simple deletion.
+        ((delete-char (- n) killflag))))