* Emacs Config
** Font
Set the font to something nice that will display ligntures
#+BEGIN_SRC emacs-lisp
(add-to-list 'default-frame-alist '(font . "Fira Code 12"))
(set-face-attribute 'default t :font "Fira Code 12")
#+END_SRC

** Customize file
Makes it so the customize data isn't schlunked in my init.el
#+BEGIN_SRC emacs-lisp
(setq custom-file (concat user-emacs-directory "_customize.el"))
(load custom-file t)
#+END_SRC

** Remove menu bar
Disable the useless cruft at the top of the screen   
#+BEGIN_SRC emacs-lisp
(menu-bar-mode 0)
(tool-bar-mode 0)
(scroll-bar-mode -1)
#+END_SRC
   
** Show matching parenthesis
Shows matching parenthesis  
#+BEGIN_SRC emacs-lisp
(require 'paren)
(setq show-paren-delay 0)
(show-paren-mode)
#+END_SRC
   
** Show columns
#+BEGIN_SRC emacs-lisp
(setq column-number-mode t)
#+END_SRC
      
** Transparency
Sets the window's transparency.  
The first number in the alpha section applies when the window is
active, the second when it's inactive.
#+BEGIN_SRC emacs-lisp
(set-frame-parameter (selected-frame) 'alpha 85)
(add-to-list 'default-frame-alist '(alpha . 85))
#+END_SRC
    
** Scrolling
#+BEGIN_SRC emacs-lisp
(setq scroll-conservatively 100) ;; don't scroll a metric boatload when bottom is hit
#+END_SRC

** Disable bell
Shut up, emacs.
#+BEGIN_SRC emacs-lisp
(setq ring-bell-function 'ignore)
#+END_SRC
   
** Relative line numbers
Use the default emacs relative line numbers, but switch to absolute lines when in insert mode.
#+BEGIN_SRC emacs-lisp
(setq linum-format " %3d ")
(setq-default display-line-numbers 'relative
              display-line-numbers-widen t
              display-line-numbers-current-absolute t)

(defun foltz-relative-numbers ()
    (setq-local display-line-numbers 'relative))

(defun foltz-absolute-numbers ()
    (setq-local display-line-numbers t))

(add-hook 'evil-insert-state-entry-hook #'foltz-absolute-numbers)
(add-hook 'evil-insert-state-exit-hook #'foltz-relative-numbers)

(global-display-line-numbers-mode t)
#+END_SRC

** y or n prompts
Make yes-or-no prompts ask for y or n instead
#+BEGIN_SRC emacs-lisp
(defalias 'yes-or-no-p 'y-or-n-p)
#+END_SRC
   
** Tabs are spaces?!
#+BEGIN_SRC emacs-lisp
(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
(setq indent-line-function 'insert-tab)
#+END_SRC
   
** Keep backup files and lockfiles out of the way
By default, emacs makes files like =file~= and =#file#= and clutters up
my projects. Instead, store them in =/tmp=!
#+BEGIN_SRC emacs-lisp
(setq backup-directory-alist
    `((".*" . ,temporary-file-directory)))
(setq auto-save-file-name-transforms
    `((".*" ,temporary-file-directory t)))
(setq create-lockfiles nil)
#+END_SRC
** Customize the terminal
Use fish shell in ansi-term
#+BEGIN_SRC emacs-lisp
(defadvice ansi-term (before force-bash)
    (interactive '("/usr/bin/fish")))
(ad-activate 'ansi-term)
#+END_SRC

** Theme
#+BEGIN_SRC emacs-lisp
(defvar foltz-wal-theme-path "~/.cache/wal/colors.el")
(defun foltz-apply-theme ()
    (interactive)
    (load-file foltz-wal-theme-path))

(defun foltz-theme-callback (event)
  (foltz-apply-theme))

(if (file-exists-p foltz-wal-theme-path)
    (progn
       (require 'filenotify)
       (file-notify-add-watch foltz-wal-theme-path '(change) 'foltz-theme-callback)
       (foltz-apply-theme))
    (load-theme spacemacs-dark))
#+END_SRC
** Auth storage location
Set stored auth tokens to be encrypted into emacs directory
#+BEGIN_SRC emacs-lisp
(setq auth-sources '("~/.emacs.d/authinfo.gpg"))
#+END_SRC

* Package Repo Config
** Repo Location
Let's start by configuring the repositories
#+BEGIN_SRC emacs-lisp
    (require 'package)

    (setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                             ("marmalade" . "https://marmalade-repo.org/packages/")
                             ("melpa-stable" . "https://stable.melpa.org/packages/")
                             ("melpa" . "https://melpa.org/packages/")
                             ("org" . "https://orgmode.org/elpa/")))
    (setq package-enable-at-startup nil)
    
    (package-initialize)
#+END_SRC

** use-package
use-package for installing packages
https://github.com/jwiegley/use-package
#+BEGIN_SRC emacs-lisp
(unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))

(eval-when-compile
    (require 'use-package))

(setq use-package-compute-statistics t)
(setq use-package-always-ensure t)
(setq use-package-always-pin "melpa-stable")
(setq use-package-verbose t)
#+END_SRC

* General Packages Configuration
** Modeline cleanup
Adds support for =:diminish= in use-package declarations,
basically hides a mode from the modeline.
#+BEGIN_SRC emacs-lisp
(use-package diminish)
#+END_SRC

** Keybind completion
Pops up a buffer that helps you navigate and complete commands
#+BEGIN_SRC emacs-lisp
(use-package which-key
    :diminish
    :config
    (which-key-mode))
#+END_SRC

** Keybind Manager
General manages my keybindings.

#+BEGIN_SRC emacs-lisp
(use-package general
    :pin melpa)
#+END_SRC

*** Leader definitions
Create a leader key, like the \ in vim.
In this case, =SPC= is used as a leader. Following the leader,
different buttons bring you to different options.
See [[https://github.com/noctuid/general.el#which-key-integration][here]] for which-key integration information

#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-leader-def
    :keymaps 'override
    :states 'normal
    :prefix "SPC"
        "m" '(:ignore t :which-key "major-mode...")
        "o" '(:ignore t :which-key "org-mode...")
        "p" '(:ignore t :which-key "projectile-mode...")
        "g" '(:ignore t :which-key "git...")
        "h" '(:ignore t :which-key "help...")
        "b" '(:ignore t :which-key "buffer...")
        "w" '(:ignore t :which-key "window...")
        "f" '(:ignore t :which-key "file..."))
#+END_SRC

**** m - major-modes
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-major-def
    :states 'normal
    :prefix "SPC m")
#+END_SRC

**** o - org-mode
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-org-def
    :keymaps 'override
    :states
'normal
    :prefix "SPC o")
#+END_SRC

**** p - projectile-mode
Since we will be binding the entire projectile-mode
keymap to this, we don't actually need a definer.
**** g - git
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-git-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC g")
#+END_SRC

**** h - help
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-help-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC h")

(foltz-help-def
    "?" 'help-for-help
    "h" 'help-for-help
    "k" 'describe-key)
#+END_SRC

**** b - buffer
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-buffer-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC b")

(foltz-buffer-def
    "i" 'ibuffer)
#+END_SRC

**** w - window
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-window-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC w")

(foltz-window-def
    "o" 'delete-other-windows)
#+END_SRC

**** f - file
#+BEGIN_SRC emacs-lisp
(general-create-definer foltz-file-def
    :states 'normal
    :keymaps 'override
    :prefix "SPC f")

(defun foltz-config-visit ()
    (interactive)
    (find-file (concat user-emacs-directory "config.org")))

(defun foltz-config-reload ()
    (interactive)
    (org-babel-load-file
        (expand-file-name "config.org" user-emacs-directory)))

(foltz-file-def
    "w"   'save-buffer
    "r"   'revert-buffer
    "e"   '(:ignore t :which-key "emacs files")
    "e e" 'foltz-config-visit
    "e r" 'foltz-config-reload) 
#+END_SRC

** Vim
Evil is pretty much the entirety of Vim in Emacs.
[[https://github.com/Somelauw/evil-org-mode][evil-org]] adds nice bindings to org-mode.

#+BEGIN_SRC emacs-lisp
(use-package evil
    :after general
    :diminish undo-tree-mode
    :init
    (setq evil-want-integration nil)
    (setq evil-want-keybinding nil)

    :config
    (evil-mode t)

    :custom
    (evil-shift-width 4 "Set indent to 4 spaces"))

(use-package evil-leader
    :after evil
    :init
    (defun foltz-window-split ()
        (interactive)
        (evil-window-split)
        (evil-window-down 1))
    (defun foltz-window-vsplit ()
        (interactive)
        (evil-window-vsplit)
        (evil-window-right 1))

    :general
    (:keymaps 'override
     :states 'normal
     "U" 'undo-tree-visualize)
    (foltz-window-def
        "-" 'foltz-window-split
        "=" 'foltz-window-vsplit
        "h" 'evil-window-left
        "j" 'evil-window-down
        "k" 'evil-window-up
        "l" 'evil-window-right
        "H" 'evil-window-far-left
        "J" 'evil-window-move-very-bottom
        "K" 'evil-window-move-very-top
        "L" 'evil-window-far-right
        "<" 'evil-window-decrease-width
        ">" 'evil-window-increase-width
        "^" 'evil-window-decrease-height
        "%" 'evil-window-increase-height
        "n" 'evil-window-new
        "c" 'evil-window-delete
        "w" 'evil-window-next
        "W" 'evil-window-prev
        "r" 'evil-window-rotate-downwards
        "|" 'evil-window-set-width
        "_" 'evil-window-set-height)

    :config
    (global-evil-leader-mode))

(use-package evil-org
    :after (evil org)
    :hook (org-mode . evil-org-mode)
    :config
    (add-hook 'evil-org-mode (lambda () 
        (evil-org-set-key-theme
            '(textobjects insert navigation 
              additional shift todo calendar)))))
#+END_SRC

** Startup dashboard
Show a cool custom buffer on startup
#+BEGIN_SRC emacs-lisp
(use-package dashboard
    :diminish page-break-lines-mode

    :config
    (dashboard-setup-startup-hook)
    (setq initial-buffer-choice (lambda () (get-buffer "*dashboard*")))

    :custom
    (dashboard-startup-banner 'logo)
    (dashboard-banner-logo-title "Welcome to Electronic Macs")
    (dashboard-items
        '((recents . 5)
          (agenda)
          (bookmarks . 5)
          (registers . 5))))
#+END_SRC

** Folder tree
A cool toggleable directory structure sidebar
It also needs icon fonts, installed with =M-x all-the-icons-install-fonts=
#+BEGIN_SRC emacs-lisp
(use-package all-the-icons)
(use-package neotree
    :after all-the-icons
    :commands neotree-toggle
    :general
    (:keymaps 'neotree-mode-map
     :states 'normal
     "RET" 'neotree-enter
     "TAB" 'neotree-quick-look
     "q"   'neotree-hide
     "g"   'neotree-refresh
     "A"   'neotree-stretch-toggle
     "H"   'neotree-hidden-file-toggle)
    (foltz-leader-def
        :states 'normal
        "t" 'neotree-toggle)
    :custom
    (neo-theme (if (display-graphic-p) 'icons 'arrow)))
#+END_SRC
** Organization
*** Capture Templates
All of my capture templates, from tasks to bookmarks.
**** Refile Targets
Goodize the refiling targets to allow moving to subtrees
#+BEGIN_SRC emacs-lisp
(defun foltz-org-capture-refile ()
    (interactive)
    (setq-local org-refile-targets '((nil :maxlevel . 5)))
    (setq-local org-refile-use-outline-path t)
    (org-refile))
#+END_SRC

**** Tasks
#+BEGIN_SRC emacs-lisp
(setq foltz-org-capture-task-templates 
  '(("t" "Todo")
    ("tg" "General" entry
        (file+headline "notes.org" "Todo")
        "** TODO %^{todo}\nNotes: %?\n")
    ("tt" "General (Date)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^t\nNotes: %?\n")
    ("tT" "General (Date+Time)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^T\nNotes: %?\n")
    ("ts" "School (Date)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^t\nClass: %^{class}\nNotes: %?\n")
    ("tS" "School (Date+Time)" entry
        (file+olp+datetree "notes.org")
        "*** TODO %^{todo}\nDue: %^T\nClass: %^{class}\nNotes: %?\n")))
#+END_SRC

**** Bookmarks
#+BEGIN_SRC emacs-lisp
(setq foltz-org-capture-bookmark-templates 
  '(("b" "Bookmark" entry
        (file+headline "links.org" "Unsorted Links")
        "** [[%^{link}][%^{name}]]\nCreated: %U\nAbout: %^{description}%?\n")))
#+END_SRC
    
**** Personal
#+BEGIN_SRC emacs-lisp
(setq foltz-org-capture-personal-templates 
  '(("j" "Journal")
    ("jj" "Journal Entry" entry
        (file+olp+datetree "journal.org")
        "**** Today's Events\n%?")
    ("jt" "Thoughts" entry
        (file+headline "notes.org" "Thoughts")
        "** %^{summary}\n%U\n%?")
    ("jd" "Dream Journal Entry" entry
        (file+olp+datetree "dreams.org")
        "**** Dream\n%?")))
#+END_SRC

**** Protocol
#+BEGIN_SRC emacs-lisp
(setq foltz-org-capture-protocol-templates 
    '(("w" "Website" entry
        (file+headline "sites.org" "Unsorted Sites")
        "** [[%:link][%:description%?]]\nCreated: %U\nAbout: %^{description}%?\n%:initial")))
#+END_SRC

**** All
Tie it all together.
#+BEGIN_SRC emacs-lisp
(setq foltz-org-capture-templates
    (append
        foltz-org-capture-task-templates
        foltz-org-capture-personal-templates
        foltz-org-capture-bookmark-templates
        foltz-org-capture-protocol-templates))
#+END_SRC

*** Structure Templates
Defines expansions with =<= followed by a string in org-mode.
**** Source Blocks
#+BEGIN_SRC emacs-lisp
(setq foltz-org-source-structure-templates '(
    ("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC")))
#+END_SRC

**** All
Tie it all together.
#+BEGIN_SRC emacs-lisp
(setq foltz-org-structure-templates
    (append
        foltz-org-source-structure-templates))
#+END_SRC

*** Org-mode
Keep org-mode up to date straight from the cow's utters.
If the manual is not on your computer, it's [[https://orgmode.org/manual/][here]].
#+BEGIN_SRC emacs-lisp
(use-package org
    :pin org
    :mode ("\\.org\\'" . org-mode)
    :hook ((org-mode . org-indent-mode)
           (org-capture-mode . evil-insert-state))

    :general
    (foltz-major-def
        :keymaps 'org-mode-map
        "e" 'org-export-dispatch
        "a" 'org-attach)
    (foltz-org-def
        "a" 'org-agenda
        "c" 'org-capture
        "l" 'org-store-link
        "b" 'org-switchb
        "r" 'foltz-org-capture-refile)
    
    :custom
    (org-directory "~/Documents/org")
    (org-agenda-files '("~/Documents/org/"))
    (org-default-notes-file "notes.org")
    (org-agenda-include-diary t)
    (org-src-window-setup 'current-window "Edit source code in the current window")
    (org-src-fontify-natively t "Highlight syntax in source blocks")
    (org-latex-to-pdf-process '("latexmk -f pdf %f") "Use pdflatex for export")
    (org-capture-templates foltz-org-capture-templates)
    (org-structure-template-alist (append org-structure-template-alist foltz-org-structure-templates)))
#+END_SRC

*** Pretty org-mode bullets
Make bullets look choice
#+BEGIN_SRC emacs-lisp
(use-package org-bullets
    :hook (org-mode . org-bullets-mode))
#+END_SRC

** Fuzzy Matching
Ivy, swiper, and counsel all provide fuzzy-matching on different
emacs operations.
#+BEGIN_SRC emacs-lisp
(use-package ivy
    :init
    ; Define some functions to bind to
    (defun foltz-kill-curr-buffer ()
        (interactive)
        (kill-buffer (current-buffer)))
    (defun foltz-kill-all-buffers ()
        (interactive)
        (mapc 'kill-buffer (buffer-list)))

    :general
    (foltz-buffer-def
        "b" 'ivy-switch-buffer
        "v" 'ivy-push-view
        "V" 'ivy-pop-view
        "c" 'foltz-kill-curr-buffer
        "C" 'foltz-kill-all-buffers)
    (:keymaps 'org-capture-mode-map
     :states 'normal
     "C-c C-w" 'foltz-org-capture-refile)

    :custom
    (ivy-use-virtual-buffers t)
    (ivy-count-format "%d/%d"))

(use-package swiper
    :after evil
    :general
    (:keymaps 'override 
     :states 'normal 
     "/" 'swiper
     "n" 'evil-search-previous
     "N" 'evil-search-next))

(use-package counsel
    :general
    ("M-x" 'counsel-M-x)
    (foltz-leader-def
        :states 'normal
        "x" 'counsel-M-x)
    (foltz-file-def
        "f" 'counsel-find-file)
    (foltz-help-def
        "k" 'counsel-descbinds
        "f" 'counsel-describe-function
        "v" 'counsel-describe-variable
        "l" 'counsel-find-library
        "a" 'counsel-apropos
        "s" 'counsel-info-lookup-symbol
        "u" 'counsel-unicode-char))
#+END_SRC

** Avy
Hotkeys for jumping to characters with =f=
#+BEGIN_SRC emacs-lisp
(use-package avy
    :general
    (:keymaps 'override
     :states 'normal
     "f" 'avy-goto-char-in-line
     "F" 'avy-goto-char))
#+END_SRC

* Programming Packages Configuration
** Autocomplete and Formatting
*** Company
company auto-completes stuff in the buffer,
company-quickhelp shows documentation popups
when idling on a completion candidate.
#+BEGIN_SRC emacs-lisp
(use-package company
    :init
    (defun foltz-company-backend-with-yas (backend)
        (if (and (listp backend) (member 'company-yasnippet backend))
            backend
            (append
                (if (consp backend)
                    backend
                    (list backend))
                '(:with company-yasnippet))))
    (defun foltz-add-company-backend (backend)
        (let ((backend-with-yas (foltz-company-backend-with-yas backend)))
        (if (member backend-with-yas company-backends)
            backend
            (add-to-list 'company-backends backend-with-yas))))
    :hook (prog-mode . company-mode)
    :hook (cdlatex-mode . company-mode)
    :general
    (:keymaps 'company-active-map
     "C-SPC" 'company-abort)
    :custom
    (company-maximum-prefix-length 2)
    (company-idle-delay 0.2 "Decrease idle delay"))
    
(use-package company-quickhelp
    :hook (company-mode . company-quickhelp-mode))
#+END_SRC
*** Smart Parentheses
smartparens handles parens for languages that aren't lispy,
and paredit handles the rest.
Keybinds in =M-x sp-cheat-sheet=.
#+BEGIN_SRC emacs-lisp
(use-package paredit
    :diminish
    :commands enable-paredit-mode)
     
(use-package smartparens
    :diminish
    :commands smartparens-strict-mode
    :config
    (require 'smartparens-config))

(use-package evil-smartparens
    :hook (smartparens-enabled . evil-smartparens-mode))
#+END_SRC
*** Smart Parentheses Modes
Picks a suitable parenthesis editing mode for the 
current major mode when entering any prog-mode.
#+BEGIN_SRC emacs-lisp
(defun foltz-paren-mode ()
    (if (member major-mode 
          '(emacs-lisp-mode
            lisp-mode
            lisp-interaction-mode
            scheme-mode))
        (enable-paredit-mode)
        (smartparens-strict-mode)))

(add-hook 'prog-mode-hook #'foltz-paren-mode)
#+END_SRC
*** evil-surround
Use =S= and a delimiter to surround in visual mode.
#+BEGIN_SRC emacs-lisp
(use-package evil-surround
    :after evil
    :diminish
    :config
    (global-evil-surround-mode 1))
#+END_SRC
*** ws-butler
Unobtrusively cleans up whitespace before EOLs 
as you edit, stopping the noisy commits generated 
from blanket trimming entire files.
#+BEGIN_SRC emacs-lisp
(use-package ws-butler
    :hook (prog-mode . ws-butler-mode))
#+END_SRC
** Prettification
*** pretty-mode
[[https://github.com/pretty-mode/pretty-mode][Redisplay parts of the Emacs buffer as pretty symbols.]]
#+BEGIN_SRC emacs-lisp
(use-package pretty-mode
    :hook (prog-mode . pretty-mode)
    :config
    (pretty-deactivate-groups
        '(:equality :sub-and-superscripts))
    (pretty-activate-groups
        '(:greek :arithmetic-nary
          :ordering :ordering-double :ordering-triple
          :arrows :arrows-twoheaded :punctuation :logic :sets)))
#+END_SRC

*** prettify-symbols-mode
Built into emacs since 24.1
#+BEGIN_SRC emacs-lisp
(add-hook 'python-mode-hook 'prettify-symbols-mode)
(add-hook 'python-mode-hook (lambda ()
    (mapc (lambda (pair) (push pair prettify-symbols-alist))
        '(;; Syntax
         ("in" .       #x2208)
         ("not in" .   #x2209)
         ("return" .   #x27fc)
         ("yield" .    #x27fb)
         ("for" .      #x2200)
         ;; Base Types
         ("int" .      #x2124)
         ("float" .    #x211d)
         ("str" .      #x1d54a)
         ("True" .     #x1d54b)
         ("False" .    #x1d53d)))))
#+END_SRC

** Debugging and Disassembly
*** Realgud
[[https://github.com/realgud/realgud][Realgud]] is a modular frontend for many debuggers
#+BEGIN_SRC emacs-lisp
(use-package realgud
    :commands 
    (realgud:gdb 
     realgud:lldb 
     realgud:node-inspect 
     realgud:pdb 
     realgud:trepan3k))
#+END_SRC
*** RMSBolt
#+BEGIN_SRC emacs-lisp
(use-package rmsbolt
    :pin melpa
    :commands rmsbolt-mode)
#+END_SRC
** Syntax checking
*** Flycheck
Flycheck does syntax highlighting in a few languages
#+BEGIN_SRC emacs-lisp
(use-package flycheck
    :hook (prog-mode . flycheck-mode))
#+END_SRC

*** Column 80 Highlight
Add a hotkey for highlighting column 80
and activate it in =prog-mode=
#+BEGIN_SRC emacs-lisp
(use-package fill-column-indicator
    :init
    (setq fci-rule-use-dashes t)
    (setq fci-rule-column 80)
    :general
    (foltz-major-def
        :keymaps 'prog-mode-map
        "l" 'fci-mode))
#+END_SRC

** Snippets
Yasnippet adds support for custom snippets
#+BEGIN_SRC emacs-lisp
(use-package yasnippet
    :commands yas-minor-mode
    :hook (prog-mode . yas-minor-mode)
    :custom
    (yas-snippet-dirs
      '("~/.emacs.d/snippets"
        "~/.emacs.d/elpa/yasnippet-snippets-0.6/snippets")))
;;;(use-package yasnippet-snippets)
#+END_SRC

** Git
*** magit
It's magic git!
Keybinds [[https://github.com/emacs-evil/evil-magit][here]]
#+BEGIN_SRC emacs-lisp
(use-package magit
    :general
    (foltz-git-def
        "s" 'magit-status
        "c" 'magit-commit
        "d" 'magit-diff
        "g" 'magit-grep)
    :config
    (use-package evil-magit
        :after evil))
#+END_SRC
*** magithub
Magic GitHub facilities for magit!
#+BEGIN_SRC emacs-lisp
(use-package magithub
    :after magit
    :config
    (magithub-feature-autoinject t)
    :custom
    (magithub-clone-default-directory "~/Documents/dev"))
#+END_SRC
** Projects
Projectile provides project-level features like
make shortcuts and file switching
#+BEGIN_SRC emacs-lisp
(use-package projectile
    :init
    (defun foltz-projectile-neotree () "Open NeoTree in the project root"
        (interactive)
        (let
            ((project-dir (projectile-project-root))
             (file-name   (buffer-file-name)))
        (neotree-toggle)
        (if project-dir
            (if (neo-global--window-exists-p)
                (progn
                    (neotree-dir project-dir)
                    (neotree-find file-name))))))

    :general
    (:keymaps 'projectile-command-map
     "t" 'foltz-projectile-neotree)
    (foltz-leader-def
        :states 'normal
        "p" '(:keymap projectile-command-map))
    :custom
    (projectile-project-search-path '("~/Documents/dev")))
#+END_SRC
** Languages
*** Fish
Beter editing of scripts for the fish shell
#+BEGIN_SRC emacs-lisp
(use-package fish-mode
    :mode "\\.fish\\'")
#+END_SRC
*** Markdown
#+BEGIN_SRC emacs-lisp
(use-package markdown-mode
    :mode "\\.md\\'")
#+END_SRC

*** Python
Jedi for autocompletion sources
#+BEGIN_SRC emacs-lisp
(use-package company-jedi
    :init
    (defun foltz-add-company-python-backend ()
        (foltz-add-company-backend 'company-jedi))
    :hook (python-mode . foltz-add-company-python-backend))
#+END_SRC

*** Javascript
[[https://github.com/mooz/js2-mode][js2-mode]] improves the default js mode. Keybindings in [[https://github.com/emacs-evil/evil-collection/blob/master/evil-collection-js2-mode.el][this file]].
#+BEGIN_SRC emacs-lisp
(use-package js2-mode
    :mode "\\.js\\'"
    :interpreter "node")
#+END_SRC

*** Web-dev
Web-mode should give everything you need for a web-dev major mode.
Company integration is done with company-web

#+BEGIN_SRC emacs-lisp
(use-package web-mode
    :pin melpa
    :mode ("\\.html\\'"
           "\\.php\\'"
           "\\.blade\\.")
    :custom
    (web-mode-code-indent-offset 4)
    (web-mode-indent-style 4))
    
(use-package company-web
    :init
    (defun foltz-add-company-web-backend ()
        (foltz-add-company-backend 'company-web))
    :hook (web-mode . foltz-add-company-web-backend))
#+END_SRC

*** JSON
Just an enhanced json mode
#+BEGIN_SRC emacs-lisp
(use-package json-mode
    :mode "\\.json\\'")
#+END_SRC

*** YAML
Enhanced yaml mode
#+BEGIN_SRC emacs-lisp
(use-package yaml-mode
    :mode "\\.yaml\\'")
#+END_SRC

*** Arch PKGBUILD
For editing PKGBUILD files
#+BEGIN_SRC emacs-lisp
(use-package pkgbuild-mode
    :mode ".*PKGBUILD\\'")
#+END_SRC

*** LaTeX
**** AUCTeX
AUCTeX is a major mode for editing tex,
CDLaTeX adds some minor niceities to it.
company-auctex for completion.
#+BEGIN_SRC emacs-lisp
(use-package tex
    :defer t
    :ensure auctex
    :general
    (foltz-major-def
        :keymaps 'TeX-mode-map
        "e" 'TeX-command-run-all)
    :custom
    (TeX-auto-save t))
    
(use-package company-auctex
    :pin melpa
    :init
    (defun foltz-add-company-auctex-backend ()
        (foltz-add-company-backend 'company-auctex))
    :hook (LaTeX-mode . foltz-add-company-auctex-backend))

(use-package company-math
    :init
    (defun foltz-add-company-math-backends ()
        (foltz-add-company-backend 'company-math-symbols-latex)
        (foltz-add-company-backend 'company-math-symbols-unicode)
        (foltz-add-company-backend 'company-latex-commands))
    :hook ((cdlatex-mode . foltz-add-company-math-backends)
           (TeX-mode . foltz-add-company-math-backends)))
#+END_SRC
**** cdlatex
***** Environment
#+BEGIN_SRC emacs-lisp
(setq foltz-cdlatex-envs nil)
#+END_SRC
***** Commands
#+BEGIN_SRC emacs-lisp
(setq foltz-cdlatex-commands nil)
#+END_SRC
***** Math Symbols
#+BEGIN_SRC emacs-lisp
(setq foltz-cdlatex-symbols
  '((?I ("\\infty"))))
#+END_SRC
***** cdlatex
cdlatex adds better TeX-specific template expansions and other niceties.
#+BEGIN_SRC emacs-lisp
(use-package cdlatex
    :hook (LaTeX-mode . cdlatex-mode)
    :custom
    (cdlatex-env-alist foltz-cdlatex-envs)
    (cdlatex-command-alist foltz-cdlatex-commands)
    (cdlatex-math-symbol-alist foltz-cdlatex-symbols))
#+END_SRC
*** Rust
#+BEGIN_SRC emacs-lisp
(use-package rust-mode
    :mode "\\.rs\\'"
    :general
    (foltz-major-def
        :keymaps 'rust-mode-map
        "TAB" 'rust-format-buffer))

(use-package flycheck-rust
    :pin melpa
    :hook (rust-mode . flycheck-rust-setup))

(use-package racer
    :hook ((rust-mode . racer-mode)
           (rust-mode . eldoc-mode))
    :custom
    (racer-cmd "~/.cargo/bin/racer")
    (racer-rust-src-path "~/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src"))

(use-package cargo
    :hook (rust-mode . cargo-minor-mode)
    :general
    (foltz-major-def
        :keymaps 'rust-mode-map
        "b" 'cargo-process-build
        "r" 'cargo-process-run
        "t" 'cargo-process-test))
#+END_SRC
*** C/C++
**** Irony
Irony handles enhanced C/C++ operations powered by clang
company-irony for company integration
#+BEGIN_SRC emacs-lisp
(use-package irony
    :after counsel
    :hook ((c++-mode   . irony-mode)
           (c-mode     . irony-mode)
           (irony-mode . irony-cdb-autosetup-compile-options)))

(use-package company-irony
    :init
    (defun foltz-add-company-irony-backend ()
        (foltz-add-company-backend 'company-irony))
    :hook (irony-mode . foltz-add-company-irony-backend))

(use-package flycheck-irony
    :hook (irony-mode . flycheck-irony-setup))
#+END_SRC
**** Hotkeys
#+BEGIN_SRC emacs-lisp
(foltz-major-def
    :keymaps '(c++-mode-map c-mode-map)
    "r" 'rmsbolt-mode
    "c" 'rmsbolt-compile)
#+END_SRC