(Emacs)~Merged app.org, lang.org and core.org back into config.org

Just makes it easier to profile and deal with compilation

1 files changed, 0 insertions, 907 deletions

diff --git a/Emacs/.config/emacs/app.org b/Emacs/.config/emacs/app.org
deleted file mode 100644
index e5e8cb8..0000000
--- a/Emacs/.config/emacs/app.org
+++ /dev/null
@@ -1,907 +0,0 @@
-#+title: Applications for Emacs
-#+author: Aryadev Chavali
-#+description: Applications for my Emacs OS™
-#+date: 2023-09-29
-#+property: header-args:emacs-lisp :tangle app.el :comments link :results none
-#+options: toc:nil
-#+startup: noindent
-
-Applications are greater than packages; they provide a set of
-functionality to create an interface in Emacs.  Emacs comes with
-applications and others may be installed.
-
-* WAIT Dashboard
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-Dashboard creates a custom dashboard for Emacs that replaces the
-initial startup screen in default Emacs.  It has a lot of customising
-options.
-
-Unfortunately not that useful, many things are easier to invoke
-directly such as recent files or project changing.
-#+begin_src emacs-lisp
-(use-package dashboard
-  :straight t
-  :demand t
-  :general
-  (app-leader
-    "b" #'dashboard-refresh-buffer)
-  (:states '(normal motion emacs)
-   :keymaps 'dashboard-mode-map
-   "q" (proc (interactive) (kill-this-buffer)))
-  (nmmap
-    :keymaps 'dashboard-mode-map
-    "r" #'dashboard-jump-to-recent-files
-    "p" #'dashboard-jump-to-projects
-    "}" #'dashboard-next-section
-    "{" #'dashboard-previous-section)
-  :init
-  (setq initial-buffer-choice nil
-        dashboard-banner-logo-title "Oreomacs"
-        dashboard-center-content t
-        dashboard-set-init-info t
-        dashboard-startup-banner (no-littering-expand-etc-file-name "dashboard/logo.png")
-        dashboard-set-footer t
-        dashboard-set-navigator t
-        dashboard-items '((projects . 5)
-                          (recents . 5))
-        dashboard-footer-messages (list
-                                   "Collecting parentheses..."
-                                   "Linking 'coffee_machine.o'..."
-                                   "Uploading ip to hacker named 4chan..."
-                                   "Dividing by zero..."
-                                   "Solving 3-sat..."
-                                   "Obtaining your health record..."
-                                   (format "Recompiling Emacs for the %dth time..." (random 1000))
-                                   "Escaping the cycle of samsara..."))
-  :config
-  (dashboard-setup-startup-hook))
-#+end_src
-* EWW
-Emacs Web Wowser is the inbuilt text based web browser for Emacs.  It
-can render images and basic CSS styles but doesn't have a JavaScript
-engine, which makes sense as it's primarily a text interface.
-#+begin_src emacs-lisp
-(use-package eww
-  :defer t
-  :general
-  (app-leader
-    "ww" #'eww
-    "wb" #'+eww/bookmarks-search
-    "we" #'+eww/bookmarks-edit)
-  (nmmap
-    :keymaps 'eww-mode-map
-    "w" #'evil-forward-word-begin
-    "Y" #'shr-probe-and-copy-url)
-  :straight nil
-  :config
-  (with-eval-after-load "evil-collection"
-    (evil-collection-eww-setup))
-  (defun bookmark->alist (bookmark)
-    (cons (plist-get bookmark :title)
-          (plist-get bookmark :url)))
-  (defun +eww/bookmarks-edit nil
-    (interactive)
-    (find-file (concat eww-bookmarks-directory "eww-bookmarks")))
-  (defun +eww/bookmarks-search nil
-    (interactive)
-    (let ((bookmarks (mapcar #'bookmark->alist eww-bookmarks)))
-      (eww
-       (alist-get (completing-read "Bookmark: " (mapcar #'car bookmarks) nil t)
-                  bookmarks
-                  nil
-                  nil
-                  #'string=)))))
-#+end_src
-* Calendar
-Calendar is a simple inbuilt application that helps with date
-functionalities.  I add functionality to copy dates from the calendar
-to the kill ring and bind it to "Y".
-#+begin_src emacs-lisp
-(use-package calendar
-  :straight nil
-  :defer t
-  :commands (+calendar/copy-date +calendar/toggle-calendar)
-  :display
-  ("\\*Calendar\\*"
-   (display-buffer-at-bottom)
-   (inhibit-duplicate-buffer . t)
-   (window-height . 0.17))
-  :general
-  (nmmap
-    :keymaps 'calendar-mode-map
-    "Y" #'+calendar/copy-date)
-  (app-leader
-    "d" #'calendar)
-  :config
-  (defun +calendar/copy-date ()
-    "Copy date under cursor into kill ring."
-    (interactive)
-    (if (use-region-p)
-        (call-interactively #'kill-ring-save)
-      (let ((date (calendar-cursor-to-date)))
-        (when date
-          (setq date (encode-time 0 0 0 (nth 1 date) (nth 0 date) (nth 2 date)))
-          (kill-new (format-time-string "%Y-%m-%d" date)))))))
-#+end_src
-* Mail
-Mail is a funny thing; most people use it just for business or
-advertising and it's come out of use in terms of personal
-communication in the west for the most part (largely due to "social"
-media applications).  However, this isn't true for the open source and
-free software movement who heavily use mail for communication.
-
-Integrating mail into Emacs helps as I can send source code and
-integrate it into my workflow just a bit better.
-** Notmuch
-#+begin_src emacs-lisp
-(use-package notmuch
-  :defer t
-  :commands (notmuch +mail/flag-thread)
-  :general
-  (app-leader "m" #'notmuch)
-  (nmap
-    :keymaps 'notmuch-search-mode-map
-    "f" #'+mail/flag-thread)
-  :init
-  (defconst +mail/signature "---------------\nAryadev Chavali")
-  (defconst +mail/local-dir (no-littering-expand-var-file-name "mail/"))
-  (setq notmuch-show-logo nil
-        notmuch-search-oldest-first nil
-        notmuch-hello-sections '(notmuch-hello-insert-saved-searches
-                                 notmuch-hello-insert-alltags
-                                 notmuch-hello-insert-recent-searches)
-        notmuch-archive-tags '("-inbox" "-unread" "+archive")
-        mail-signature +mail/signature
-        mail-default-directory +mail/local-dir
-        mail-source-directory +mail/local-dir
-        message-signature +mail/signature
-        message-auto-save-directory +mail/local-dir
-        message-directory +mail/local-dir)
-
-  (defun +mail/sync-mail ()
-    "Sync mail via mbsync."
-    (interactive)
-    (start-process-shell-command "" nil "mbsync -a"))
-  (defun +mail/trash-junk ()
-    "Delete any mail in junk"
-    (interactive)
-    (start-process-shell-command "" nil "notmuch search --output=files --format=text0 tag:deleted tag:spam tag:trash tag:junk | xargs -r0 rm"))
-  :config
-  (defun +mail/flag-thread (&optional unflag beg end)
-    (interactive (cons current-prefix-arg (notmuch-interactive-region)))
-    (notmuch-search-tag
-     (notmuch-tag-change-list '("-inbox" "+flagged") unflag) beg end)
-    (when (eq beg end)
-      (notmuch-search-next-thread)))
-
-  (advice-add #'notmuch-poll-and-refresh-this-buffer :after
-              #'+mail/trash-junk)
-  (with-eval-after-load "evil-collection"
-    (evil-collection-notmuch-setup)))
-#+end_src
-** Smtpmail
-#+begin_src emacs-lisp
-(use-package smtpmail
-  :straight nil
-  :commands mail-send
-  :init
-  (setq-default
-   smtpmail-smtp-server "mail.aryadevchavali.com"
-   smtpmail-smtp-user "aryadev"
-   smtpmail-smtp-service 587
-   smtpmail-stream-type 'starttls
-   send-mail-function #'smtpmail-send-it
-   message-send-mail-function #'smtpmail-send-it))
-#+end_src
-* Dired
-Setup for dired.  Make dired-hide-details-mode the default mode when
-using dired-mode, as it removes the clutter.  Setup evil collection
-for dired (even though dired doesn't really conflict with evil, there
-are some corners I'd like to adjust).
-#+begin_src emacs-lisp
-(use-package dired
-  :straight nil
-  :commands (dired find-dired)
-  :hook
-  (dired-mode-hook              . auto-revert-mode)
-  (dired-mode-hook              . dired-hide-details-mode)
-  :init
-  (setq-default dired-listing-switches "-AFBlu --group-directories-first"
-                dired-omit-files "^\\."
-                dired-dwim-target t
-                image-dired-external-viewer "nsxiv")
-  (with-eval-after-load "evil-collection"
-    (evil-collection-dired-setup))
-  :general
-  (nmmap
-    :keymaps 'dired-mode-map
-    "SPC"   nil
-    "SPC ," nil
-    "T"     #'dired-create-empty-file
-    "H"     #'dired-up-directory
-    "L"     #'dired-find-file)
-  (dir-leader
-    "f" #'find-dired
-    "d" #'dired
-    "D" #'dired-other-window
-    "i" #'image-dired
-    "p" `(,(proc (interactive)
-                 (dired "~/Text/PDFs/"))
-          :which-key "Open PDFs"))
-  (local-leader
-    :keymaps 'dired-mode-map
-    "i" #'dired-maybe-insert-subdir
-    "I" #'+dired/insert-all-subdirectories
-    "k" #'dired-prev-subdir
-    "j" #'dired-next-subdir
-    "K" #'dired-kill-subdir
-    "m" #'dired-mark-files-regexp
-    "u" #'dired-undo)
-  (nmmap
-    :keymaps 'image-dired-thumbnail-mode-map
-    "h" #'image-dired-backward-image
-    "l" #'image-dired-forward-image
-    "j" #'image-dired-next-line
-    "k" #'image-dired-previous-line
-    "H" #'image-dired-display-previous
-    "L" #'image-dired-display-next
-    "RET" #'image-dired-display-this
-    "m" #'image-dired-mark-thumb-original-file
-    "q" #'quit-window)
-  :config
-  (add-to-list 'dired-guess-shell-alist-user '("\\.pdf\\'" "zathura"))
-  (defun +dired/insert-all-subdirectories ()
-    "Insert all subdirectories currently viewable."
-    (interactive)
-    (dired-mark-directories nil)
-    (mapc #'dired-insert-subdir (dired-get-marked-files))
-    (dired-unmark-all-marks)))
-#+end_src
-** fd-dired
-Uses fd for finding file results in a directory: ~find-dired~ ->
-~fd-dired~.
-
-#+begin_src emacs-lisp
-(use-package fd-dired
-  :after dired
-  :straight t
-  :general
-  (dir-leader
-    "g" #'fd-dired))
-#+end_src
-** wdired
-Similar to [[file:config.org::*(Rip)grep][wgrep]] =wdired= provides
-the ability to use Emacs motions and editing on file names.  This
-makes stuff like mass renaming and other file management tasks way
-easier than even using the mark based system.
-#+begin_src emacs-lisp
-(use-package wdired
-  :after dired
-  :straight t
-  :general
-  (nmmap
-    :keymaps 'dired-mode-map
-    "W" #'wdired-change-to-wdired-mode)
-  (nmmap
-    :keymaps 'wdired-mode-map
-    "ZZ" #'wdired-finish-edit
-    "ZQ" #'wdired-abort-changes))
-#+end_src
-* WAIT Xwidget
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-Xwidget is a package which allows for the insertion of arbitrary
-xwidgets into Emacs through buffers.  It must be compiled into Emacs
-so you might need to customise your install.  One of its premier uses
-is in navigating the web which it provides through the function
-~xwidget-webkit-browse-url~.  This renders a fully functional web
-browser within Emacs.
-
-Though I am not to keen on using Emacs to browse the web /via/ xwidget
-(EWW does a good job on its own), I am very interested in its
-capability to render pages with JavaScript, as it may come of use when
-doing web development.  I can see the results of work very quickly
-without switching windows all within Emacs.
-
-2023-10-20: Disabled as it didn't seem to work, and honestly wasn't
-that useful.
-** Xwidget Core
-#+begin_src emacs-lisp
-(use-package xwidget
-  :straight nil
-  :general
-  (app-leader
-    "u" #'xwidget-webkit-browse-url)
-  (nmmap
-    :keymaps 'xwidget-webkit-mode-map
-    "q"         #'quit-window
-    "h"         #'xwidget-webkit-scroll-backward
-    "j"         #'xwidget-webkit-scroll-up
-    "k"         #'xwidget-webkit-scroll-down
-    "l"         #'xwidget-webkit-scroll-forward
-    "+"         #'xwidget-webkit-zoom-in
-    "-"         #'xwidget-webkit-zoom-out
-    (kbd "C-f") #'xwidget-webkit-scroll-up
-    (kbd "C-b") #'xwidget-webkit-scroll-down
-    "H"         #'xwidget-webkit-back
-    "L"         #'xwidget-webkit-forward
-    "gu"        #'xwidget-webkit-browse-url
-    "gr"        #'xwidget-webkit-reload
-    "gg"        #'xwidget-webkit-scroll-top
-    "G"         #'xwidget-webkit-scroll-bottom))
-#+end_src
-** Xwidget Extensions
-Define a function ~+xwidget/render-file~ that reads a file name and
-presents it in an xwidget.  If the current file is an HTML file, ask
-if user wants to open current file.  Bind it to ~aU~ in the leader.
-
-Also define a function ~+xwidget/search-query~ that first asks the
-user what search engine they want to use ([[https://duckduckgo.com][Duck Duck Go]] and [[https://devdocs.io][DevDocs]]
-currently) then asks for a query, which it parses then presents in an
-xwidget window.  Bind to ~as~ in the leader.
-#+begin_src emacs-lisp
-(use-package xwidget
-  :straight nil
-  :commands (+xwidget/render-file +xwidget/search)
-  :general
-  (app-leader
-    "U" #'+xwidget/render-file
-    "s" #'+xwidget/search)
-  :config
-  (setenv "WEBKIT_FORCE_SANDBOX" "0")
-  (defun +xwidget/render-file (&optional FORCE)
-    "Find file (or use current file) and render in xwidget."
-    (interactive)
-    (cond
-     ((and (not FORCE) (or (string= (replace-regexp-in-string ".*.html"
-                                                              "html" (buffer-name)) "html")
-                           (eq major-mode 'web-mode)
-                           (eq major-mode 'html-mode))) ; If in html file
-      (if (y-or-n-p "Open current file?: ") ; Maybe they want to open a separate file
-          (xwidget-webkit-browse-url (format "file://%s" (buffer-file-name)))
-        (+xwidget/render-file t))) ; recurse and open file via prompt
-     (t
-      (xwidget-webkit-browse-url
-       (format "file://%s" (read-file-name "Enter file to open: "))))))
-
-  (defun +xwidget/search ()
-    "Run a search query on some search engine and display in
-xwidget."
-    (interactive)
-    (let* ((engine (completing-read "Engine: " '("duckduckgo.com" "devdocs.io") nil t))
-           (query-raw (read-string "Enter query: "))
-           (query
-            (cond
-             ((string= engine "duckduckgo.com") query-raw)
-             ((string= engine "devdocs.io") (concat "_ " query-raw)))))
-      (xwidget-webkit-browse-url (concat "https://" engine "/?q=" query)))))
-#+end_src
-* Eshell
-** Why Eshell?
-Eshell is an integrated shell environment for Emacs, written in Emacs
-Lisp.  I argue that it is the best shell/command interpreter to use in
-Emacs.
-
-Eshell is unlike the alternatives in Emacs as it's a /shell/ first,
-not a terminal emulator. It has the ability to spoof some aspects of a
-terminal emulator (through the shell parser), but it is NOT a terminal
-emulator.
-
-The killer benefits of eshell (which would appeal to Emacs users) are
-a direct result of eshell being written in Emacs lisp:
-- incredible integration with Emacs utilities (such as ~dired~,
-  ~find-file~, any read functions, etc)
-- very extensible, easy to write new commands which leverage Emacs
-  commands as well as external utilities
-- agnostic of platform: "eshell/cd" will call the underlying change
-  directory function for you, so commands will (usually) mean the same
-  thing regardless of platform
-  - this means as long as Emacs can run on an operating system, one
-    may run eshell
-
-However, my favourite feature of eshell is the set of evaluators that
-run on command input.  Some of the benefits listed above come as a
-result of this powerful feature. These evaluators are described below.
-
-Lisp evaluator: works on braced expressions, evaluating them as Lisp
-expressions (e.g. ~(message "Hello, World!\n")~).  Any returned
-objects are printed.  This makes eshell a LISP REPL!
-
-External evaluator: works within curly braces, evaluating them via
-some external shell process (like sh) (e.g. ~{echo "Hello,
-world!\n"}~).  This makes eshell a (kinda dumb) terminal emulator!
-
-The alias evaluator is the top level evaluator.  It is the main
-evaluator for each expression given to eshell.  When given an
-expression it tries to evaluate it by testing against these conditions:
-- it's an alias defined by the user or in the ~eshell/~ namespace of
-  functions (simplest evaluator)
-- it's some form of lisp expression (lisp evaluator)
-- it's an external command (bash evaluator)
-Essentially, you get the best of both Emacs and external shell
-programs *ALL WITHIN* Emacs for free.
-** Eshell functionality
-Bind some evil-like movements for easy shell usage, and a toggle
-function to pull up the eshell quickly.
-#+begin_src emacs-lisp
-(use-package eshell
-  :defer t
-  :general
-  (shell-leader
-    "t" #'eshell)
-  :init
-  (add-hook
-   'eshell-mode-hook
-   (proc
-    (interactive)
-    (general-def
-      :states '(normal insert)
-      :keymaps 'eshell-mode-map
-      "M-j" #'eshell-next-matching-input-from-input
-      "M-k" #'eshell-previous-matching-input-from-input)
-    (local-leader
-      :keymaps 'eshell-mode-map
-      "c" (proc (interactive) (eshell/clear)
-                (recenter))
-      "k" #'eshell-kill-process))))
-#+end_src
-** Eshell pretty symbols and display
-Pretty symbols and a display record.
-#+begin_src emacs-lisp
-(use-package eshell
-  :defer t
-  :pretty
-  (eshell-mode-hook
-   ("lambda"  . "λ")
-   ("numberp" . "ℤ")
-   ("t"       . "⊨")
-   ("nil"     . "Ø"))
-  :display
-  ("\\*e?shell\\*" ; for general shells as well
-   (display-buffer-at-bottom)
-   (window-height . 0.33)))
-#+end_src
-** Eshell variables and aliases
-Set some sane defaults, a banner and a prompt.  The prompt checks for
-a git repo in the current directory and provides some extra
-information in that case (in particular, branch name and if there any
-changes that haven't been committed).
-
-#+begin_src emacs-lisp
-(use-package eshell
-  :defer t
-  :config
-  (defun +eshell/--git-get-remote-status ()
-    (let* ((branch-status (split-string
-                           (shell-command-to-string "git status | grep 'Your branch is'")))
-           (status (nth 3 branch-status))
-           (diff (cl-position "by" branch-status :test #'string=)))
-      (if (null diff)
-          (propertize "=" 'font-lock-face '(:foreground "green"))
-        (let ((n (nth (+ 1 diff) branch-status)))
-          (concat
-           (cond
-            ((string= status "ahead")
-             (propertize "→ " 'font-lock-face '(:foreground "dodger blue")))
-            ((string= status "behind")
-             (propertize "← " 'font-lock-face '(:foreground "orange red"))))
-           n)))))
-
-  (defun +eshell/--git-get-change-status ()
-    (let ((changed-files (- (length (split-string (shell-command-to-string "git status -s" ) "\n")) 1)))
-      (if (= changed-files 0)
-          (propertize "✓" 'font-lock-face '(:foreground "green"))
-        (propertize (number-to-string changed-files) 'font-lock-face '(:foreground "red")))))
-
-  (defun +eshell/get-git-properties ()
-    (let ((git-branch (shell-command-to-string "git branch")))
-      (if (or (string= git-branch "")
-             (not (string= "*" (substring git-branch 0 1))))
-          ""
-        (format
-         "(%s<%s>[%s])"
-         (nth 2 (split-string git-branch "\n\\|\\*\\| "))
-         (+eshell/--git-get-change-status)
-         (+eshell/--git-get-remote-status)))))
-
-  (defun +eshell/prompt-function ()
-    (let ((git (+eshell/get-git-properties)))
-      (mapconcat
-       (lambda (item)
-         (if (listp item)
-             (propertize (car item)
-                         'read-only t
-                         'font-lock-face (cdr item)
-                         'front-sticky   '(font-lock-face read-only)
-                         'rear-nonsticky '(font-lock-face read-only))
-           item))
-       (list
-        '("[")
-        `(,(abbreviate-file-name (eshell/pwd)) :foreground "LimeGreen")
-        '("]")
-        (if (string= git "")
-            ""
-          (concat "-" git ""))
-        "\n"
-        `(,(format-time-string "[%H:%M:%S]") :foreground "purple")
-        "\n"
-        '("𝜆> " :foreground "DeepSkyBlue")))))
-
-  (defun +eshell/banner-message ()
-    (concat (shell-command-to-string "~/.local/scripts/cowfortune")
-            "\n"))
-
-  (setq eshell-cmpl-ignore-case t
-        eshell-cd-on-directory t
-        eshell-banner-message '(+eshell/banner-message)
-        eshell-highlight-prompt nil
-        eshell-prompt-function #'+eshell/prompt-function
-        eshell-prompt-regexp "^𝜆> "))
-#+end_src
-** Eshell change directory quickly
-Add ~eshell/goto~, which is actually a command accessible from within
-eshell (this is because ~eshell/*~ creates an accessible function
-within eshell with name ~*~).  ~eshell/goto~ makes it easier to change
-directories by using Emacs' find-file interface (which is much faster
-than ~cd ..; ls -l~).
-
-~eshell/goto~ is a better ~cd~ for eshell.  However it is really just
-a plaster over a bigger issue for my workflow; many times I want
-eshell to be present in the current directory of the buffer I am
-using.  So here's also a command for opening eshell with the current
-directory.
-#+begin_src emacs-lisp
-(use-package eshell
-  :defer t
-  :general
-  (leader
-    "T" #'+eshell/current-buffer)
-  :config
-  (defun eshell/goto (&rest args)
-    "Use `read-directory-name' to change directories."
-    (eshell/cd (list (read-directory-name "Directory?: "))))
-
-  (defun eshell/project-root (&rest args)
-    "Change to directory `project-root'"
-    (if (project-current)
-        (eshell/cd (list (project-root (project-current))))
-      (eshell/echo (format "[%s]: No project in current directory"
-                           (propertize "Error" 'font-lock-face '(:foreground "red"))))))
-
-  (defun +eshell/current-buffer ()
-    (interactive)
-    (let  ((dir (if buffer-file-name
-                    (file-name-directory buffer-file-name)
-                  default-directory))
-           (buf (eshell)))
-      (if dir
-          (with-current-buffer buf
-            (eshell/cd dir)
-            (eshell-send-input))
-        (message "Could not switch eshell: buffer is not real file")))))
-#+end_src
-* WAIT Elfeed
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-Elfeed is the perfect RSS feed reader, integrated into Emacs
-perfectly.  I've got a set of feeds that I use for a large variety of
-stuff, mostly media and entertainment.  I've also bound "<leader> ar"
-to elfeed for loading the system.
-#+begin_src emacs-lisp
-(use-package elfeed
-  :general
-  (app-leader "r" #'elfeed)
-  (nmmap
-    :keymaps 'elfeed-search-mode-map
-    "gr"       #'elfeed-update
-    "s"        #'elfeed-search-live-filter
-    "<return>" #'elfeed-search-show-entry)
-  :init
-  (setq elfeed-db-directory (no-littering-expand-var-file-name "elfeed/"))
-
-  (setq +rss/feed-urls
-        '(("Arch Linux"
-           "https://www.archlinux.org/feeds/news/"
-           News Technology)
-          ("The Onion"
-           "https://www.theonion.com/rss"
-           Social)
-          ("Protesilaos Stavrou"
-           "https://www.youtube.com/@protesilaos"
-           YouTube Technology)
-          ("Tsoding Daily"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCrqM0Ym_NbK1fqeQG2VIohg"
-           YouTube Technology)
-          ("Tsoding"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCrqM0Ym_NbK1fqeQG2VIohg"
-           YouTube Technology)
-          ("Nexpo"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCpFFItkfZz1qz5PpHpqzYBw"
-           YouTube Stories)
-          ("3B1B"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCYO_jab_esuFRV4b17AJtAw"
-           YouTube)
-          ("Fredrik Knusden"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCbWcXB0PoqOsAvAdfzWMf0w"
-           YouTube Stories)
-          ("Barely Sociable"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UC9PIn6-XuRKZ5HmYeu46AIw"
-           YouTube Stories)
-          ("Atrocity Guide"
-           "https://www.youtube.com/feeds/videos.xml?channel_id=UCn8OYopT9e8tng-CGEWzfmw"
-           YouTube Stories)
-          ("Hacker News"
-           "https://news.ycombinator.com/rss"
-           Social News Technology)
-          ("Hacker Factor"
-           "https://www.hackerfactor.com/blog/index.php?/feeds/index.rss2"
-           Social)))
-  :config
-  (with-eval-after-load "evil-collection"
-    (evil-collection-elfeed-setup))
-
-  (setq elfeed-feeds (cl-map 'list #'(lambda (item)
-                                       (append (list (nth 1 item)) (cdr (cdr item))))
-                             +rss/feed-urls))
-
-  (advice-add  'elfeed-search-show-entry :after #'+elfeed/dispatch-entry)
-
-  (defun +elfeed/dispatch-entry (entry)
-    "Process each type of entry differently.
-  e.g., you may want to open HN entries in eww."
-    (let ((url (elfeed-entry-link entry)))
-      (pcase url
-        ((pred (string-match-p "https\\:\\/\\/www.youtube.com\\/watch"))
-         (mpv-play-url url))
-        (_ (eww url))))))
-#+end_src
-* Magit
-Magit is *the* git porcelain for Emacs, which perfectly encapsulates
-the git cli.  In this case I just need to setup the bindings for it.
-As magit will definitely load after evil (as it must be run by a
-binding, and evil will load after init), I can use evil-collection
-freely.  Also, define an auto insert for commit messages so that I
-don't need to write everything myself.
-
-#+begin_src emacs-lisp
-(use-package magit
-  :defer t
-  :display
-  ("magit:.*"
-   (display-buffer-same-window)
-   (inhibit-duplicate-buffer . t))
-  ("magit-diff:.*"
-   (display-buffer-below-selected))
-  ("magit-log:.*"
-   (display-buffer-same-window))
-  :general
-  (leader
-    "g" '(magit-dispatch :which-key "Magit"))
-  (code-leader
-    "b" #'magit-blame)
-  :auto-insert
-  (("COMMIT_EDITMSG" . "Commit skeleton")
-   ""
-   "(" (read-string "Enter feature/module: ") ")"
-   (read-string "Enter simple description: ") "\n\n")
-  :init
-  (setq vc-follow-symlinks t
-        magit-blame-echo-style 'lines
-        magit-copy-revision-abbreviated t)
-  :config
-  (with-eval-after-load "evil"
-    (evil-set-initial-state 'magit-status-mode 'motion))
-  (with-eval-after-load "evil-collection"
-    (evil-collection-magit-setup)))
-#+end_src
-* IBuffer
-IBuffer is the dired of buffers: providing the ability to mark
-buffers, mass rename/delete and just observe stuff.
-#+begin_src emacs-lisp
-(use-package ibuffer
-  :general
-  (buffer-leader
-    "i" #'ibuffer)
-  :config
-  (with-eval-after-load "evil-collection"
-    (evil-collection-ibuffer-setup)))
-#+end_src
-* Proced
-Emacs has two systems for process management:
-+ proced: a general 'top' like interface which allows general
-  management of linux processes
-+ list-processes: a specific Emacs based system that lists processes
-  spawned by Emacs (similar to a top for Emacs specifically)
-
-Core proced config, just a few bindings and evil collection setup.
-#+begin_src emacs-lisp
-(use-package proced
-  :straight nil
-  :general
-  (app-leader
-    "p" #'proced)
-  (nmap
-    :keymaps 'proced-mode-map
-    "za" #'proced-toggle-auto-update)
-  :display
-  ("\\*Proced\\*"
-   (display-buffer-at-bottom)
-   (window-height . 0.25))
-  :init
-  (setq proced-auto-update-interval 0.5)
-  :config
-  (with-eval-after-load "evil-collection"
-    (evil-collection-proced-setup)))
-#+end_src
-* Calculator
-Surprise, surprise Emacs comes with a calculator.
-
-Greater surprise, this thing is over powered.  It can perform the
-following (and more):
-- Matrix calculations
-- Generalised calculus operations
-- Equation solvers for n-degree multi-variable polynomials
-- Embedded mode (check below)!
-
-~calc-mode~ is a calculator system within Emacs that provides a
-diverse array of mathematical operations.  It uses reverse polish
-notation to do calculations (though there is a standard infix
-algebraic notation mode).
-
-Embedded mode allows computation with the current buffer as the echo
-area.  This basically means I can compute stuff within a buffer
-without invoking calc directly: $1 + 2\rightarrow_{\text{calc-embed}} 3$.
-
-#+begin_src emacs-lisp
-(use-package calc
-  :straight nil
-  :display
-  ("*Calculator*"
-   (display-buffer-at-bottom)
-   (window-height . 0.18))
-  :general
-  (app-leader
-    "c" #'calc-dispatch)
-  (mode-leader
-    "c" #'calc-embedded)
-  :init
-  (setq calc-algebraic-mode t)
-  :config
-  (with-eval-after-load "evil-collection"
-    (evil-collection-calc-setup)))
-#+end_src
-** WAIT Calctex
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-~calc-mode~ also has a 3rd party package called ~calctex~. It renders
-mathematical expressions within calc as if they were rendered in TeX.
-You can also copy the expressions in their TeX forms, which is pretty
-useful when writing a paper.  I've set a very specific lock on this
-repository as it's got quite a messy work-tree and this commit seems to
-work for me given the various TeX utilities installed via Arch.
-
-#+begin_src emacs-lisp
-(use-package calctex
-  :after calc
-  :straight (calctex :type git :host github :repo "johnbcoughlin/calctex")
-  :hook (calc-mode-hook . calctex-mode))
-#+end_src
-* WAIT Ledger
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-#+begin_src emacs-lisp
-(use-package ledger-mode
-  :defer t)
-
-(use-package evil-ledger
-  :after ledger-mode)
-#+end_src
-* Zone
-Of course Emacs has a cool screensaver software.
-
-#+begin_src emacs-lisp
-(use-package zone-matrix
-  :straight t
-  :commands (zone)
-  :general
-  (leader
-    "z" #'zone)
-  :init
-  (setq zone-programs
-        [zone-pgm-drip
-         zone-pgm-drip-fretfully
-         zone-pgm-martini-swan-dive
-         zone-pgm-stress
-         zone-pgm-random-life]))
-#+end_src
-* (Wo)man
-Man pages are the user manuals for most software on Linux.  Really
-useful when writing code for Un*x systems, though they can be very
-verbose.
-
-2023-08-17: `Man-notify-method' is the reason the `:display' record
-doesn't work here.  I think it's to do with how Man pages are rendered
-or something, but very annoying as it's a break from standards!
-#+begin_src emacs-lisp
-(use-package man
-  :demand t
-  :straight nil
-  :init
-  (setq Man-notify-method 'pushy)
-  :display
-  ("^\\*Man.*"
-   (display-buffer-reuse-mode-window display-buffer-same-window))
-  :general
-  (file-leader
-    "m" #'man) ;; kinda like "find man page"
-  (nmmap
-    :keymaps 'Man-mode-map
-    "RET" #'man-follow))
-#+end_src
-* WAIT gif-screencast
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-Little application that uses =gifsicle= to make essentially videos of
-Emacs.  Useful for demonstrating features.
-#+begin_src emacs-lisp
-(use-package gif-screencast
-  :straight t
-  :general
-  (app-leader
-    "x" #'gif-screencast-start-or-stop)
-  :init
-  (setq gif-screencast-output-directory (expand-file-name "~/Media/emacs/")))
-#+end_src
-* Image-mode
-Image mode, for viewing images.  Supports tons of formats, easy to use
-and integrates slickly into image-dired.  Of course,
-#+begin_src emacs-lisp
-(use-package image-mode
-  :straight nil
-  :general
-  (nmmap
-    :keymaps 'image-mode-map
-    "+" #'image-increase-size
-    "-" #'image-decrease-size
-    "p" #'image-animate
-    "P" #'image-animate-set-speed
-    "h" #'image-backward-hscroll
-    "j" #'image-next-line
-    "k" #'image-previous-line
-    "l" #'image-forward-hscroll))
-#+end_src
-* WAIT ERC
-:PROPERTIES:
-:header-args:emacs-lisp: :tangle no
-:END:
-#+begin_src emacs-lisp
-(use-package erc
-  :defer t
-  :init
-  (setq erc-server "irc.libera.chat"
-        erc-nick "oreodave"
-        erc-buffer-display "current"))
-#+end_src
-* MPV
-Basically a porcelain over mpv via the IPC interface.
-#+begin_src emacs-lisp
-(use-package mpv
-  :defer t
-  :straight t
-  :config
-  (with-eval-after-load "org"
-    (defun org-mpv-complete-link (&optional arg)
-      (replace-regexp-in-string
-       "file:" "mpv:"
-       (org-link-complete-file arg)
-       t t))
-    (org-link-set-parameters "mpv"
-                             :follow #'mpv-play :complete #'org-mpv-complete-link)))
-#+end_src