dotfiles/doom.d/config.org

#+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, which I try to use for as many things as
possibe. It is currently my main C# and Python editor but hopefully it will
become my C one soon!
* Global variables
#+BEGIN_SRC elisp
(setq doom-localleader-key ",")
(setq warning-minimum-level :emergency)
(setq completion-ignore-case t)
(setq org-directory "~/Text")
(setq truncate-lines t)
(setq doom-font (font-spec :family "Fira Code" :size 18))
#+END_SRC
- '<SPC>m' is right next to ',', so may as well use one tap instead of two
- Projectile tags commands

* General keymap
#+BEGIN_SRC elisp
(map!
 :leader
 :desc   "M-x"                "<SPC>" 'counsel-M-x
 :desc   "Switch to p-buffer" ">"     'projectile-switch-to-buffer
 :desc   "Indent"             "j"     'indent-region
 :desc   "Reload emacs"       "r"     'oreodave/reload
 :desc   "Compile via make"   "cC"    '+make/run
                                        ; Redefine <SPC><SPC> as M-x rather than find-file because of my muscle memory with spacemacs
                                        ; General maps like <SPC>j for indenting because I don't know what else to bind them to
                                        ; <SPC>pf => project -> find file
 (:prefix "/" ; Search
   :after counsel
   :desc "Ag!"                "a"     '+ivy/ag
   :desc "FZF!"               "f"     'counsel-fzf
   :desc "RipGrep!"           "r"     'counsel-rg
   :desc "Search Tags"        "t"     'counsel-etags-find-tag
   :desc "List Tags"          "T"     'counsel-etags-list-tag
   :desc "Buffer Tags"        "s"     'counsel-imenu
   :desc "Search buffer"      "/"     'swiper
   )
                                        ; I like using <SPC>/ in comparison to <SPC>s: it's closer together (thus quicker, I do searches a lot so this is noticeable) and makes more sense
                                        ; Ripgrep is faster than Ag in most cases and makes me feel cool
                                        ; <SPC>// is quicker to do than <SPC>/b, for something that is done so often

 (:prefix "w" ; Windows
   :desc "Close window"       "d"     '+workspace/close-window-or-workspace
   :desc "Switch window"      "W"     'ace-window
   :desc "Swap windows"       "S"     'ace-swap-window
   )
                                        ; <SPC>wd is slightly closer together than <SPC>wc
                                        ; <SPC>wd is also used in spacemacs so I'd rather use this
                                        ; <SPC>wW allows me to switch windows more efficiently than before, better than just motions

 (:prefix "b"
   :desc "Close buffer"       "d"     'doom/kill-this-buffer-in-all-windows
   )
                                        ; <SPC>bd is used for the same reasons as above

 (:prefix "p"
   :after projectile
   :desc "Regen tags"         "g"     'projectile-regenerate-tags
   :desc "Open project files" "f"     'projectile-find-file
   )
 (:prefix "o"
   :after org
   :desc "Calendar"           "c"     '=calendar)
 )
; <SPC>pg for regenning tags is useful when searching them
#+END_SRC
* Custom
** Packages
*** Projectile
#+BEGIN_SRC elisp
(after! projectile
  (setq oreodave-tags-alist '("Makefile" "node_modules" "bin" "dist" "obj" "'*.json'"))
  (defun oreodave/config/construct-tags ()
    (reduce (lambda (x y) (concat x y)) (mapcar (lambda (i) (concat " --exclude=" i)) oreodave-tags-alist)
            :initial-value "exctags -Re ")
    )
  (setq projectile-tags-command (oreodave/config/construct-tags))
  )
#+END_SRC

Really simple, just want to set projectile-tags-command when projectile has
loaded, and easily add new ignores if necessary.
*** Wakatime
#+BEGIN_SRC elisp
(setq wakatime-api-key (shell-command-to-string "pass Keys/Wakatime"))
#+END_SRC
Using new password holder (pass) to help with secure transactions.
*** Elfeed
#+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)
  ;; (oreodave/elfeed/load-feeds)
  )
#+END_SRC
*** Dash
#+BEGIN_SRC elisp
(setq dash-docs-docsets-path "~/.docsets")
#+END_SRC
My docsets are stored in .docsets for ease of use
*** wttrin
#+BEGIN_SRC elisp
(after! wttrin
  (defun oreodave/weather ()
    (interactive)
    (wttrin (shell-command-to-string "pass location"))))
#+END_SRC
** Languages
*** C-style
#+BEGIN_SRC elisp
(after! cc-mode
  (add-hook! 'c-mode-hook '(lambda ()
                             (setq c-basic-offset 2))))
#+END_SRC
*** C#
#+BEGIN_SRC elisp
(after! csharp-mode
  (defun oreodave/csharp/get-unit-test-in-project ()
    (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)))

                      (when counsel-etags-debug
                        (message "counsel-etags-open-file-api called => dir=%s, linenum=%s, file=%s" dir linenum file))

                      (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)))

  (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)

  (setq omnisharp-server-executable-path "~/bin/omnisharp/run")
  (add-hook 'csharp-mode-hook '(lambda()
                                 (setq c-basic-offset 4)
                                 (c-set-style "java"))) ; Hook for csharp setting variables

  (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

- I have custom installed the omnisharp roslyn executable, so I'd rather use that
- C# code is better at 4 space indents, but I indent most of my C code at 2 space indents because it looks nicer :)
- Reimplemented omnisharp emit messages for stdout
- 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
*** Python
#+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
- I do python development for Python3 (who doesn't?), so I need to set the flycheck python checker, as well as the interpreter, to be Python3
- Python keybinds
- 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
*** JavaScript/TypeScript
#+BEGIN_SRC elisp
(after! typescript-mode
  (setq typescript-indent-level 2)
  (setq tide-format-options '(:indentSize 2 :tabSize 2))
  (map!
   :localleader
   :map typescript-mode-map
   :desc "Format code" "=" 'tide-format
   )
  )
#+END_SRC
- Typescript (in my opinion) should be indented by 2
- I like having one keybind to format a file, thus need to rebind
*** Org
#+BEGIN_SRC elisp
(after! org
  (add-hook 'org-mode-hook #'visual-line-mode)
  (remove-hook 'org-mode-hook #'auto-fill-mode)
  (map! ; Org keybinds
   :map org-mode-map
   (:localleader
     :desc "Org dispatch"      "e" #'org-export-dispatch
     :desc "Export to ODT"     "E"  #'org-pandoc-export-to-odt
     (:prefix ("n" . "+narrow")
       :desc "Narrow to subtree" "n" #'org-narrow-to-subtree
       :desc "Go out of narrow"  "o" #'widen))
  ))
#+END_SRC
I like using the org dispatch facilities more than the default export keybinds
in Doom, so I need this binding
** Meta/Custom other stuff
*** Code
#+BEGIN_SRC elisp
(map!
 :leader
 :prefix "c"
 :desc "Fold all in level"  "f" 'hs-hide-level
 (:after format-all
   :desc "Format code universally" "=" 'format-all-buffer)
 )
#+END_SRC
*** Books
#+BEGIN_SRC elisp
(map!
 :leader
 :desc "Open folder" "B" '(lambda () (interactive) (dired "~/Text/Books"))
 )
#+END_SRC
*** Download Items
#+BEGIN_SRC elisp
(defun oreodave/request-json-fn (url)
  (set-process-sentinel
   (start-process-shell-command "request-json" "*request-json*" (format "curl %s" url))
   (lambda (process event)
     (when (memq (process-status process) '(exit stop))
       (message "Request finished")
       (with-current-buffer "*request-json*"
         (json-mode)
         (json-mode-beautify))))))

(defun oreodave/request-json ()
  (interactive)
  (oreodave/request-json-fn (read-string "Enter url: "))
  )
#+END_SRC
Download JSON easily and be able to get responses quickly.
*** Themes
#+BEGIN_SRC elisp
(setq oreodave/aesthetics/list '(doom-molokai doom-peacock doom-solarized-dark))
(setq oreodave/aesthetics/index 2)
(load-theme (nth oreodave/aesthetics/index oreodave/aesthetics/list))

(defun oreodave/aesthetics/next-theme ()
  (interactive)
  (cond ((= 2 oreodave/aesthetics/index) (setq oreodave/aesthetics/index 0))
        (t (setq oreodave/aesthetics/index (+ oreodave/aesthetics/index 1))))
  (load-theme (nth oreodave/aesthetics/index oreodave/aesthetics/list)))

(map!
 :leader
 :prefix ("a" . "+aesthetics")
 :desc "Load themes"        "a" 'load-theme
 :desc "Next default theme" "n" 'oreodave/aesthetics/next-theme
 )
#+END_SRC
- I want to have similar functionality to spacemacs: a way to switch themes
  easily and quickly
*** Frame management
#+BEGIN_SRC elisp
(map!
 :leader
 :prefix ("F" . "Frame") ; Literally the first free prefix I could think of
 :desc "Kill frame"                  "d" 'delete-frame
 :desc "Make current buffer frame"   "m" 'make-frame
 :desc "Choose buffer to make frame" "n" 'display-buffer-other-frame
 :desc "Switch frames"               "o" 'other-frame
 )
#+END_SRC
- This is my config for handling new frames
- I've only recently found out about them, they're incredibly powerful tools
  that I should've put in my toolbox a LONG time ago
*** Font size
#+BEGIN_SRC elisp
(map!
 :leader
 :prefix ("z" . "Font") ; using this prefix due to spacemacs
 :desc "Increase font"  "+" 'doom/increase-font-size
 :desc "Decreease font" "-" 'doom/decrease-font-size
 :desc "Adjust font"    "z" 'text-scale-adjust
 )
#+END_SRC
*** Custom functions
#+BEGIN_SRC elisp
(defun oreodave/reload ()
  (interactive)
  (load-file (concat doom-private-dir "config.el"))
  )
#+END_SRC