830 lines
26 KiB
Org Mode
830 lines
26 KiB
Org Mode
#+TITLE: My Doom Emacs config
|
|
#+AUTHOR: Iñigo Ortega
|
|
#+EMAIL: inigoortega@tutanota.com
|
|
#+LANGUAGE: en
|
|
#+STARTUP: inlineimages
|
|
#+PROPERTY: header-args :tangle yes :cache yes :results silent :padline no :config literate
|
|
#+OPTIONS: toc:nil
|
|
#+EXPORT_FILE_NAME: README
|
|
|
|
* Lexical binding
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; -*- lexical-binding: t -*-
|
|
#+END_SRC
|
|
* User configs
|
|
These are used for a number of things, particularly for GPG configuration,
|
|
some email clients, file templates and snippets.
|
|
#+BEGIN_SRC elisp
|
|
(setq user-full-name "inigoortega"
|
|
user-mail-address "inigoortega@tutanota.com")
|
|
#+END_SRC
|
|
|
|
* Style
|
|
** Fonts
|
|
Doom exposes five (optional) variables for controlling fonts in Doom. Here
|
|
are the three important ones:
|
|
+ `doom-font'
|
|
+ `doom-variable-pitch-font'
|
|
+ `doom-big-font' -- used for `doom-big-font-mode'
|
|
|
|
They all accept either a font-spec, font string ("Input Mono-12"), or xlfd
|
|
font string. You generally only need these two:
|
|
test
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq doom-font (font-spec :family "monospace" :width 'normal :size 17)
|
|
doom-variable-pitch-font (font-spec :family "monospace"))
|
|
#+END_SRC
|
|
|
|
** Theme
|
|
There are two ways to load a theme. Both assume the theme is installed and
|
|
available. You can either set `doom-theme' or manually load a theme with the
|
|
`load-theme' function. These are the defaults.
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq doom-theme 'doom-gruvbox)
|
|
#+END_SRC
|
|
|
|
** Line numbers
|
|
If you want to change the style of line numbers, change this to `relative' or
|
|
`nil' to disable it:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq display-line-numbers-type 'relative)
|
|
#+END_SRC
|
|
|
|
* Org
|
|
If you intend to use org, it is recommended you change this!
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq org-directory "~/org/")
|
|
#+END_SRC
|
|
|
|
* Custom variables
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq sh-symbols
|
|
'(sed tail printf echo pidof top dmenu rofi killall sed awk tee basename
|
|
ln mkdir rm ssh sleep source ps bash python perl Rscript wget
|
|
bunzip2 bzip2 zip unzip gzip gunzip find ls cat egrep grep mv cp
|
|
chmod tar stty export spark-shell spark-submit hadoop pyspark aws
|
|
dash xdotool xprop 7z p7z zsh fish expr command disown pv alias
|
|
))
|
|
|
|
(setq prelude-symbols
|
|
'(not otherwise maybe either fst snd curry uncurry compare min max succ
|
|
pred toEnum fromEnum enumFrom enumFromThen enumFromTo enumFromThenTo
|
|
minBound maxBound abs negate signum fromInteger show showsPrec showList
|
|
toInteger toRational quot rem div mod quotRem divMod toInteger recip
|
|
fromRational pi exp log sqrt logBase sin cos tan asin acos atan sinh cosh
|
|
tanh asinh acosh atanh map properFraction truncate round ceiling floor
|
|
floatRadix floatDigits floatRange decodeFloat encodeFloat exponent
|
|
significand scaleFloat isNaN isInfinite isDenormalized isNegativeZero
|
|
isIEEE atan2 subtract odd even gcd lcm fromIntegral realToFrac mempty
|
|
mappend mconcat fmap pure return fail mapM_ sequence foldMap foldr foldl
|
|
foldr1 foldl1 elem minimum sum product traverse sequenceA mapM id const
|
|
flip until asTypeOf error errorWithoutStackTrace undefined seq filter head
|
|
last tail init null length reverse and or any all concat concatMap scanl
|
|
scanr scanr1 iterate repeat replicate cycle take drop dropWhile takeWhile
|
|
splitAt span break notElem lookup zip zip3 zipWith zipWith3 unzip unzip3
|
|
lines words unlines unwords shows showChar showString showParen readsPrec
|
|
readList reads readParen read lex putChar putStr putStrLn print getChar
|
|
getLine getContents interact readFile writeFile appendFile readIO readLn
|
|
ioError userError))
|
|
|
|
(setq path-to-ctags "/usr/bin/ctags")
|
|
|
|
(setq i-keys (mapcar
|
|
(lambda (number) (setq command (format "%c" number)))
|
|
(number-sequence 35 91)))
|
|
(nconc i-keys (mapcar
|
|
(lambda (number) (setq command (format "%c" number)))
|
|
(number-sequence 93 250)))
|
|
|
|
(setq my-unignored-buffers '("*ielm*" "*scratch*" "*ansi-term*" "*term*"))
|
|
|
|
(setq insert-on-mode #s(hash-table size 30 data (shell-mode insert term-mode term-send-raw-string prog-mode insert!)))
|
|
|
|
(setq compression-extensions '("7z" "7zip" "zip" "zstd" "tar\..*"))
|
|
#+END_SRC
|
|
* Custom functions
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun eval-string (string)
|
|
"Evals all the commands inside the string"
|
|
(eval (car (read-from-string (format "(progn %s)" string)))))
|
|
|
|
;;; Shell script highlighting
|
|
(defun highlight-words-on-mode (mode symbols &optional face)
|
|
"Makes given symbols be highlighted on given mode"
|
|
(setq strings (mapcar 'symbol-name symbols))
|
|
(setq formatted-words
|
|
(concat "\\\\<\\\\(" (mapconcat 'identity
|
|
strings "\\\\|") "\\\\)\\\\>"))
|
|
(if face
|
|
(eval-string (format "(font-lock-add-keywords '%s '((\"%s\" .
|
|
%s)))" mode formatted-words face))
|
|
(eval-string (format "(font-lock-add-keywords '%s '((\"%s\" .
|
|
%s)))" mode formatted-words font-lock-builtin-face))
|
|
)
|
|
|
|
;; highlight options
|
|
(font-lock-add-keywords
|
|
mode
|
|
'(("\\<-[-a-zA-Z0-9]+\\>"
|
|
. font-lock-constant-face)))
|
|
(font-lock-add-keywords
|
|
mode
|
|
`((,(concat "[ \t]+"
|
|
(regexp-opt
|
|
'("!" "!=" "==" "=~") 'paren) "[ \t]+")
|
|
. font-lock-constant-face)))
|
|
)
|
|
|
|
(defun create-tags (dir-name)
|
|
"Create tags file."
|
|
(interactive "DDirectory: ")
|
|
(shell-command
|
|
(format "%s -f TAGS -e -R %s" path-to-ctags (directory-file-name dir-name)))
|
|
)
|
|
#+END_SRC
|
|
|
|
Xah Lee, read .bashrc:
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; from xah-lee http://ergoemacs.org/emacs/elisp_read_file_content.html
|
|
(defun re-n-matches ()
|
|
(1- (/ (length (match-data)) 2)))
|
|
|
|
(defun get-string-from-file (filePath)
|
|
"Return filePath's file content."
|
|
(with-temp-buffer
|
|
(insert-file-contents filePath)
|
|
(buffer-string)))
|
|
(defun match-strings-all (&optional string)
|
|
"Return the list of all expressions matched in last search.
|
|
STRING is optionally what was given to `string-match'."
|
|
(loop for i from 0 to (re-n-matches)
|
|
collect (match-string-no-properties i string)))
|
|
|
|
(defun re-find-all (regexp string &optional groups yes-props)
|
|
"like python's re.find_all"
|
|
(let (
|
|
;;(groups (or groups (list (regexp-count-capture-groups regexp))))
|
|
(match-string-fun (if (not yes-props) 'match-string 'match-string-no-properties))
|
|
(start 0)
|
|
(matches nil )
|
|
)
|
|
(while (setq start (and (string-match regexp string start) (match-end 0)))
|
|
(setq matches (cons (cdr (match-strings-all string)) matches))
|
|
)
|
|
(setq matches (reverse matches))
|
|
(if (not (cdar matches))
|
|
(mapcar 'car matches)
|
|
matches
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
(defun apply-eshell-alias (alias &rest definition)
|
|
"basically taken from eshell/alias function"
|
|
(if (not definition)
|
|
(setq eshell-command-aliases-list
|
|
(delq (assoc alias eshell-command-aliases-list)
|
|
eshell-command-aliases-list))
|
|
(and (stringp definition)
|
|
(set-text-properties 0 (length definition) nil definition))
|
|
(let ((def (assoc alias eshell-command-aliases-list))
|
|
(alias-def (list alias
|
|
(eshell-flatten-and-stringify definition))))
|
|
(if def
|
|
(setq eshell-command-aliases-list
|
|
(delq def eshell-command-aliases-list)))
|
|
(setq eshell-command-aliases-list
|
|
(cons alias-def eshell-command-aliases-list))))
|
|
)
|
|
(defun eshell-load-bashrc-aliases ()
|
|
(interactive)
|
|
(mapc (lambda (alias-def) (apply 'eshell/alias alias-def))
|
|
(re-find-all "^alias \\([^=]+\\)='?\\(.+?\\)'?$"
|
|
(get-string-from-file (concat (getenv "HOME") "/" ".alias"))
|
|
)
|
|
)
|
|
)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun make-buffer-uninteresting ()
|
|
"rename the current buffer to begin with a space"
|
|
(interactive)
|
|
(unless (string-match-p "^ " (buffer-name))
|
|
(rename-buffer (concat " " (buffer-name)))))
|
|
|
|
(defun make-buffer-interesting ()
|
|
"rename the current buffer to begin with a space"
|
|
(interactive)
|
|
(if (string-match-p "^ " (buffer-name))
|
|
(rename-buffer (concat " " (buffer-name)))))
|
|
#+END_SRC
|
|
|
|
Ansi-term for TRAMP:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun dfeich/ansi-terminal (&optional path name)
|
|
"Opens an ansi terminal at PATH. If no PATH is given, it uses
|
|
the value of `default-directory'. PATH may be a tramp remote path.
|
|
The ansi-term buffer is named based on `name' "
|
|
(interactive)
|
|
(unless path (setq path default-directory))
|
|
(unless name (setq name "ansi-term"))
|
|
(ansi-term "/bin/bash" name)
|
|
(let ((path (replace-regexp-in-string "^file:" "" path))
|
|
(cd-str
|
|
"fn=%s; if test ! -d $fn; then fn=$(dirname $fn); fi; cd $fn;")
|
|
(bufname (concat "*" name "*" )))
|
|
(if (tramp-tramp-file-p path)
|
|
(let ((tstruct (tramp-dissect-file-name path)))
|
|
(cond
|
|
((equal (tramp-file-name-method tstruct) "ssh")
|
|
(process-send-string bufname (format
|
|
(concat "ssh -t %s '"
|
|
cd-str
|
|
"exec bash'; exec bash; clear\n")
|
|
(tramp-file-name-host tstruct)
|
|
(tramp-file-name-localname tstruct))))
|
|
(t (error "not implemented for method %s"
|
|
(tramp-file-name-method tstruct)))))
|
|
(process-send-string bufname (format (concat cd-str " exec bash;clear\n")
|
|
path)))))
|
|
#+END_SRC
|
|
|
|
ii mode:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun ins-mode (str)
|
|
(interactive)
|
|
(setq f (gethash major-mode insert-on-mode))
|
|
(if (eq f nil)
|
|
(insert! str)
|
|
(funcall f str)
|
|
)
|
|
)
|
|
(defun ii-mode ()
|
|
(mapcar
|
|
(lambda (key)
|
|
(eval-string
|
|
(format "(map!
|
|
:i \"i %s\" (lambda() (interactive) (ins-mode \"i\") (execute-kbd-macro (kbd \"%s\"))))"
|
|
key key))) i-keys)
|
|
|
|
;; Exceptions
|
|
(map! :i "i !" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "!"))))
|
|
(map! :i "i \"" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd (format "%c" 34)))))
|
|
(map! :i "i SPC" (lambda()
|
|
(interactive)
|
|
(ins-mode "i ")
|
|
))
|
|
(map! :i "i ESC" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
;; (execute-kbd-macro (kbd "ESC"))))
|
|
(evil-normal-state)))
|
|
(map! :i "i C-g" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
))
|
|
(map! :i "i RET" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "RET"))))
|
|
(map! :i "i \\" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "\\"))))
|
|
(map! :i "i DEL" (lambda()
|
|
(interactive)
|
|
(ignore)))
|
|
(map! :i "i TAB" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "TAB"))))
|
|
(map! :i "i C-n" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "C-n"))))
|
|
;; (evil-complete-next)))
|
|
|
|
;; F keys
|
|
(map! :i "i <f1>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f1>"))))
|
|
(map! :i "i <f2>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f2>"))))
|
|
(map! :i "i <f3>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f3>"))))
|
|
(map! :i "i <f4>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f4>"))))
|
|
(map! :i "i <f5>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f5>"))))
|
|
(map! :i "i <f6>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f6>"))))
|
|
(map! :i "i <f7>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f7>"))))
|
|
(map! :i "i <f8>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f8>"))))
|
|
(map! :i "i <f9>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f9>"))))
|
|
(map! :i "i <f10>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f10>"))))
|
|
(map! :i "i <f11>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f11>"))))
|
|
(map! :i "i <f12>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<f12>"))))
|
|
|
|
;; Other special keys
|
|
(map! :i "i <pause>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<pause>"))))
|
|
(map! :i "i <Scroll_Lock>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<Scroll_Lock>"))))
|
|
(map! :i "i <insert>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<insert>"))))
|
|
(map! :i "i <deletechar>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<deletechar>"))))
|
|
(map! :i "i <home>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<home>"))))
|
|
(map! :i "i <end>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<end>"))))
|
|
(map! :i "i <prior>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<prior>"))))
|
|
(map! :i "i <next>" (lambda()
|
|
(interactive)
|
|
(ins-mode "i")
|
|
(execute-kbd-macro (kbd "<next>"))))
|
|
|
|
;; i i
|
|
(map! :i "i i" #'evil-normal-state)
|
|
)
|
|
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun get-file-type (file &optional deref-symlinks)
|
|
"Return the type of FILE, according to the `file' command.
|
|
If you give a prefix to this command, and FILE is a symbolic
|
|
link, then the type of the file linked to by FILE is returned
|
|
instead."
|
|
(let (process-file-side-effects)
|
|
(with-temp-buffer
|
|
(if deref-symlinks
|
|
(process-file "file" nil t t "-bL" "--" file)
|
|
(process-file "file" nil t t "-b" "--" file))
|
|
(when (bolp)
|
|
(backward-delete-char 1))
|
|
(buffer-string))))
|
|
#+END_SRC
|
|
|
|
* Custom keybindings
|
|
Replace with Regiser:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "g r" #'evil-replace-with-register)
|
|
(evil-replace-with-register-install)
|
|
#+END_SRC
|
|
|
|
Delete other windows:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "SPC w D" #'delete-other-windows)
|
|
#+END_SRC
|
|
|
|
zsh as ansi-term shell
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defvar my-term-shell "/bin/zsh")
|
|
(setq tramp-shell-prompt-pattern "$ ")
|
|
;; (eval-after-load 'tramp '(setenv "SHELL" "/bin/bash"))
|
|
(defadvice ansi-term (before force-bash)
|
|
(interactive (list my-term-shell)))
|
|
(ad-activate 'ansi-term)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :map 'pdf-view-mode-map
|
|
:n "f" #'pdf-links-action-perform)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "SPC f z" #'counsel-fzf)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "SPC b j" #'ivy-switch-buffer)
|
|
(map! :n "SPC j j" #'ivy-switch-buffer)
|
|
(map! :map 'ranger-mode-map :g "SPC b j" #'ivy-switch-buffer)
|
|
(map! :map 'ranger-mode-map :g "SPC j j" #'ivy-switch-buffer)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "SPC o c" #'calendar)
|
|
(map! :n "SPC o s" #'ansi-term)
|
|
|
|
(map! :map 'ranger-mode-map :g "SPC o c" #'calendar)
|
|
(map! :map 'ranger-mode-map :g "SPC o s"
|
|
(lambda() (interactive)
|
|
(if (file-remote-p default-directory)
|
|
(dfeich/ansi-terminal)
|
|
(ansi-term my-term-shell))))
|
|
#+END_SRC
|
|
|
|
Emacs powered window manager keybinding clones:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :n "SPC j h" (lambda () (interactive) (ansi-term "htop")))
|
|
#+END_SRC
|
|
|
|
Real buffer:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun mark-real-user-buffer()
|
|
(interactive)
|
|
(setq buf-name (buffer-name))
|
|
(switch-to-buffer "*scratch*")
|
|
(switch-to-buffer buf-name)
|
|
)
|
|
(map! :n "SPC b R" (lambda ()
|
|
(interactive)
|
|
(mark-real-user-buffer)
|
|
))
|
|
#+END_SRC
|
|
** Dired
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :map 'dired-mode-map :n "A" (lambda () (interactive) (find-alternate-file "..")))
|
|
(map! :map 'dired-mode-map
|
|
:n "w" #'peep-dired
|
|
)
|
|
(map! :map 'dired-mode-map :n "a"
|
|
(lambda ()
|
|
(interactive)
|
|
(if (equal (get-file-type (dired-get-file-for-visit)) "directory")
|
|
(dired-find-alternate-file)
|
|
(dired-find-file))
|
|
))
|
|
(map! :map 'dired-mode-map :n "l"
|
|
(lambda ()
|
|
(interactive)
|
|
(if (equal (get-file-type (dired-get-file-for-visit)) "directory")
|
|
(dired-find-alternate-file)
|
|
(dired-find-file))
|
|
))
|
|
(map! :map 'dired-mode-map :n "SPC m o" #'hydra-dired-quick-sort/body)
|
|
(map! :map 'dired-mode-map :n "h" (lambda () (interactive) (find-alternate-file "..")))
|
|
#+END_SRC
|
|
|
|
** 'ii' in INSERT mode to escape to NORMAL mode:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(ii-mode)
|
|
;; Why is not working?
|
|
;; (ii-mode org-mode-map "org-mode-map")
|
|
;; (map! :n "SPC i i" (lambda () (ii-mode org-mode-map "org-mode-map")))
|
|
#+END_SRC
|
|
|
|
* Custom configuration
|
|
** Dired
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq dired-dwim-target t)
|
|
#+END_SRC
|
|
|
|
Peep-dired:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(map! :map 'peep-dired-mode-map
|
|
:n "j" #'peep-dired-next-file
|
|
:n "k" #'peep-dired-prev-file
|
|
)
|
|
(add-hook! 'peep-dired-hook #'evil-normalize-keymaps)
|
|
(setq peep-dired-cleanup-on-disable t)
|
|
(setq peep-dired-ignored-extensions '("mkv" "iso" "mp4" "webm" "avi"))
|
|
#+END_SRC
|
|
|
|
** General
|
|
Delitimers:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(show-paren-mode 1)
|
|
(add-hook 'prog-mode-hook 'rainbow-delimiters-mode)
|
|
#+END_SRC
|
|
|
|
Cutting lines at 80th character:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(add-hook! 'text-mode-hook #'turn-on-auto-fill)
|
|
(setq-default auto-fill-function 'do-auto-fill)
|
|
#+END_SRC
|
|
|
|
Highlight after 80:
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; (require 'whitespace)
|
|
;; (setq whitespace-style '(face lines-tail))
|
|
;; (add-hook 'text-mode-hook
|
|
;; (setq whitespace-line-column 80)
|
|
;; ;; (global-whitespace-mode t) ; for dot on spaces
|
|
;; )
|
|
#+END_SRC
|
|
|
|
Trailing whitespaces:
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; (setq-default show-trailing-whitespace t)
|
|
(setq-default indicate-empty-lines t)
|
|
(add-hook 'before-save-hook 'delete-trailing-whitespace)
|
|
#+END_SRC
|
|
|
|
Wrap lines if there is no more space in the window:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(global-visual-line-mode)
|
|
#+END_SRC
|
|
|
|
Evil-surround work everywhere:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(global-evil-surround-mode t)
|
|
#+END_SRC
|
|
|
|
Folding:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(vimish-fold-global-mode 1)
|
|
(add-hook 'prog-mode-hook
|
|
(lambda ()
|
|
(if (or (derived-mode-p 'python-mode) (derived-mode-p 'haskell-mode))
|
|
(progn
|
|
(yafolding-mode)
|
|
(yafolding-hide-all)
|
|
)
|
|
(+fold/close-all)
|
|
)))
|
|
|
|
(defun yafolding-rec (todo)
|
|
(interactive)
|
|
(setq level (yafolding-get-indent-level))
|
|
(while (or (current-line-empty-p) (> level 0))
|
|
(if (current-line-empty-p)
|
|
(progn
|
|
(re-search-backward "^.")
|
|
(setq level (yafolding-get-indent-level))
|
|
)
|
|
(progn
|
|
(yafolding-go-parent-element)
|
|
(setq level (- level 1))
|
|
)
|
|
))
|
|
(cond ((eq todo 'hide-element) (yafolding-hide-element))
|
|
((eq todo 'hide-all) (yafolding-hide-all))
|
|
)
|
|
)
|
|
|
|
(defun current-line-empty-p ()
|
|
;; Spaces not included
|
|
(string-match-p "\\`$" (thing-at-point 'line)))
|
|
(defun current-line-empty2-p ()
|
|
;; Spaces included
|
|
(string-match-p "\\`\\s-*$" (thing-at-point 'line)))
|
|
|
|
(map! :map 'hs-minor-mode-map
|
|
:n "z o" #'hs-show-block
|
|
)
|
|
|
|
(map! :map 'yafolding-mode-map
|
|
:n "z a" #'yafolding-toggle-fold
|
|
:n "z c" #'yafolding-hide-parent-element
|
|
:n "z C" (lambda () (interactive) (yafolding-rec 'hide-element))
|
|
:n "z o" #'yafolding-show-element
|
|
:n "z O" #'yafolding-show-element
|
|
:n "z m" (lambda () (interactive) (yafolding-rec 'hide-all))
|
|
:n "z r" #'yafolding-show-all
|
|
)
|
|
#+END_SRC
|
|
|
|
IRC (not working):
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; Default user.
|
|
(setq rcirc-default-nick "initega")
|
|
(setq rcirc-default-user-name "initega")
|
|
(setq rcirc-default-full-name "initega")
|
|
#+END_SRC
|
|
|
|
Eshell:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(add-hook 'eshell-mode-hook (lambda ()
|
|
(if (eq company-mode nil)
|
|
(company-mode)
|
|
)
|
|
))
|
|
(setq shell-command-switch "-ic")
|
|
|
|
(defun singpolyma/term-insert-literal (key)
|
|
"Take a keypress and insert it literally into a terminal."
|
|
(interactive "cPress key:")
|
|
(term-send-raw-string (format "\e%c" key))
|
|
)
|
|
|
|
(add-hook 'term-mode-hook
|
|
(lambda ()
|
|
(interactive)
|
|
(doom-mark-buffer-as-real-h)
|
|
(map!
|
|
:i "C-#" #'singpolyma/term-insert-literal
|
|
)))
|
|
#+END_SRC
|
|
|
|
Aliases:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defalias 'open 'find-file)
|
|
(defalias 'openo 'find-file-other-window)
|
|
;; (apply 'eshell/alias '("config" "/usr/bin/git --git-dir=$HOME/dotfiles/ --work-tree=$HOME"))
|
|
;; (add-hook 'eshell-mode-hook 'eshell-load-bashrc-aliases)
|
|
#+END_SRC
|
|
|
|
Interesting buffers filter:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun my-ido-ignore-func (name)
|
|
"Ignore all non-user (a.k.a. *starred*) buffers except those listed in `my-unignored-buffers'."
|
|
(and (string-match "^\*" name)
|
|
(not (member name my-unignored-buffers))))
|
|
|
|
(setq ido-ignore-buffers '("\\` " my-ido-ignore-func))
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(add-hook 'calendar-load-hook
|
|
(lambda ()
|
|
(calendar-set-date-style 'european)))
|
|
(setq calendar-week-start-day 1)
|
|
#+END_SRC
|
|
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq flycheck-flake8-maximum-line-length 80)
|
|
#+END_SRC
|
|
** Personal packages
|
|
#+BEGIN_SRC emacs-lisp
|
|
(add-to-list 'load-path "~/.doom.d/lisp/")
|
|
(load "rate-sx")
|
|
(load "sunrise")
|
|
#+END_SRC
|
|
** Haskell
|
|
Haskell-mode configs:
|
|
# ;; Ancient code for hindent
|
|
# ;; (add-hook! 'haskell-mode-hook
|
|
# ;; #'hindent-mode
|
|
# ;; (lambda() (add-hook!
|
|
# ;; 'before-save-hook
|
|
# ;; (progn
|
|
# ;; (hindent-reformat-buffer)
|
|
# ;; (recenter-top-bottom)
|
|
# ;; ) nil 'local)))
|
|
|
|
|
|
Haskell stylish:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(after! haskell-mode
|
|
(progn
|
|
(setq
|
|
;; Format files with Brittany instead of Stylish
|
|
haskell-mode-stylish-haskell-path "brittany"
|
|
;; Format buffer with Brittany on save
|
|
haskell-stylish-on-save t
|
|
;; Suggest removing imports
|
|
haskell-process-suggest-remove-import-lines t)))
|
|
#+END_SRC
|
|
|
|
Haskell-mode hook to activate minor modes (yafolding...).
|
|
#+BEGIN_SRC emacs-lisp
|
|
(add-hook 'haskell-mode-hook
|
|
(lambda ()
|
|
(interactive)
|
|
(haskell-indentation-mode)
|
|
(interactive-haskell-mode)
|
|
(yas-minor-mode)
|
|
))
|
|
|
|
(map! :map 'haskell-interactive-mode-map
|
|
:i "C-j" #'haskell-interactive-mode-history-next)
|
|
(map! :map 'haskell-interactive-mode-map
|
|
:i "C-k" #'haskell-interactive-mode-history-previous)
|
|
#+END_SRC
|
|
|
|
|
|
Haskell-interactive-mode process (change when I am on big project):
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; (setq haskell-process-path-ghci "stack-ghci")
|
|
(setq haskell-process-type 'stack-ghci)
|
|
#+END_SRC
|
|
|
|
Dante configuration:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(after! dante
|
|
(nconc dante-methods '(stack-ghci))
|
|
(defun dante-repl-command-line ()
|
|
'("stack-ghci"))
|
|
)
|
|
;; (setq dante-methods
|
|
;; '(styx new-impure-nix new-nix nix impure-nix new-build nix-ghci stack mafia
|
|
;; bare-cabal bare-ghci)))
|
|
|
|
(add-hook 'dante-mode-hook
|
|
'(lambda () (flycheck-add-next-checker 'haskell-dante
|
|
'(warning . haskell-hlint))))
|
|
#+END_SRC
|
|
|
|
Highlight predule:
|
|
#+BEGIN_SRC emacs-lisp
|
|
(highlight-words-on-mode 'haskell-mode prelude-symbols)
|
|
#+END_SRC
|
|
** Jupyter (ein)
|
|
#+BEGIN_SRC emacs-lisp
|
|
(setq org-babel-load-languages '((emacs-lisp . t) (ein . t)))
|
|
#+END_SRC
|
|
** Python
|
|
#+BEGIN_SRC emacs-lisp
|
|
(elpy-enable)
|
|
|
|
;; Following disabled due to high CPU usage
|
|
;;; Use IPython for REPL
|
|
;; (setq python-shell-interpreter "jupyter"
|
|
;; python-shell-interpreter-args "console --simple-prompt"
|
|
;; python-shell-prompt-detect-failure-warning nil)
|
|
;; (add-to-list 'python-shell-completion-native-disabled-interpreters
|
|
;; "jupyter")
|
|
;; (setq python-shell-interpreter "ipython"
|
|
;; python-shell-interpreter-args "-i --simple-prompt")
|
|
|
|
(setq blacken-line-length 80)
|
|
|
|
(add-hook 'python-mode-hook
|
|
(lambda ()
|
|
(setq-default indent-tabs-mode nil)
|
|
(setq-default tab-width 4)
|
|
(yafolding-mode)
|
|
(setq-default python-indent 4)))
|
|
#+END_SRC
|
|
|
|
** Shell script
|
|
#+BEGIN_SRC emacs-lisp
|
|
(highlight-words-on-mode 'sh-mode sh-symbols)
|
|
#+END_SRC
|
|
|
|
** AucTex
|
|
#+BEGIN_SRC emacs-lisp
|
|
;; (add-to-list 'TeX-mode-hook #'TeX-fold-buffer)
|
|
;; (add-hook! 'tex-mode-hook #'TeX-fold-buffer)
|
|
#+END_SRC
|
|
** TRAMP
|
|
#+BEGIN_SRC emacs-lisp
|
|
(defun my-shell ()
|
|
(interactive)
|
|
(let ((default-directory "/ssh:initega@192.168.0.28:"))
|
|
(eshell)))
|
|
#+END_SRC
|
|
* Doom info
|
|
Here are some additional functions/macros that could help you configure Doom:
|
|
|
|
- `load!' for loading external *.el files relative to this one
|
|
- `use-package' for configuring packages
|
|
- `after!' for running code after a package has loaded
|
|
- `add-load-path!' for adding directories to the `load-path', where Emacs
|
|
looks when you load packages with `require' or `use-package'.
|
|
- `map!' for binding new keys
|
|
|
|
To get information about any of these functions/macros, move the cursor over
|
|
the highlighted symbol at press 'K' (non-evil users must press 'C-c g k').
|
|
This will open documentation for it, including demos of how they are used.
|
|
|
|
You can also try 'gd' (or 'C-c g d') to jump to their definition and see how
|
|
they are implemented.
|