~moved config/*.org -> org/*.org

Also changed literate to for this change

1 files changed, 447 insertions, 0 deletions

diff --git a/doom.d/org/config.org b/doom.d/org/config.org
new file mode 100644
index 0000000..3b12709
--- /dev/null
+++ b/doom.d/org/config.org
@@ -0,0 +1,447 @@
+#+TITLE: Oreodave's Emacs configuration
+#+AUTHOR: Oreodave
+#+DESCRIPTION: My Doom Emacs configuration!
+
+* Preclude
+- This is my [[https://github.com/hlissner/doom-emacs][Doom Emacs]] configuration.
+- Use it for most of my code editing and development needs.
+- Incredibly versatile tool in my inventory.
+* Variables and Bootstrap config
+Bootstrap via literate and setting up basic variables.
+** Bootstrap
+Load the literate.el file to start parsing.
+#+BEGIN_SRC elisp
+(load (expand-file-name (concat doom-private-dir "bin/literate.el")))
+#+END_SRC
+** Doom Variables
+#+BEGIN_SRC elisp
+(after! core-keybinds
+  (setq doom-localleader-key ",")
+  (setq doom-theme 'doom-solarized-dark)
+  (setq doom-font (font-spec :family "Hack" :size 17)))
+#+END_SRC
+- Set the doom localleader to "," because it's faster
+- Using the font [[https://sourcefoundry.org/hack/][Hack]]
+** Other variables
+#+BEGIN_SRC elisp
+(setq completion-ignore-case t)
+(setq truncate-lines t)
+(setq display-line-numbers-type nil)
+(setq bookmark-default-file (expand-file-name (concat doom-private-dir "bookmarks")))
+(setq-default frame-title-format '("%b - Emacs"))
+(cl-pushnew '("Libgen" "http://gen.lib.rus.ec/search.php?req=%s") +lookup-provider-url-alist :key #'car :test 'string=)
+#+END_SRC
+Some quality of life things and others that I couldn't really put in one category
+- Displaying line numbers isn't usually something I do. If need be, I'll just
+  open them with *<SPC>tl*.
+- Set org directory
+- Add libgen to search providers
+* Package Config
+Config for or based heavily around specific packages that I find very important
+** DAP
+A keybind and a routine
+
+- Routine sets up the panes that I like to use, instead of having to M-x'ing it
+- *<SPC>cD* starts up the routine
+#+BEGIN_SRC elisp
+(after! dap-mode
+  (defun oreodave/debug ()
+    (interactive)
+    (dap-ui-mode)
+    (dap-ui-locals)
+    (dap-ui-sessions))
+  (map!
+   :leader
+   :desc "Start debugging setup" "cD" #'oreodave/debug))
+#+END_SRC
+** Elfeed
+Custom functions to work with elfeed, generating new feeds on demand and adding
+a keybind to help with that.
+#+BEGIN_SRC elisp
+(after! elfeed
+  (defun oreodave/elfeed/load-feeds ()
+    (interactive)
+    (setq elfeed-feeds nil)
+    (elfeed-load-opml (concat org-directory "/elfeed.opml")))
+
+  (defun oreodave/elfeed/on-new-feed ()
+    (interactive)
+    (elfeed-org-export-opml)
+    (write-file (concat org-directory "/elfeed.opml"))
+    (kill-current-buffer))
+
+  (map!
+   (:map elfeed-search-mode-map
+     :localleader
+     :desc "Update feeds" "u" #'elfeed-update)
+   (:leader
+     :prefix "o"
+     :desc "Open RSS"     "f" #'=rss))
+
+  (add-hook 'elfeed-org-new-entry-hook 'oreodave/elfeed/on-new-feed))
+#+END_SRC
+** Dashboard
+My very own dashboard config using doom dashboard, with these features:
+- Custom load message
+- Custom splash image and dashboard buffer name
+- Custom dashboard sections for myself
+#+BEGIN_SRC elisp
+(defun doom-display-benchmark-h (&optional return-p)
+  "Display a benchmark, showing number of packages and modules, and how quickly
+they were loaded at startup.
+
+If RETURN-P, return the message as a string instead of displaying it."
+  (funcall (if return-p #'format #'message)
+           "εmacs loaded %d packages, %d modules in %.03fs"
+           (- (length load-path) (length doom--initial-load-path))
+           (if doom-modules (hash-table-count doom-modules) 0)
+           (or doom-init-time
+               (setq doom-init-time
+                     (float-time (time-subtract (current-time) before-init-time))))))
+
+(setq fancy-splash-image "~/Pictures/space2.png") ; splash image
+(setq +doom-dashboard-name "*dashboard*")
+
+(setq +doom-dashboard-functions ; limit the dashboard items
+      '(doom-dashboard-widget-banner
+        doom-dashboard-widget-loaded
+        doom-dashboard-widget-shortmenu))
+
+(setq +doom-dashboard-menu-sections ; Set a specific amount of items
+      '(("Open org-agenda"
+         :icon (all-the-icons-octicon "calendar" :face 'font-lock-keyword-face)
+         :when (fboundp 'org-agenda)
+         :action org-agenda)
+        ("Check the weather"
+         :icon (all-the-icons-wicon "rain" :face 'font-lock-keyword-face)
+         :action oreodave/weather)
+        ("Jump to bookmark"
+         :icon (all-the-icons-octicon "bookmark" :face 'font-lock-keyword-face)
+         :action bookmark-jump)
+        ("Open private config"
+         :icon (all-the-icons-octicon "file-directory" :face 'font-lock-keyword-face)
+         :action oreodave/goto-dotfiles)))
+#+END_SRC
+- Space image comes from [[https://flaticon.com][website]]
+- Remove the Github link to the official Doom Emacs repository: it's in muscle memory
+  at this point.
+- Added my own menu items:
+  - Books
+  - Weather
+* Language Config
+Configuration for various languages which I feel can be useful
+** C-style languages
+Emacs doesn't have the full range of styles that I want, so lemme just do it myself.
+#+BEGIN_SRC elisp
+(after! cc-mode
+  (c-add-style
+   "user"
+   '((c-basic-offset . 2)
+     (c-comment-only-line-offset . 0)
+     (c-hanging-braces-alist (brace-list-open)
+                             (brace-entry-open)
+                             (substatement-open after)
+                             (block-close . c-snug-do-while)
+                             (arglist-cont-nonempty))
+     (c-cleanup-list brace-else-brace)
+     (c-offsets-alist
+      (statement-block-intro . +)
+      (knr-argdecl-intro . 0)
+      (substatement-open . 0)
+      (substatement-label . 0)
+      (access-label . 0)
+      (label . 0)
+      (statement-cont . +))))
+  (set-pretty-symbols!
+    '(c-mode c++-mode)
+    :return "return"
+    :or "||"
+    :and "&&"
+    :not "!"
+    :bool "bool"
+    :str "string"
+    :str "std::string"
+    :float "float"
+    :int "int"
+    :false "false"
+    :true "true"
+    :null "nullptr"))
+#+END_SRC
+** LSP
+Add lsp-ui-doc-mode to lsp-ui-mode: allows you to see documentation in a little
+VSCode style web-kit window.
+#+BEGIN_SRC elisp
+(after! lsp-ui
+  (add-hook 'lsp-ui-hook #'lsp-ui-doc-mode)
+  (setq lsp-ui-doc-position 'top))
+#+END_SRC
+** CSharp
+- I have custom installed the omnisharp roslyn executable, so I'd rather use
+  that
+#+BEGIN_SRC elisp
+(after! csharp-mode
+  (setq omnisharp-server-executable-path "~/Bin/repos/omnisharp-roslyn/run"))
+#+END_SRC
+*** Unit test over whole projects
+- Implemented my own function which piggy backs counsel etags to globally search
+  tags for test specific context, then goes to it and uses an omnisharp test
+  command to unit test it. Basically global test search in C# projects. To use
+  this, just make sure you have tags compiled and that all your tests are
+  written as some public void *name* _Test (i.e. they are appended with _Test so
+  that the pattern can be matched)
+#+BEGIN_SRC elisp
+(after! (csharp-mode counsel-etags)
+  (defun oreodave/csharp/get-unit-test-in-project ()
+    "Unit test anywhere using CTags or ETags and C#"
+    (interactive)
+    (let* ((tags-file (counsel-etags-locate-tags-file))
+           (cands (counsel-etags-collect-cands "void.*Test" t buffer-file-name)))
+      (ivy-read
+       "Choose test: "
+       cands
+       :action
+       (lambda (item)
+         ;; From the counsel-etags file-open-api function
+         (when (string-match "\\`\\(.*?\\):\\([0-9]+\\):\\(.*\\)\\'" item)
+           (let*
+               ((file (match-string-no-properties 1 item))
+                (linenum (match-string-no-properties 2 item))
+                ;; always calculate path relative to TAGS
+                (default-directory (counsel-etags-tags-file-directory)))
+
+             (counsel-etags-push-marker-stack (point-marker))
+             (find-file file)
+             (counsel-etags-forward-line linenum)
+             (omnisharp-unit-test-at-point))))
+       :caller 'oreodave/csharp/get-unit-tests-in-project))))
+#+END_SRC
+*** Redo omnisharp-emit-results
+- Reimplemented omnisharp-emit-results to emit stdout regardless of whether the
+  test failed or not
+#+BEGIN_SRC elisp
+(after! (csharp-mode omnisharp)
+  (defun omnisharp--unit-test-emit-results (passed results)
+    "Emits unit test results as returned by the server to the unit test result buffer.
+PASSED is t if all of the results have passed. RESULTS is a vector of status data for
+each of the unit tests ran."
+                                        ; we want to clean output buffer for result if things have passed otherwise
+                                        ; compilation & test run output is to be cleared and results shown only for brevity
+
+    (omnisharp--unit-test-message "")
+
+    (seq-doseq (result results)
+      (-let* (((&alist 'MethodName method-name
+                       'Outcome outcome
+                       'ErrorMessage error-message
+                       'ErrorStackTrace error-stack-trace
+                       'StandardOutput stdout
+                       'StanderError stderr) result)
+              (outcome-is-passed (string-equal "passed" outcome)))
+
+        (omnisharp--unit-test-message
+         (format "[%s] %s "
+                 (propertize
+                  (upcase outcome)
+                  'font-lock-face (if outcome-is-passed
+                                      '(:foreground "green" :weight bold)
+                                    '(:foreground "red" :weight bold)))
+                 (omnisharp--truncate-symbol-name method-name 76)))
+
+        (if error-stack-trace
+            (omnisharp--unit-test-message error-stack-trace))
+
+        (unless (= (seq-length stdout) 0)
+          (omnisharp--unit-test-message "Standard output:")
+          (seq-doseq (stdout-line stdout)
+            (omnisharp--unit-test-message stdout-line)))
+
+        (unless (= (seq-length stderr) 0)
+          (omnisharp--unit-test-message "Standard error:")
+          (seq-doseq (stderr-line stderr)
+            (omnisharp--unit-test-message stderr-line)))
+        ))
+
+    (omnisharp--unit-test-message "")
+
+    (if (eq passed :json-false)
+        (omnisharp--unit-test-message
+         (propertize "*** UNIT TEST RUN HAS FAILED ***"
+                     'font-lock-face '(:foreground "red" :weight bold)))
+      (omnisharp--unit-test-message
+       (propertize "*** UNIT TEST RUN HAS SUCCEEDED ***"
+                   'font-lock-face '(:foreground "green" :weight bold)))
+      )
+    nil))
+#+END_SRC
+*** Map for C# mode
+#+BEGIN_SRC elisp
+(after! csharp-mode
+  (map! ; CSharp Keybinds
+   :map csharp-mode-map
+   :localleader
+   :desc   "Format buffer"            "="    #'omnisharp-code-format-entire-file
+   (:prefix "t"
+     :desc "Select Test in Project"    "t"   #'oreodave/csharp/get-unit-test-in-project)))
+#+END_SRC
+** Python
+- I do python development for Python3, so I need to set the flycheck python checker, as well as the interpreter, to be Python3
+- Most of my python work is in scripts or ideas, so I don't need extensive testing utilities or anything like that
+- I run my python code a LOT and thus need commands for sending bits or whole scripts into the REPL
+#+BEGIN_SRC elisp
+(after! python
+  (setq python-version-checked t)
+  (setq python-python-command "python3")
+  (setq python-shell-interpreter "python3")
+  (setq flycheck-python-pycompile-executable "python3")
+
+  (map! ; Python keybinds
+   :map python-mode-map
+   :localleader
+   :desc "Start python minor" "c" #'run-python
+   :desc "Format buffer"      "=" #'py-yapf-buffer
+   (:prefix "s"
+     :desc "Send region REPL" "r" #'python-shell-send-region
+     :desc "Send buffer"      "b" #'python-shell-send-buffer
+     :desc "Send function"    "f" #'python-shell-send-defun)))
+#+END_SRC
+** TypeScript
+- Typescript (in my opinion) should be indented by 2
+- Setup the LSP server on the lsp-language-id-config in case it hasn't already
+#+BEGIN_SRC elisp
+(after! typescript-mode
+  (setq typescript-indent-level 2)
+  (setq tide-format-options '(:indentSize 2 :tabSize 2))
+  (after! lsp
+    (cl-pushnew '(typescript-mode . "typescript") lsp-language-id-configuration :key #'car)
+    (lsp-register-client
+     (make-lsp-client
+      :new-connection (lsp-stdio-connection "typescript-language-server --stdio")
+      :major-modes '(typescript-mode)
+      :server-id 'typescript))))
+#+END_SRC
+** Haskell
+#+BEGIN_SRC elisp
+(after! (haskell-mode dante)
+  (setq dante-repl-command-line '("stack" "ghci")))
+#+END_SRC
+** FSharp
+#+BEGIN_SRC elisp
+(after! fsharp
+  (setq inferior-fsharp-program "dotnet fsi --readline"))
+#+END_SRC
+* Keymap
+General keymap for leader
+** Personal
+- Prefix "SPC m" (rebound from local-leader) that will hold personal keybinds
+  for functions that I like using
+- Mostly opening directories I use a lot or doing custom stuff that I can't
+  really put in anything in particular
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :prefix ("m" . "personal") ; Personal
+ :desc   "Open books"         "b"     #'(lambda () (interactive) (dired (concat org-directory "/Books"))); I like my books
+ :desc   "Open school dir"    "s"     #'(lambda () (interactive) (dired (expand-file-name "~/School")))
+ :desc   "Open notes"         "n"     #'(lambda () (interactive) (dired org-directory))
+ :desc   "Open code"          "c"     #'(lambda () (interactive) (dired (expand-file-name "~/Code")))
+ :desc   "Open weather"       "w"     #'oreodave/weather
+ :desc   "Change theme"       "t"     #'oreodave/themes/set-new-theme ; From my own collection
+ :desc   "Generate template"  "g"     #'+gentemplate/generate-template ; From my own collection
+ (:after pdf-view
+   :desc "Goto page on pdf"   "p"     #'pdf-view-goto-page)
+ :desc   "Reload emacs"       "r"     #'oreodave/reload) ; Reload is necessary
+#+END_SRC
+** Counsel
+- Counsel keybind config
+- Mostly just convenience stuff that happens to use counsel
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :after counsel ; Counsel or ivy
+ :desc   "M-x"                "<SPC>" #'counsel-M-x ; Redefine as M-x because of my muscle memory with spacemacs
+ :desc   "Find file here"     "f."    #'counsel-find-file ; Sometimes use this instead of <SPC>ff
+ (:prefix ("s" . "search")
+   :desc "RipGrep!"           "r"     #'counsel-rg ; Ripgrep is faster than Ag in most cases and makes me feel cool
+   :desc "Search Tags"        "t"     #'counsel-etags-find-tag)); is quicker to do than <SPC>/b, for something that is done so often
+#+END_SRC
+** Window
+- Keybinds to do with windows
+- SPC wc < SPC wd
+- Some ace-window config in the window keybind prefix
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :prefix ("w" . "window") ; Windows
+ :desc "Close window"       "d"       #'+workspace/close-window-or-workspace ; is slightly closer together than <SPC>wc
+ :desc "Switch window"      "W"       #'ace-window ; is also used in spacemacs so I'd rather use this
+ :desc "Swap windows"       "S"       #'ace-swap-window) ; allows me to switch windows more efficiently than before, better than just motions
+#+END_SRC
+** Code
+- Some keybinds for the code prefix which help me with coding or working with
+  code, particularly LSP
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :prefix ("c" . "code") ; Code
+ :desc "Fold all in level"  "f"       #'hs-hide-level
+ :desc "Compile via make"   "C"       #'+make/run
+ (:after format-all
+   :desc "Format code"      "="       #'format-all-buffer)
+ (:after lsp
+   :desc "Execute action"   "a"       #'lsp-execute-code-action)
+ (:after dap-mode
+   :desc "Debug hydra"      "h"       #'dap-hydra))
+#+END_SRC
+** Projectile
+- Projectile config, for leader and for project prefix
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :after projectile
+ :desc   "Switch to p-buffer" ">"     #'projectile-switch-to-buffer ; Opposing <SPC>< which counsel's all buffers
+ (:prefix ("p" . "project")
+   :desc "Regen tags"         "g"     #'projectile-regenerate-tags
+   :desc "Open project files" "f"     #'projectile-find-file))
+#+END_SRC
+** Fonts
+- Fonts keybinds (prefix "z") for messing with fonts temp on a buffer
+- Really useful when I need to zoom into something for whatever reason
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :prefix ("z" . "font") ; Fonts
+ :desc "Increase font"  "+"           #'doom/increase-font-size
+ :desc "Decrease font"  "-"           #'doom/decrease-font-size
+ :desc "Adjust font"    "z"           #'text-scale-adjust)
+#+END_SRC
+** Frames
+- Keybinds for frame manipulation:
+  - Generate new frames from current buffer
+  - Generate new frames from a specific buffer
+  - Delete frames
+  - Switch frames
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :prefix ("F" . "frame") ; Frames
+ :desc "Kill frame"           "d"     #'delete-frame
+ :desc "Current buffer frame" "m"     #'make-frame
+ :desc "Choose Buffer frame"  "n"     #'display-buffer-other-frame
+ :desc "Switch frames"        "o"     #'other-frame)
+#+END_SRC
+** Other
+- Miscellaneous bindings that don't really fit into any particular item
+#+BEGIN_SRC elisp
+(map!
+ :leader
+ :desc   "Shell command"      "!"       #'shell-command ; Better than M-!
+ (:prefix ("b" . "buffers") ; Buffers
+   :desc "Close buffer"       "d"       #'doom/kill-this-buffer-in-all-windows)
+ (:prefix ("f" . "files")
+   :desc "Open dotfiles"      "p"       #'oreodave/goto-dotfiles)
+ (:prefix ("o" . "open")
+   :after org
+   :desc "Calendar"           "c"       #'=calendar)
+ (:prefix ("n" . "notes")
+   :desc "Open notes in dired" "-"      #'(lambda () (interactive) (dired org-directory))))
+#+END_SRC