emenel/doomemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'develop' into eshell-improvements

Browse source
This commit is contained in:
Steven vanZyl 2020-05-06 10:33:39 -04:00 • committed by GitHub
commit a70cfce520
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
153 changed files with 2327 additions and 1920 deletions
Download patch file Download diff file Expand all files Collapse all files

5
.github/PULL_REQUEST/bump.md → .github/PULL_REQUEST_TEMPLATE/bump.md vendored
View file

@ -15,12 +15,13 @@ labels: is:update re:packages
>
> OR, if multiple packages are bumped in one commit:
>
> Bump package1, package2 & package 3
> Bump :tools lsp
>
> emacs-lsp/lsp-mode@91e37a6 -> emacs-lsp/lsp-mode@c8188ef
> emacs-lsp/lsp-ui@cf6906c -> emacs-lsp/lsp-ui@582e153
>
> (Commit hashes should be limited to 7 characters)
> Commit hashes should be limited to 7 characters. Include additional
> commentary after the list of commit changes.
>
> 4. You've included links to relevant issues, if any
> 5. You've deleted this template

0
.github/PULL_REQUEST/general.md → .github/PULL_REQUEST_TEMPLATE/general.md vendored
View file

9
bin/doom
View file

@ -6,7 +6,7 @@
:; DOOMBASE="$(dirname "$0")/.."
:; [ "$1" = -d ] || [ "$1" = --debug ] && { shift; export DEBUG=1; }
:; [ "$1" = run ] && { cd "$DOOMBASE"; shift; exec $EMACS -q --no-splash -l bin/doom "$@"; exit 0; }
:; exec $EMACS --script "$0" -- "$@"
:; exec $EMACS --no-site-file --script "$0" -- "$@"
:; exit 0
(let* ((load-prefer-newer t)
@ -15,6 +15,13 @@
(user-emacs-directory
(abbreviate-file-name (or emacsdir (expand-file-name "../" loaddir)))))
;; HACK Load `cl' and site files manually so we can stop them from polluting
;; CLI logs with deprecation and file load messages.
(let ((inhibit-message t))
(when (> emacs-major-version 26)
(require 'cl))
(load "site-start" t t))
(push (expand-file-name "core" user-emacs-directory) load-path)
(require 'core)
(require 'core-cli)

95
core/autoload/cache.el
View file

@ -1,95 +0,0 @@
;;; core/autoload/cache.el -*- lexical-binding: t; -*-
;; This little library thinly wraps around persistent-soft (which is a pcache
;; wrapper, how about that). It has three purposes:
;;
;; + To encapsulate the cache backend (persistent-soft/pcache in this case), in
;; case it needs to change.
;; + To provide `doom-cache-persist': a mechanism for easily persisting
;; variables across Emacs sessions.
;; + To lazy-load persistent-soft until it is really needed.
;;
;; Like persistent-soft, caches assume a 2-tier structure, where all caches are
;; namespaced by location.
(defvar doom-cache-alists '(t)
"An alist of alists, containing lists of variables for the doom cache library
to persist across Emacs sessions.")
(defvar doom-cache-location 'doom
"The default location for cache files. This symbol is translated into a file
name under `pcache-directory' (by default a subdirectory under
`doom-cache-dir'). One file may contain multiple cache entries.")
(defun doom-save-persistent-cache-h ()
"Hook to run when an Emacs session is killed. Saves all persisted variables
listed in `doom-cache-alists' to files."
(dolist (alist (butlast doom-cache-alists 1))
(cl-loop with key = (car alist)
for var in (cdr alist)
if (symbol-value var)
do (doom-cache-set var it nil key))))
(add-hook 'kill-emacs-hook #'doom-save-persistent-cache-h)
;;
;; Library
;;;###autoload
(defmacro with-cache! (location &rest body)
"Runs BODY with a different default `doom-cache-location'."
(declare (indent defun))
`(let ((doom-cache-location ',location))
,@body))
;;;###autoload
(defun doom-cache-persist (location variables)
"Persist VARIABLES (list of symbols) in LOCATION (symbol).
This populates these variables with cached values, if one exists, and saves them
to file when Emacs quits.
Warning: this is incompatible with buffer-local variables."
(dolist (var variables)
(when (doom-cache-exists var location)
(set var (doom-cache-get var location))))
(setf (alist-get location doom-cache-alists)
(append variables (cdr (assq location doom-cache-alists)))))
;;;###autoload
(defun doom-cache-desist (location &optional variables)
"Unregisters VARIABLES (list of symbols) in LOCATION (symbol) from
`doom-cache-alists', thus preventing them from being saved between sessions.
Does not affect the actual variables themselves or their values."
(if variables
(setf (alist-get location doom-cache-alists)
(cl-set-difference (cdr (assq location doom-cache-alists))
variables))
(delq (assq location doom-cache-alists)
doom-cache-alists)))
;;;###autoload
(defun doom-cache-get (key &optional location)
"Retrieve KEY from LOCATION (defaults to `doom-cache-location'), if it exists
and hasn't expired."
(persistent-soft-fetch
key (symbol-name (or location doom-cache-location))))
;;;###autoload
(defun doom-cache-set (key value &optional ttl location)
"Set KEY to VALUE in the cache. TTL is the time (in seconds) until this cache
entry expires. LOCATION is the super-key to store this cache item under; the
default is `doom-cache-location'. "
(persistent-soft-store
key value
(symbol-name (or location doom-cache-location)) ttl))
;;;###autoload
(defun doom-cache-exists (key &optional location)
"Returns t if KEY exists at LOCATION (defaults to `doom-cache-location')."
(persistent-soft-exists-p key (or location doom-cache-location)))
;;;###autoload
(defun doom-cache-clear (&optional location)
"Clear a cache LOCATION (defaults to `doom-cache-location')."
(persistent-soft-flush (or location doom-cache-location)))

5
core/autoload/debug.el
View file

@ -46,10 +46,7 @@ ready to be pasted in a bug report on github."
(require 'core-packages)
(let ((default-directory doom-emacs-dir)
(doom-modules (doom-modules)))
(cl-letf
(((symbol-function 'sh)
(lambda (&rest args)
(cdr (apply #'doom-call-process args)))))
(letf! (defun sh (&rest args) (cdr (apply #'doom-call-process args)))
`((emacs
(version . ,emacs-version)
(features ,@system-configuration-features)

7
core/autoload/help.el
View file

@ -38,6 +38,7 @@
(LaTeX-mode :lang latex)
(ledger-mode :lang ledger)
(lua-mode :lang lua)
(moonscript-mode :lang lua)
(markdown-mode :lang markdown)
(gfm-mode :lang markdown)
(nim-mode :lang nim)
@ -45,6 +46,7 @@
(taureg-mode :lang ocaml)
(org-mode :lang org)
(perl-mode :lang perl)
(raku-mode :lang perl)
(php-mode :lang php)
(hack-mode :lang php)
(plantuml-mode :lang plantuml)
@ -53,7 +55,9 @@
(restclient-mode :lang rest)
(ruby-mode :lang ruby)
(rust-mode :lang rust)
(rustic-mode :lang rust)
(scala-mode :lang scala)
(scheme-mode :lang scheme)
(sh-mode :lang sh)
(swift-mode :lang swift)
(web-mode :lang web)
@ -131,7 +135,8 @@ selection of all minor-modes, active or not."
(list (or (+org-get-global-property "TITLE")
(file-relative-name (buffer-file-name)))))
path
(list (replace-regexp-in-string org-link-any-re "\\4" text)))
(when text
(list (replace-regexp-in-string org-link-any-re "\\4" text))))
" > ")
tags)
" ")

7
core/autoload/projects.el
View file

@ -101,11 +101,10 @@ If DIR is not a project, it will be indexed (but not cached)."
(unless (file-readable-p dir)
(error "Directory %S isn't readable" dir))
(let* ((default-directory (file-truename (expand-file-name dir)))
(project-root (doom-project-root default-directory))
(projectile-project-root default-directory)
(projectile-project-root (doom-project-root default-directory))
(projectile-enable-caching projectile-enable-caching))
(cond ((and project-root (file-equal-p project-root projectile-project-root))
(unless (doom-project-p projectile-project-root)
(cond ((and projectile-project-root (file-equal-p projectile-project-root default-directory))
(unless (doom-project-p default-directory)
;; Disable caching if this is not a real project; caching
;; non-projects easily has the potential to inflate the projectile
;; cache beyond reason.

5
core/autoload/sessions.el
View file

@ -130,8 +130,11 @@
(interactive "P")
(setq doom-autosave-session nil)
(doom/quicksave-session)
(save-some-buffers nil t)
(letf! ((#'save-buffers-kill-emacs #'kill-emacs)
(confirm-kill-emacs))
(restart-emacs
(append (if debug (list "--debug-init"))
(when (boundp 'chemacs-current-emacs-profile)
(list "--with-profile" chemacs-current-emacs-profile))
(list "--restore"))))
(list "--restore")))))

142
core/autoload/store.el Normal file
View file

@ -0,0 +1,142 @@
;;; core/autoload/cache.el -*- lexical-binding: t; -*-
;; This little library abstracts the process of writing arbitrary elisp values
;; to a 2-tiered file store (in `doom-store-dir'/`doom-store-location').
(defvar doom-store-dir (concat doom-etc-dir "store/")
"Directory to look for and store data accessed through this API.")
(defvar doom-store-persist-alist '(t)
"An alist of alists, containing lists of variables for the doom cache library
to persist across Emacs sessions.")
(defvar doom-store-location "default"
"The default location for cache files. This symbol is translated into a file
name under `pcache-directory' (by default a subdirectory under
`doom-store-dir'). One file may contain multiple cache entries.")
(defvar doom--store-table (make-hash-table :test 'equal))
(defvar doom--inhibit-flush nil)
(defun doom-save-persistent-store-h ()
"Hook to run when an Emacs session is killed. Saves all persisted variables
listed in `doom-store-persist-alist' to files."
(let (locations)
(let ((doom--inhibit-flush t))
(dolist (alist (butlast doom-store-persist-alist 1))
(cl-loop with location = (car alist)
for var in (cdr alist)
do (doom-store-put var (symbol-value var) nil location)
and do (cl-pushnew location locations))))
(mapc #'doom--store-flush locations)))
(add-hook 'kill-emacs-hook #'doom-save-persistent-store-h)
;;
;; Library
;;;###autoload
(defun doom-store-persist (location variables)
"Persist VARIABLES (list of symbols) in LOCATION (symbol).
This populates these variables with cached values, if one exists, and saves them
to file when Emacs quits. This cannot persist buffer-local variables."
(dolist (var variables)
(when (doom-store-member-p var location)
(set var (doom-store-get var location))))
(setf (alist-get location doom-store-persist-alist)
(append variables (alist-get location doom-store-persist-alist))))
;;;###autoload
(defun doom-store-desist (location &optional variables)
"Unregisters VARIABLES (list of symbols) in LOCATION (symbol).
Variables to persist are recorded in `doom-store-persist-alist'. Does not affect
the actual variables themselves or their values."
(if variables
(setf (alist-get location doom-store-persist-alist)
(cl-set-difference (cdr (assq location doom-store-persist-alist))
variables))
(delq! location doom-store-persist-alist 'assoc)))
(defun doom--store-init (location)
(or (gethash location doom--store-table)
(let* ((file-name-handler-alist nil)
(location-path (expand-file-name location doom-store-dir)))
(if (file-exists-p location-path)
(puthash location
(with-temp-buffer
(set-buffer-multibyte nil)
(setq buffer-file-coding-system 'binary)
(insert-file-contents-literally location-path)
(read (current-buffer)))
doom--store-table)
(puthash location (make-hash-table :test 'equal)
doom--store-table)))))
(defun doom--store-get (key location &optional default-value)
(let* ((location-data (doom--store-init location))
(data (gethash key location-data default-value)))
(if (and (not (eq data default-value))
(or (null (car data))
(not (time-less-p (car data) (current-time)))))
(cdr data)
default-value)))
(defun doom--store-put (key value location &optional ttl)
(puthash key (cons (if ttl (time-add (current-time) ttl)) value)
(doom--store-init location))
(doom--store-flush location))
(defun doom--store-flush (location)
(unless doom--inhibit-flush
(let ((file-name-handler-alist nil)
(coding-system-for-write 'binary)
(write-region-annotate-functions nil)
(write-region-post-annotation-function nil)
(data (doom--store-init location)))
(make-directory doom-store-dir 'parents)
(with-temp-file (expand-file-name location doom-store-dir)
(prin1 data (current-buffer)))
data)))
;;;###autoload
(defun doom-store-get (key &optional location default-value)
"Retrieve KEY from LOCATION (defaults to `doom-store-location').
If it doesn't exist or has expired, DEFAULT_VALUE is returned."
(doom--store-get key (or location doom-store-location) default-value))
;;;###autoload
(defun doom-store-put (key value &optional ttl location)
"Set KEY to VALUE in the store at LOCATION.
KEY can be any lisp object that is comparable with `equal'. TTL is the time (in
seconds) until this cache entry expires. LOCATION is the super-key to store this
cache item under. It defaults to `doom-store-location'."
(doom--store-put key value (or location doom-store-location) ttl))
;;;###autoload
(defun doom-store-rem (key &optional location)
"Clear a cache LOCATION (defaults to `doom-store-location')."
(let ((location (or location doom-store-location)))
(remhash key (doom--store-init location))
(let ((table (doom--store-init "default")))
(remhash 'test table)
table)
(doom--store-flush location)))
;;;###autoload
(defun doom-store-member-p (key &optional location)
"Return t if KEY in LOCATION exists.
LOCATION defaults to `doom-store-location'."
(let ((nil-value (format "--nilvalue%s--" (current-time))))
(not (equal (doom-store-get key location nil-value)
nil-value))))
;;;###autoload
(defun doom-store-clear (&optional location)
"Clear the store at LOCATION (defaults to `doom-store-location')."
(let* ((location (or location doom-store-location))
(path (expand-file-name location doom-store-dir)))
(remhash location doom--store-table)
(when (file-exists-p path)
(delete-file path)
t)))

10
core/cli/autoloads.el
View file

@ -32,7 +32,9 @@ one wants that.")
(cl-check-type file string)
(and (print! (start "Generating core autoloads..."))
(doom-cli--write-autoloads
file (doom-cli--generate-autoloads
file
(doom-cli--generate-emacs-version-check)
(doom-cli--generate-autoloads
(cl-loop for dir
in (append (list doom-core-dir)
(cdr (doom-module-load-path 'all-p))
@ -105,6 +107,12 @@ one wants that.")
(print! "M-x doom/restart")
(print! "M-x doom/reload")))
(defun doom-cli--generate-emacs-version-check ()
`((unless (equal emacs-major-version (eval-when-compile emacs-major-version))
(signal 'doom-error
(list "Your installed (major) version of Emacs has changed"
"Run 'doom sync && doom build' to bring Doom up to speed")))))
(defun doom-cli--generate-var-cache (vars)
`((setq ,@(cl-loop for var in vars
append `(,var ',(symbol-value var))))))

7
core/cli/env.el
View file

@ -113,10 +113,11 @@ default, on Linux, this is '$SHELL -ic /usr/bin/env'. Variables in
"# run 'doom sync'. To create a safe-to-edit envvar file use:\n#\n"
"# doom env -o ~/.doom.d/myenv\n#\n"
"# And load it with (doom-load-envvars-file \"~/.doom.d/myenv\").\n")
(concat "# This file is safe to edit by hand, but needs to be loaded manually with:\n#\n"
(concat "# This file is safe to edit by hand, but remember to preserve the null bytes at\n"
"# the end of each line! needs to be loaded manually with:\n#\n"
"# (doom-load-envvars-file \"path/to/this/file\")\n#\n"
"# Use 'doom env -o path/to/this/file' to regenerate it."))
"# ---------------------------------------------------------------------------\n\n"))
"# ---------------------------------------------------------------------------\n\0\n"))
;; We assume that this noninteractive session was spawned from the
;; user's interactive shell, therefore we just dump
;; `process-environment' to a file.
@ -124,7 +125,7 @@ default, on Linux, this is '$SHELL -ic /usr/bin/env'. Variables in
(if (cl-find-if (doom-rpartial #'string-match-p (car (split-string env "=")))
doom-env-ignored-vars)
(print! (info "Ignoring %s") env)
(insert env "\n")))
(insert env "\0\n")))
(print! (success "Successfully generated %S")
(path env-file))
t))))))

2
core/core-cli.el
View file

@ -258,7 +258,7 @@ BODY will be run when this dispatcher is called."
(print! "%2s) %s" (1+ (length options))
(if (cl-find-if (doom-rpartial #'string-match-p desc)
doom--cli-straight-discard-options)
(concat desc " (Recommended)")
(green (concat desc " (Recommended)"))
desc))))
(terpri)
(let* ((options

26
core/core-editor.el
View file

@ -293,10 +293,7 @@ possible."
`pp' can be expensive for longer lists, and there's no reason to prettify cache
files, so we replace calls to `pp' with the much faster `prin1'."
:around #'save-place-alist-to-file
(cl-letf (((symbol-function #'pp) #'prin1))
(funcall orig-fn)))
(save-place-mode +1))
(letf! ((#'pp #'prin1)) (funcall orig-fn))))
(use-package! server
@ -394,18 +391,14 @@ files, so we replace calls to `pp' with the much faster `prin1'."
`nim-mode'. This prevents them from leaving Emacs in a broken state."
:around #'dtrt-indent-mode
(let ((dtrt-indent-run-after-smie dtrt-indent-run-after-smie))
(cl-letf* ((old-smie-config-guess (symbol-function 'smie-config-guess))
(old-smie-config--guess (symbol-function 'symbol-config--guess))
((symbol-function 'symbol-config--guess)
(lambda (beg end)
(funcall old-smie-config--guess beg (min end 10000))))
((symbol-function 'smie-config-guess)
(lambda ()
(condition-case e (funcall old-smie-config-guess)
(letf! ((defun symbol-config--guess (beg end)
(funcall symbol-config--guess beg (min end 10000)))
(defun smie-config-guess ()
(condition-case e (funcall smie-config-guess)
(error (setq dtrt-indent-run-after-smie t)
(message "[WARNING] Indent detection: %s"
(error-message-string e))
(message "")))))) ; warn silently
(message ""))))) ; warn silently
(funcall orig-fn arg)))))
@ -421,8 +414,8 @@ files, so we replace calls to `pp' with the much faster `prin1'."
(defun doom-use-helpful-a (orig-fn &rest args)
"Force ORIG-FN to use helpful instead of the old describe-* commands."
(cl-letf (((symbol-function #'describe-function) #'helpful-function)
((symbol-function #'describe-variable) #'helpful-variable))
(letf! ((#'describe-function #'helpful-function)
(#'describe-variable #'helpful-variable))
(apply orig-fn args)))
(after! apropos
@ -486,7 +479,8 @@ files, so we replace calls to `pp' with the much faster `prin1'."
(defun doom-init-smartparens-in-minibuffer-maybe-h ()
"Enable `smartparens-mode' in the minibuffer, during `eval-expression',
`pp-eval-expression' or `evil-ex'."
(when (memq this-command '(eval-expression pp-eval-expression evil-ex))
(and (memq this-command '(eval-expression pp-eval-expression evil-ex))
smartparens-global-mode
(smartparens-mode))))
;; You're likely writing lisp in the minibuffer, therefore, disable these

10
core/core-keybinds.el
View file

@ -221,16 +221,6 @@ For example, :nvi will map to (list 'normal 'visual 'insert). See
else do (error "not a valid state: %s" l)))
;; Register keywords for proper indentation (see `map!')
(put :after 'lisp-indent-function 'defun)
(put :desc 'lisp-indent-function 'defun)
(put :leader 'lisp-indent-function 'defun)
(put :localleader 'lisp-indent-function 'defun)
(put :map 'lisp-indent-function 'defun)
(put :mode 'lisp-indent-function 'defun)
(put :prefix 'lisp-indent-function 'defun)
(put :prefix-map 'lisp-indent-function 'defun)
;; specials
(defvar doom--map-forms nil)
(defvar doom--map-fn nil)

403
core/core-lib.el
View file

@ -1,8 +1,5 @@
;;; core-lib.el -*- lexical-binding: t; -*-
(require 'cl-lib)
(require 'subr-x)
;;
;;; Helpers
@ -85,6 +82,60 @@ Accepts the same arguments as `message'."
format-string)
,@args))))
(defun doom-try-run-hook (hook)
"Run HOOK (a hook function) with better error handling.
Meant to be used with `run-hook-wrapped'."
(doom-log "Running doom hook: %s" hook)
(condition-case e
(funcall hook)
((debug error)
(signal 'doom-hook-error (list hook e))))
;; return nil so `run-hook-wrapped' won't short circuit
nil)
(defun doom-load-autoloads-file (file &optional noerror)
"Tries to load FILE (an autoloads file).
Return t on success, nil otherwise (but logs a warning)."
(condition-case e
;; Avoid `file-name-sans-extension' for premature optimization reasons.
;; `string-remove-suffix' is much cheaper (because it does no file sanity
;; checks during or after; just plain ol' string manipulation).
(load (string-remove-suffix ".el" file) noerror 'nomessage)
(doom-error
(signal (car e) (cdr e)))
((debug error)
(message "Autoload file error: %s -> %s" (file-name-nondirectory file) e)
nil)))
(defun doom-load-envvars-file (file &optional noerror)
"Read and set envvars from FILE.
If NOERROR is non-nil, don't throw an error if the file doesn't exist or is
unreadable. Returns the names of envvars that were changed."
(if (null (file-exists-p file))
(unless noerror
(signal 'file-error (list "No envvar file exists" file)))
(when-let
(env
(with-temp-buffer
(save-excursion
(insert "\0\n") ; to prevent off-by-one
(insert-file-contents file))
(save-match-data
(when (re-search-forward "\0\n *\\([^#= \n]*\\)=" nil t)
(setq
env (split-string (buffer-substring (match-beginning 1) (point-max))
"\0\n"
'omit-nulls))))))
(setq process-environment (append (nreverse env) process-environment)
exec-path (append (split-string (getenv "PATH") path-separator t)
(list exec-directory))
shell-file-name (or (getenv "SHELL") shell-file-name))
env)))
;;
;;; Functional library
(defalias 'doom-partial #'apply-partially)
(defun doom-rpartial (fn &rest args)
@ -119,6 +170,11 @@ aliases."
(call-interactively command))))
(defalias 'lambda!! 'λ!!)
(defun dir! ()
"Returns the directory of the emacs lisp file this macro is called from."
(when-let (path (file!))
(directory-file-name (file-name-directory path))))
(defun file! ()
"Return the emacs lisp file this macro is called from."
(cond ((bound-and-true-p byte-compile-current-file))
@ -128,10 +184,129 @@ aliases."
(buffer-file-name)
((error "Cannot get this file-path"))))
(defun dir! ()
"Returns the directory of the emacs lisp file this macro is called from."
(when-let (path (file!))
(directory-file-name (file-name-directory path))))
(defmacro letenv! (envvars &rest body)
"Lexically bind ENVVARS in BODY, like `let' but for `process-environment'."
(declare (indent 1))
`(let ((process-environment (copy-sequence process-environment)))
(dolist (var (list ,@(cl-loop for (var val) in envvars
collect `(cons ,var ,val))))
(setenv (car var) (cdr var)))
,@body))
(defmacro letf! (bindings &rest body)
"Temporarily rebind function and macros in BODY.
BINDINGS is either a) a list of, or a single, `defun' or `defmacro'-ish form, or
b) a list of (PLACE VALUE) bindings as `cl-letf*' would accept.
TYPE is either `defun' or `defmacro'. NAME is the name of the function. If an
original definition for NAME exists, it can be accessed as a lexical variable by
the same name, for use with `funcall' or `apply'. ARGLIST and BODY are as in
`defun'.
\(fn ((TYPE NAME ARGLIST &rest BODY) ...) BODY...)"
(declare (indent defun))
(setq body (macroexp-progn body))
(when (memq (car bindings) '(defun defmacro))
(setq bindings (list bindings)))
(dolist (binding (nreverse bindings) body)
(let ((type (car binding))
(rest (cdr binding)))
(setq
body (pcase type
(`defmacro `(cl-macrolet ((,(car rest) ,(cadr rest) ,@(cddr rest))) ,body))
(`defun `(cl-letf* ((,(car rest) (symbol-function #',(car rest)))
((symbol-function #',(car rest))
(lambda ,(cadr rest) ,@(cddr rest))))
,body))
(_
(when (eq (car-safe type) 'function)
(setq type `(symbol-function ,type)))
`(cl-letf ((,type ,@rest)) ,body)))))))
(defmacro quiet! (&rest forms)
"Run FORMS without generating any output.
This silences calls to `message', `load-file', `write-region' and anything that
writes to `standard-output'."
`(cond (doom-debug-mode ,@forms)
((not doom-interactive-mode)
(letf! ((standard-output (lambda (&rest _)))
(defun load-file (file) (load-file nil t))
(defun message (&rest _))
(defun write-region (start end filename &optional append visit lockname mustbenew)
(unless visit (setq visit 'no-message))
(funcall write-region start end filename append visit lockname mustbenew)))
,@forms))
((let ((inhibit-message t)
(save-silently t))
(prog1 ,@forms (message ""))))))
(defmacro if! (cond then &rest body)
"Expands to THEN if COND is non-nil, to BODY otherwise.
COND is checked at compile/expansion time, allowing BODY to be omitted
entirely when the elisp is byte-compiled. Use this for forms that contain
expensive macros that could safely be removed at compile time."
(declare (indent 2))
(if (eval cond)
then
(macroexp-progn body)))
(defmacro when! (cond &rest body)
"Expands to BODY if CONDITION is non-nil at compile/expansion time.
See `if!' for details on this macro's purpose."
(declare (indent 1))
(when (eval cond)
(macroexp-progn body)))
;;; Mutation
(defmacro appendq! (sym &rest lists)
"Append LISTS to SYM in place."
`(setq ,sym (append ,sym ,@lists)))
(defmacro setq! (&rest settings)
"A stripped-down `customize-set-variable' with the syntax of `setq'.
Use this instead of `setq' when you know a variable has a custom setter (a :set
property in its `defcustom' declaration). This trigger setters. `setq' does
not."
(macroexp-progn
(cl-loop for (var val) on settings by 'cddr
collect (list (or (get var 'custom-set) #'set)
(list 'quote var)
val))))
(defmacro delq! (elt list &optional fetcher)
"`delq' ELT from LIST in-place.
If FETCHER is a function, ELT is used as the key in LIST (an alist)."
`(setq ,list
(delq ,(if fetcher
`(funcall ,fetcher ,elt ,list)
elt)
,list)))
(defmacro pushnew! (place &rest values)
"Push VALUES sequentially into PLACE, if they aren't already present.
This is a variadic `cl-pushnew'."
(let ((var (make-symbol "result")))
`(dolist (,var (list ,@values) (with-no-warnings ,place))
(cl-pushnew ,var ,place :test #'equal))))
(defmacro prependq! (sym &rest lists)
"Prepend LISTS to SYM in place."
`(setq ,sym (append ,@lists ,sym)))
;;; Loading
(defmacro add-load-path! (&rest dirs)
"Add DIRS to `load-path', relative to the current file.
The current file is the file from which `add-to-load-path!' is used."
`(let ((default-directory ,(dir!))
file-name-handler-alist)
(dolist (dir (list ,@dirs))
(cl-pushnew (expand-file-name dir) load-path))))
(defmacro after! (package &rest body)
"Evaluate BODY after PACKAGE have loaded.
@ -183,58 +358,84 @@ This is a wrapper around `eval-after-load' that:
(setq body `((after! ,next ,@body))))
(car body))))))
(defmacro setq! (&rest settings)
"A stripped-down `customize-set-variable' with the syntax of `setq'.
(defun doom--handle-load-error (e target path)
(let* ((source (file-name-sans-extension target))
(err (cond ((not (featurep 'core))
(cons 'error (file-name-directory path)))
((file-in-directory-p source doom-core-dir)
(cons 'doom-error doom-core-dir))
((file-in-directory-p source doom-private-dir)
(cons 'doom-private-error doom-private-dir))
((cons 'doom-module-error doom-emacs-dir)))))
(signal (car err)
(list (file-relative-name
(concat source ".el")
(cdr err))
e))))
Use this instead of `setq' when you know a variable has a custom setter (a :set
property in its `defcustom' declaration). This trigger setters. `setq' does
not."
(macroexp-progn
(cl-loop for (var val) on settings by 'cddr
collect `(funcall (or (get ',var 'custom-set) #'set)
',var ,val))))
(defmacro load! (filename &optional path noerror)
"Load a file relative to the current executing file (`load-file-name').
(defmacro pushnew! (place &rest values)
"Push VALUES sequentially into PLACE, if they aren't already present.
This is a variadic `cl-pushnew'."
(let ((var (make-symbol "result")))
`(dolist (,var (list ,@values) (with-no-warnings ,place))
(cl-pushnew ,var ,place :test #'equal))))
FILENAME is either a file path string or a form that should evaluate to such a
string at run time. PATH is where to look for the file (a string representing a
directory path). If omitted, the lookup is relative to either `load-file-name',
`byte-compile-current-file' or `buffer-file-name' (checked in that order).
(defmacro prependq! (sym &rest lists)
"Prepend LISTS to SYM in place."
`(setq ,sym (append ,@lists ,sym)))
If NOERROR is non-nil, don't throw an error if the file doesn't exist."
(let* ((path (or path
(dir!)
(error "Could not detect path to look for '%s' in"
filename)))
(file (if path
`(expand-file-name ,filename ,path)
filename)))
`(condition-case-unless-debug e
(let (file-name-handler-alist)
(load ,file ,noerror 'nomessage))
(doom-error (signal (car e) (cdr e)))
(error (doom--handle-load-error e ,file ,path)))))
(defmacro appendq! (sym &rest lists)
"Append LISTS to SYM in place."
`(setq ,sym (append ,sym ,@lists)))
(defmacro defer-until! (condition &rest body)
"Run BODY when CONDITION is true (checks on `after-load-functions'). Meant to
serve as a predicated alternative to `after!'."
(declare (indent defun) (debug t))
`(if ,condition
(progn ,@body)
,(let ((fn (intern (format "doom--delay-form-%s-h" (sxhash (cons condition body))))))
`(progn
(fset ',fn (lambda (&rest args)
(when ,(or condition t)
(remove-hook 'after-load-functions #',fn)
(unintern ',fn nil)
(ignore args)
,@body)))
(put ',fn 'permanent-local-hook t)
(add-hook 'after-load-functions #',fn)))))
(defmacro delq! (elt list &optional fetcher)
"`delq' ELT from LIST in-place.
(defmacro defer-feature! (feature &optional fn)
"Pretend FEATURE hasn't been loaded yet, until FEATURE-hook or FN runs.
If FETCHER is a function, ELT is used as the key in LIST (an alist)."
`(setq ,list
(delq ,(if fetcher
`(funcall ,fetcher ,elt ,list)
elt)
,list)))
Some packages (like `elisp-mode' and `lisp-mode') are loaded immediately at
startup, which will prematurely trigger `after!' (and `with-eval-after-load')
blocks. To get around this we make Emacs believe FEATURE hasn't been loaded yet,
then wait until FEATURE-hook (or MODE-hook, if FN is provided) is triggered to
reverse this and trigger `after!' blocks at a more reasonable time."
(let ((advice-fn (intern (format "doom--defer-feature-%s-a" feature)))
(fn (or fn feature)))
`(progn
(setq features (delq ',feature features))
(advice-add #',fn :before #',advice-fn)
(defun ,advice-fn (&rest _)
;; Some plugins (like yasnippet) will invoke a fn early to parse
;; code, which would prematurely trigger this. In those cases, well
;; behaved plugins will use `delay-mode-hooks', which we can check for:
(when (and ,(intern (format "%s-hook" fn))
(not delay-mode-hooks))
;; ...Otherwise, announce to the world this package has been loaded,
;; so `after!' handlers can react.
(provide ',feature)
(advice-remove #',fn #',advice-fn))))))
(defmacro letenv! (envvars &rest body)
"Lexically bind ENVVARS in BODY, like `let' but for `process-environment'."
(declare (indent 1))
`(let ((process-environment (copy-sequence process-environment)))
(dolist (var (list ,@(cl-loop for (var val) in envvars
collect `(cons ,var ,val))))
(setenv (car var) (cdr var)))
,@body))
(defmacro add-load-path! (&rest dirs)
"Add DIRS to `load-path', relative to the current file.
The current file is the file from which `add-to-load-path!' is used."
`(let ((default-directory ,(dir!))
file-name-handler-alist)
(dolist (dir (list ,@dirs))
(cl-pushnew (expand-file-name dir) load-path))))
;;; Hooks
(defvar doom--transient-counter 0)
@ -360,106 +561,8 @@ If N and M = 1, there's no benefit to using this macro over `remove-hook'.
in (doom--setq-hook-fns hooks vars 'singles)
collect `(remove-hook ',hook #',fn))))
(defmacro load! (filename &optional path noerror)
"Load a file relative to the current executing file (`load-file-name').
FILENAME is either a file path string or a form that should evaluate to such a
string at run time. PATH is where to look for the file (a string representing a
directory path). If omitted, the lookup is relative to either `load-file-name',
`byte-compile-current-file' or `buffer-file-name' (checked in that order).
If NOERROR is non-nil, don't throw an error if the file doesn't exist."
(let* ((path (or path
(dir!)
(error "Could not detect path to look for '%s' in"
filename)))
(file (if path
`(expand-file-name ,filename ,path)
filename)))
`(condition-case-unless-debug e
(let (file-name-handler-alist)
(load ,file ,noerror 'nomessage))
(doom-error (signal (car e) (cdr e)))
(error
(let* ((source (file-name-sans-extension ,file))
(err (cond ((not (featurep 'core))
(cons 'error (file-name-directory path)))
((file-in-directory-p source doom-core-dir)
(cons 'doom-error doom-core-dir))
((file-in-directory-p source doom-private-dir)
(cons 'doom-private-error doom-private-dir))
((cons 'doom-module-error doom-emacs-dir)))))
(signal (car err)
(list (file-relative-name
(concat source ".el")
(cdr err))
e)))))))
(defmacro defer-until! (condition &rest body)
"Run BODY when CONDITION is true (checks on `after-load-functions'). Meant to
serve as a predicated alternative to `after!'."
(declare (indent defun) (debug t))
`(if ,condition
(progn ,@body)
,(let ((fn (intern (format "doom--delay-form-%s-h" (sxhash (cons condition body))))))
`(progn
(fset ',fn (lambda (&rest args)
(when ,(or condition t)
(remove-hook 'after-load-functions #',fn)
(unintern ',fn nil)
(ignore args)
,@body)))
(put ',fn 'permanent-local-hook t)
(add-hook 'after-load-functions #',fn)))))
(defmacro defer-feature! (feature &optional fn)
"Pretend FEATURE hasn't been loaded yet, until FEATURE-hook or FN runs.
Some packages (like `elisp-mode' and `lisp-mode') are loaded immediately at
startup, which will prematurely trigger `after!' (and `with-eval-after-load')
blocks. To get around this we make Emacs believe FEATURE hasn't been loaded yet,
then wait until FEATURE-hook (or MODE-hook, if FN is provided) is triggered to
reverse this and trigger `after!' blocks at a more reasonable time."
(let ((advice-fn (intern (format "doom--defer-feature-%s-a" feature)))
(fn (or fn feature)))
`(progn
(setq features (delq ',feature features))
(advice-add #',fn :before #',advice-fn)
(defun ,advice-fn (&rest _)
;; Some plugins (like yasnippet) will invoke a fn early to parse
;; code, which would prematurely trigger this. In those cases, well
;; behaved plugins will use `delay-mode-hooks', which we can check for:
(when (and ,(intern (format "%s-hook" fn))
(not delay-mode-hooks))
;; ...Otherwise, announce to the world this package has been loaded,
;; so `after!' handlers can react.
(provide ',feature)
(advice-remove #',fn #',advice-fn))))))
(defmacro quiet! (&rest forms)
"Run FORMS without generating any output.
This silences calls to `message', `load-file', `write-region' and anything that
writes to `standard-output'."
`(cond (doom-debug-mode ,@forms)
((not doom-interactive-mode)
(let ((old-fn (symbol-function 'write-region)))
(cl-letf ((standard-output (lambda (&rest _)))
((symbol-function 'load-file) (lambda (file) (load file nil t)))
((symbol-function 'message) (lambda (&rest _)))
((symbol-function 'write-region)
(lambda (start end filename &optional append visit lockname mustbenew)
(unless visit (setq visit 'no-message))
(funcall old-fn start end filename append visit lockname mustbenew))))
,@forms)))
((let ((inhibit-message t)
(save-silently t))
(prog1 ,@forms (message ""))))))
;;
;;; Definers
(defmacro defadvice! (symbol arglist &optional docstring &rest body)
"Define an advice called SYMBOL and add it to PLACES.

6
core/core-modules.el
View file

@ -211,13 +211,15 @@ those directories. The first returned path is always `doom-private-dir'."
(declare (pure t) (side-effect-free t))
(append (list doom-private-dir)
(if module-dirs
(mapcar (lambda (m) (doom-module-locate-path (car m) (cdr m)))
(doom-files-in (if (listp module-dirs)
module-dirs
doom-modules-dirs)
:map #'doom-module-from-path
:type 'dirs
:mindepth 1
:depth 1)
(cl-loop for plist being the hash-values of (doom-modules)
:depth 1))
(cl-loop for plist being the hash-values of doom-modules
collect (plist-get plist :path)))
nil))

8
core/core-packages.el
View file

@ -269,9 +269,13 @@ elsewhere."
recipe
;; Expand :local-repo from current directory
(when local-repo
(plist-put! plist :recipe
(plist-put!
plist :recipe
(plist-put recipe :local-repo
(expand-file-name local-repo ,(dir!)))))))
(let ((local-path (expand-file-name local-repo ,(dir!))))
(if (file-directory-p local-path)
local-path
local-repo)))))))
(error
(signal 'doom-package-error
(cons ,(symbol-name name)

10
core/core-projects.el
View file

@ -43,7 +43,7 @@ Emacs.")
;; REVIEW Resolve the project root once, when the file/buffer is opened. This
;; speeds up projectile's project root resolution by leaps, but does
;; put you at risk of having a stale project root.
(setq-hook! '(after-change-major-mode-hook
(setq-hook! '(change-major-mode-after-body-hook
;; In case the user saves the file to a new location
after-save-hook
;; ...or makes external changes then returns to Emacs
@ -146,7 +146,7 @@ c) are not valid projectile projects."
;; .gitignore. This is recommended in the projectile docs.
((executable-find doom-projectile-fd-binary)
(setq projectile-generic-command
(format "%s . --color=never --type f -0 -H -E .git"
(format "%s . -0 -H -E .git --color=never --type file --type symlink --follow"
doom-projectile-fd-binary)
projectile-git-command projectile-generic-command
projectile-git-submodule-command nil
@ -156,9 +156,11 @@ c) are not valid projectile projects."
;; Otherwise, resort to ripgrep, which is also faster than find
((executable-find "rg")
(setq projectile-generic-command
(concat "rg -0 --files --color=never --hidden"
(concat "rg -0 --files --follow --color=never --hidden"
(cl-loop for dir in projectile-globally-ignored-directories
concat (format " --glob '!%s'" dir)))
concat " --glob "
concat (shell-quote-argument (concat "!" dir)))
(if IS-WINDOWS " --path-separator /"))
projectile-git-command projectile-generic-command
projectile-git-submodule-command nil
;; ensure Windows users get rg's benefits

61
core/core-ui.el
View file

@ -54,6 +54,9 @@ examples.
It is recommended you don't set specify a font-size, as to inherit `doom-font's
size.")
(defvar doom-unicode-extra-fonts nil
"Fonts to inject into the unicode charset before `doom-unicode-font'.")
;;
;;; Custom hooks
@ -85,48 +88,51 @@ size.")
(defvar doom--last-frame nil)
(defun doom-run-switch-window-hooks-h ()
(let ((gc-cons-threshold most-positive-fixnum))
(unless (or doom-inhibit-switch-window-hooks
(eq doom--last-window (selected-window))
(minibufferp))
(let ((doom-inhibit-switch-window-hooks t)
(let ((gc-cons-threshold most-positive-fixnum)
(doom-inhibit-switch-window-hooks t)
(inhibit-redisplay t))
(run-hooks 'doom-switch-window-hook)
(setq doom--last-window (selected-window))))))
(setq doom--last-window (selected-window)))))
(defun doom-run-switch-frame-hooks-h (&rest _)
(unless (or doom-inhibit-switch-frame-hooks
(eq doom--last-frame (selected-frame))
(frame-parameter nil 'parent-frame))
(let ((doom-inhibit-switch-frame-hooks t))
(let ((gc-cons-threshold most-positive-fixnum)
(doom-inhibit-switch-frame-hooks t))
(run-hooks 'doom-switch-frame-hook)
(setq doom--last-frame (selected-frame)))))
(defun doom-run-switch-buffer-hooks-a (orig-fn buffer-or-name &rest args)
(let ((gc-cons-threshold most-positive-fixnum))
(if (or doom-inhibit-switch-buffer-hooks
(eq (current-buffer) (get-buffer buffer-or-name))
(and buffer-or-name
(eq (current-buffer)
(get-buffer buffer-or-name)))
(and (eq orig-fn #'switch-to-buffer) (car args)))
(apply orig-fn buffer-or-name args)
(let ((doom-inhibit-switch-buffer-hooks t)
(let ((gc-cons-threshold most-positive-fixnum)
(doom-inhibit-switch-buffer-hooks t)
(inhibit-redisplay t))
(when-let (buffer (apply orig-fn buffer-or-name args))
(with-current-buffer (if (windowp buffer)
(window-buffer buffer)
buffer)
(run-hooks 'doom-switch-buffer-hook))
buffer)))))
buffer))))
(defun doom-run-switch-to-next-prev-buffer-hooks-a (orig-fn &rest args)
(let ((gc-cons-threshold most-positive-fixnum))
(if doom-inhibit-switch-buffer-hooks
(apply orig-fn args)
(let ((doom-inhibit-switch-buffer-hooks t)
(let ((gc-cons-threshold most-positive-fixnum)
(doom-inhibit-switch-buffer-hooks t)
(inhibit-redisplay t))
(when-let (buffer (apply orig-fn args))
(with-current-buffer buffer
(run-hooks 'doom-switch-buffer-hook))
buffer)))))
buffer))))
(defun doom-protect-fallback-buffer-h ()
"Don't kill the scratch buffer. Meant for `kill-buffer-query-functions'."
@ -300,7 +306,7 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
(add-to-list 'default-frame-alist '(tool-bar-lines . 0))
(add-to-list 'default-frame-alist '(vertical-scroll-bars)))
(when IS-MAC
(when! IS-MAC
;; Curse Lion and its sudden but inevitable fullscreen mode!
;; NOTE Meaningless to railwaycat's emacs-mac build
(setq ns-use-native-fullscreen nil)
@ -410,13 +416,6 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
(set-window-configuration doom--ediff-saved-wconf)))))
(use-package! goto-addr
:hook (text-mode . goto-address-mode)
:hook (prog-mode . goto-address-prog-mode)
:config
(define-key goto-address-highlight-keymap (kbd "RET") #'goto-address-at-point))
(use-package! hl-line
;; Highlights the current line
:hook ((prog-mode text-mode conf-mode special-mode) . hl-line-mode)
@ -485,6 +484,14 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
all-the-icons-wicon
all-the-icons-material
all-the-icons-alltheicon)
:preface
(setq doom-unicode-extra-fonts
(list "Weather Icons"
"github-octicons"
"FontAwesome"
"all-the-icons"
"file-icons"
"Material Icons"))
:config
(cond ((daemonp)
(defadvice! doom--disable-all-the-icons-in-tty-a (orig-fn &rest args)
@ -579,8 +586,9 @@ behavior). Do not set this directly, this is let-bound in `doom-init-theme-h'.")
(set-face-attribute 'fixed-pitch-serif nil :font doom-serif-font))
(when doom-variable-pitch-font
(set-face-attribute 'variable-pitch nil :font doom-variable-pitch-font))
(when (and doom-unicode-font (fboundp 'set-fontset-font))
(set-fontset-font t 'unicode doom-unicode-font nil 'prepend)))
(when (fboundp 'set-fontset-font)
(dolist (font (append doom-unicode-extra-fonts (doom-enlist doom-unicode-font)))
(set-fontset-font t 'unicode font nil 'prepend))))
((debug error)
(if (string-prefix-p "Font not available: " (error-message-string e))
(lwarn 'doom-ui :warning
@ -611,11 +619,14 @@ behavior). Do not set this directly, this is let-bound in `doom-init-theme-h'.")
(unless no-enable
(setq doom-theme theme
doom-init-theme-p t)
;; `load-theme' doesn't disable previously enabled themes, which seems
;; like what you'd want. You could always use `enable-theme' to activate
;; multiple themes instead.
(mapc #'disable-theme (remq theme custom-enabled-themes))
(run-hooks 'doom-load-theme-hook))
result)))
(unless EMACS27+
(when! (not EMACS27+)
;; DEPRECATED Not needed in Emacs 27
(defadvice! doom--prefer-compiled-theme-a (orig-fn &rest args)
"Have `load-theme' prioritize the byte-compiled theme.
@ -624,10 +635,8 @@ This offers a moderate boost in startup (or theme switch) time, so long as
:around #'load-theme
(if (or (null after-init-time)
doom--prefer-theme-elc)
(cl-letf* ((old-locate-file (symbol-function 'locate-file))
((symbol-function 'locate-file)
(lambda (filename path &optional _suffixes predicate)
(funcall old-locate-file filename path '("c" "") predicate))))
(letf! (defun locate-file (filename path &optional _suffixes predicate)
(funcall locate-file filename path '("c" "") predicate))
(apply orig-fn args))
(apply orig-fn args))))

87
core/core.el
View file

@ -14,6 +14,10 @@
(defconst IS-WINDOWS (memq system-type '(cygwin windows-nt ms-dos)))
(defconst IS-BSD (or IS-MAC (eq system-type 'berkeley-unix)))
;; Unix tools looks for HOME, but this is normally not defined on Windows.
(when (and IS-WINDOWS (null (getenv "HOME")))
(setenv "HOME" (getenv "USERPROFILE")))
;; Ensure `doom-core-dir' is in `load-path'
(add-to-list 'load-path (file-name-directory load-file-name))
@ -40,6 +44,8 @@
(add-hook 'emacs-startup-hook #'doom-reset-file-handler-alist-h))
;; Just the bare necessities
(require 'subr-x)
(require 'cl-lib)
(require 'core-lib)
@ -207,27 +213,22 @@ users).")
;; https://www.keylength.com/en/4/
gnutls-min-prime-bits 3072
tls-checktrust gnutls-verify-error
;; Emacs is built with `gnutls' by default, so `tls-program' would not
;; be used in that case. Otherwiese, people have reasons to not go with
;; `gnutls', we use `openssl' instead.
;; For more details, see https://redd.it/8sykl1
;; Emacs is built with `gnutls' by default, so `tls-program' would not be
;; used in that case. Otherwise, people have reasons to not go with
;; `gnutls', we use `openssl' instead. For more details, see
;; https://redd.it/8sykl1
tls-program '("openssl s_client -connect %h:%p -CAfile %t -nbio -no_ssl3 -no_tls1 -no_tls1_1 -ign_eof"
"gnutls-cli -p %p --dh-bits=3072 --ocsp --x509cafile=%t \
--strict-tofu --priority='SECURE192:+SECURE128:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3' %h"
;; compatibility fallbacks
"gnutls-cli -p %p %h"))
;; Emacs stores authinfo in $HOME and in plaintext. Let's not do that, mkay?
;; Emacs stores `authinfo' in $HOME and in plain-text. Let's not do that, mkay?
;; This file stores usernames, passwords, and other such treasures for the
;; aspiring malicious third party.
(setq auth-sources (list (expand-file-name "authinfo.gpg" doom-etc-dir)
(setq auth-sources (list (concat doom-etc-dir "authinfo.gpg")
"~/.authinfo.gpg"))
;; Emacs on Windows frequently confuses HOME (C:\Users\<NAME>) and %APPDATA%,
;; causing `abbreviate-home-dir' to produce incorrect paths.
(when IS-WINDOWS
(setq abbreviated-home-dir "\\`'"))
;; Don't litter `doom-emacs-dir'. We don't use `no-littering' because it's a
;; mote too opinionated for our needs.
(setq abbrev-file-name (concat doom-local-dir "abbrev.el")
@ -274,11 +275,6 @@ users).")
;; quickly self-correct.
(setq fast-but-imprecise-scrolling t)
;; Font locking is the source of much slowness in Emacs. jit-lock-mode tries to
;; defer fontification until the user is idle. This should help... in theory.
(setq jit-lock-defer-time 0 ; only defer while processing input
jit-lock-stealth-time 2) ; fontify the rest of the buffer after a delay
;; Resizing the Emacs frame can be a terribly expensive part of changing the
;; font. By inhibiting this, we halve startup times, particularly when we use
;; fonts that are larger than the system default (which would resize the frame).
@ -288,7 +284,7 @@ users).")
(setq ffap-machine-p-known 'reject)
;; Font compacting can be terribly expensive, especially for rendering icon
;; fonts on Windows. Whether it has a noteable affect on Linux and Mac hasn't
;; fonts on Windows. Whether it has a notable affect on Linux and Mac hasn't
;; been determined, but we inhibit it there anyway.
(setq inhibit-compacting-font-caches t)
@ -432,17 +428,6 @@ If this is a daemon session, load them all immediately instead."
;;
;;; Bootstrap helpers
(defun doom-try-run-hook (hook)
"Run HOOK (a hook function) with better error handling.
Meant to be used with `run-hook-wrapped'."
(doom-log "Running doom hook: %s" hook)
(condition-case e
(funcall hook)
((debug error)
(signal 'doom-hook-error (list hook e))))
;; return nil so `run-hook-wrapped' won't short circuit
nil)
(defun doom-display-benchmark-h (&optional return-p)
"Display a benchmark including number of packages and modules loaded.
@ -455,50 +440,6 @@ If RETURN-P, return the message as a string instead of displaying it."
(setq doom-init-time
(float-time (time-subtract (current-time) before-init-time))))))
(defun doom-load-autoloads-file (file &optional noerror)
"Tries to load FILE (an autoloads file).
Return t on success, nil otherwise (but logs a warning)."
(condition-case e
(load (substring file 0 -3) noerror 'nomessage)
((debug error)
(message "Autoload file error: %s -> %s" (file-name-nondirectory file) e)
nil)))
(defun doom-load-envvars-file (file &optional noerror)
"Read and set envvars from FILE.
If NOERROR is non-nil, don't throw an error if the file doesn't exist or is
unreadable. Returns the names of envvars that were changed."
(if (not (file-readable-p file))
(unless noerror
(signal 'file-error (list "Couldn't read envvar file" file)))
(let (envvars environment)
(with-temp-buffer
(save-excursion
(insert "\n")
(insert-file-contents file))
(while (re-search-forward "\n *\\([^#= \n]*\\)=" nil t)
(push (match-string 1) envvars)
(push (buffer-substring
(match-beginning 1)
(1- (or (save-excursion
(when (re-search-forward "^\\([^= ]+\\)=" nil t)
(line-beginning-position)))
(point-max))))
environment)))
(when environment
(setq process-environment
(append (nreverse environment) process-environment)
exec-path
(if (member "PATH" envvars)
(append (split-string (getenv "PATH") path-separator t)
(list exec-directory))
exec-path)
shell-file-name
(if (member "SHELL" envvars)
(or (getenv "SHELL") shell-file-name)
shell-file-name))
envvars))))
(defun doom-initialize (&optional force-p noerror)
"Bootstrap Doom, if it hasn't already (or if FORCE-P is non-nil).
@ -517,7 +458,7 @@ The overall load order of Doom is as follows:
Module config.el files
~/.doom.d/config.el
`doom-init-modules-hook'
`doom-after-init-hook' (`after-init-hook')
`doom-after-init-modules-hook' (`after-init-hook')
`emacs-startup-hook'
`doom-init-ui-hook'
`window-setup-hook'

41
core/packages.el
View file

@ -2,47 +2,44 @@
;;; core/packages.el
;; core.el
(package! auto-minor-mode :pin "17cfa1b548")
(package! gcmh :pin "b1bde50891")
(package! auto-minor-mode :pin "17cfa1b54800fdef2975c0c0531dad34846a5065")
(package! gcmh :pin "b1bde5089169a74f62033d027e06e98cbeedd43f")
;; core-ui.el
(package! all-the-icons :pin "0b74fc3618")
(package! hide-mode-line :pin "88888825b5")
(package! highlight-numbers :pin "8b4744c7f4")
(package! rainbow-delimiters :pin "5125f4e476")
(package! restart-emacs :pin "9aa90d3df9")
(package! all-the-icons :pin "0b74fc361817e885580c3f3408079f949f5830e1")
(package! hide-mode-line :pin "88888825b5b27b300683e662fa3be88d954b1cea")
(package! highlight-numbers :pin "8b4744c7f46c72b1d3d599d4fb75ef8183dee307")
(package! rainbow-delimiters :pin "5125f4e47604ad36c3eb4706310fcafac729ca8c")
(package! restart-emacs :pin "9aa90d3df9e08bc420e1c9845ee3ff568e911bd9")
;; core-editor.el
(package! better-jumper :pin "6d240032ca")
(package! dtrt-indent :pin "9163cd990f")
(package! helpful :pin "c54e9ddbd6")
(package! better-jumper :pin "6d240032ca213ccb3347e25f26c29b6822bf03a7")
(package! dtrt-indent :pin "9163cd990fb1f43dafed3948c6e406c13a45a6be")
(package! helpful :pin "c54e9ddbd6a77858048c1a4c4b549de98af8f88e")
(when IS-MAC
(package! ns-auto-titlebar :pin "1efc30d385"))
(package! pcre2el :pin "0b5b2a2c17")
(package! smartparens :pin "555626a43f")
(package! ns-auto-titlebar :pin "1efc30d38509647b417f05587fd7003457719256"))
(package! pcre2el :pin "0b5b2a2c173aab3fd14aac6cf5e90ad3bf58fa7d")
(package! smartparens :pin "555626a43f9bb1985aa9a0eb675f2b88b29702c8")
(package! so-long
:built-in 'prefer ; included in Emacs 27+
;; REVIEW so-long is slated to be published to ELPA eventually, but until then
;; I've created my own mirror for it because git.savannah.gnu.org runs
;; on a potato.
:recipe (:host github :repo "hlissner/emacs-so-long")
:pin "ed666b0716")
:pin "ed666b0716f60e8988c455804de24b55919e71ca")
(package! ws-butler
;; Use my fork of ws-butler, which has a few choice improvements and
;; optimizations (the original has been abandoned).
:recipe (:host github :repo "hlissner/ws-butler")
:pin "2bb49d3ee7")
:pin "2bb49d3ee7d2cba133bc7e9cdac416cd1c5e4fe0")
(unless IS-WINDOWS
(package! clipetty
:recipe (:host github :repo "spudlyo/clipetty")
:pin "7ee3f9c52f"))
:pin "01b39044b9b65fa4ea7d3166f8b1ffab6f740362"))
;; core-projects.el
(package! projectile :pin "eec569dc32")
(package! projectile :pin "5cd261dd75f4d711c0016617621349e2a98b43aa")
;; core-keybinds.el
(package! general :pin "14ad4c888b")
(package! which-key :pin "8b49ae978c")
;; autoload/cache.el
(package! persistent-soft :pin "a1e0ddf2a1")
(package! general :pin "42e38034cd2305fa7432866323c923979d8f9b06")
(package! which-key :pin "8b49ae978cceca65967f3544c236f32964ddbed0")

4
docs/api.org
View file

@ -535,7 +535,7 @@ These are side-by-side comparisons, showing how to bind keys with and without
** Persist Emacs' initial frame position, dimensions and/or full-screen state across sessions
#+BEGIN_SRC elisp
;; add to ~/.doom.d/config.el
(when-let (dims (doom-cache-get 'last-frame-size))
(when-let (dims (doom-store-get 'last-frame-size))
(cl-destructuring-bind ((left . top) width height fullscreen) dims
(setq initial-frame-alist
(append initial-frame-alist
@ -546,7 +546,7 @@ These are side-by-side comparisons, showing how to bind keys with and without
(fullscreen . ,fullscreen))))))
(defun save-frame-dimensions ()
(doom-cache-set 'last-frame-size
(doom-store-set 'last-frame-size
(list (frame-position)
(frame-width)
(frame-height)

13
docs/getting_started.org
View file

@ -17,6 +17,7 @@ us know!
- [[#on-linux][On Linux]]
- [[#arch-linux][Arch Linux:]]
- [[#ubuntu][Ubuntu:]]
- [[#fedora][Fedora:]]
- [[#nixos][NixOS]]
- [[#on-macos][On macOS]]
- [[#with-homebrew][With Homebrew]]
@ -143,6 +144,14 @@ apt-get update
apt-get install emacs26
#+END_SRC
**** Fedora:
#+BEGIN_SRC bash
# required dependencies
sudo dnf install emacs git ripgrep
# optional dependencies
sudo dnf install tar fd-find clang multimarkdown ShellCheck
#+END_SRC
**** NixOS
On NixOS Emacs 26.3 can be installed via ~nix-env -Ai nixos.emacs~, or
permanently with the following added to ~etc/nixos/configuration.nix~:
@ -343,9 +352,7 @@ provides, and ~bin/doom help COMMAND~ to display documentation for a particular
#+begin_quote
I recommend you add =~/.emacs.d/bin= to your ~PATH~ so you can call =doom=
directly and from anywhere. Accomplish this by adding this to your .bashrc or
.zshrc file:
~export PATH="$HOME/.emacs.d/bin:$PATH"~
.zshrc file: ~export PATH=~/.emacs.d/bin:$PATH~
#+end_quote
*** Install Doom Manually

6
modules/app/calendar/config.el
View file

@ -42,10 +42,10 @@
org-gcal-fetch
org-gcal-post-at-point
org-gcal-delete-at-point)
:init
(defvar org-gcal-dir (concat doom-cache-dir "org-gcal/"))
(defvar org-gcal-token-file (concat org-gcal-dir "token.gpg"))
:config
;; hack to avoid the deferred.el error
(defun org-gcal--notify (title mes)
(message "org-gcal::%s - %s" title mes)))
;; (use-package! alert)

6
modules/app/calendar/packages.el
View file

@ -1,6 +1,6 @@
;; -*- no-byte-compile: t; -*-
;;; app/calendar/packages.el
(package! calfw :pin "03abce9762")
(package! calfw-org :pin "03abce9762")
(package! org-gcal :pin "6821e34967")
(package! calfw :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
(package! calfw-org :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
(package! org-gcal :pin "2ee2b31547e6f4e33db70fb812d552e55d612fd6")

4
modules/app/irc/packages.el
View file

@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; -*-
;;; app/irc/packages.el
(package! circe :pin "e5bf5f8974")
(package! circe-notifications :pin "291149ac12")
(package! circe :pin "e5bf5f89741a9c43aa406491e94dd8d58c302fb4")
(package! circe-notifications :pin "291149ac12877bbd062da993479d3533a26862b0")

5
modules/app/rss/autoload.el
View file

@ -101,10 +101,9 @@
;;;###autoload
(defun +rss-put-sliced-image-fn (spec alt &optional flags)
"TODO"
(cl-letf (((symbol-function #'insert-image)
(lambda (image &optional alt _area _slice)
(letf! (defun insert-image (image &optional alt _area _slice)
(let ((height (cdr (image-size image t))))
(insert-sliced-image image alt nil (max 1 (/ height 20.0)) 1)))))
(insert-sliced-image image alt nil (max 1 (/ height 20.0)) 1)))
(shr-put-image spec alt flags)))
;;;###autoload

4
modules/app/rss/packages.el
View file

@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; -*-
;;; app/rss/packages.el
(package! elfeed :pin "d0405e6386")
(package! elfeed-org :pin "77b6bbf222")
(package! elfeed :pin "d0405e63863e54a01200740a6717ac875eceabc1")
(package! elfeed-org :pin "77b6bbf222487809813de260447d31c4c59902c9")

4
modules/app/twitter/packages.el
View file

@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; -*-
;;; app/twitter/packages.el
(package! twittering-mode :pin "114891e8fd")
(package! avy :pin "3bf83140fa")
(package! twittering-mode :pin "114891e8fdb4f06b1326a6cf795e49c205cf9e29")
(package! avy :pin "509471bad0e8094b8639729ec39ca141fae7d4bd")

9
modules/checkers/grammar/config.el
View file

@ -8,15 +8,16 @@
:init (setq langtool-default-language "en-US")
:config
(unless (or langtool-bin
langtool-language-tool-jar)
(setq langtool-language-tool-jar
langtool-language-tool-jar
langtool-java-classpath)
(cond (IS-MAC
(setq langtool-language-tool-jar
(locate-file "libexec/languagetool-commandline.jar"
(doom-files-in "/usr/local/Cellar/languagetool"
:type 'dirs
:depth 2)))
:depth 2))))
(IS-LINUX
"/usr/share/java/languagetool/languagetool-commandline.jar")))))
(setq langtool-java-classpath "/usr/share/languagetool:/usr/share/java/languagetool/*")))))
;; Detects weasel words, passive voice and duplicates. Proselint would be a

4
modules/checkers/grammar/packages.el
View file

@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; -*-
;;; checkers/grammar/packages.el
(package! langtool :pin "a71ed02ce0")
(package! writegood-mode :pin "b71757ec33")
(package! langtool :pin "a71ed02ce06920ae3cafd6708de1c21811ce14c3")
(package! writegood-mode :pin "b71757ec337e226909fb0422f0224e31acc71733")

10
modules/checkers/spell/packages.el
View file

@ -1,11 +1,11 @@
;; -*- no-byte-compile: t; -*-
;;; checkers/spell/packages.el
(package! flyspell-correct :pin "e765d1a3d9")
(package! flyspell-correct :pin "fd8ac7a4f922ce5ea1cc5d4583a7d584847cb6b5")
(cond ((featurep! :completion ivy)
(package! flyspell-correct-ivy :pin "e765d1a3d9"))
(package! flyspell-correct-ivy))
((featurep! :completion helm)
(package! flyspell-correct-helm :pin "e765d1a3d9"))
((package! flyspell-correct-popup :pin "e765d1a3d9")))
(package! flyspell-correct-helm))
((package! flyspell-correct-popup)))
(package! flyspell-lazy :pin "3ebf68cc9e")
(package! flyspell-lazy :pin "3ebf68cc9eb10c972a2de8d7861cbabbbce69570")

6
modules/checkers/syntax/packages.el
View file

@ -1,9 +1,9 @@
;; -*- no-byte-compile: t; -*-
;;; checkers/syntax/packages.el
(package! flycheck :pin "f19a51c0f1")
(package! flycheck-popup-tip :pin "ef86aad907")
(package! flycheck :pin "246e1d4380721ca03962464f11d02dd1372860ce")
(package! flycheck-popup-tip :pin "ef86aad907f27ca076859d8d9416f4f7727619c6")
(when (featurep! +childframe)
(package! flycheck-posframe :pin "2b3e94c2e4"))
(package! flycheck-posframe :pin "2b3e94c2e427ec9831c513007460c5ea9e2225a3"))
;; TODO flymake?

23
modules/completion/company/config.el
View file

@ -11,9 +11,26 @@
company-require-match 'never
company-global-modes
'(not erc-mode message-mode help-mode gud-mode)
company-backends '(company-capf)
company-frontends '(company-pseudo-tooltip-frontend
company-echo-metadata-frontend))
company-echo-metadata-frontend)
;; Buffer-local backends will be computed when loading a major mode, so
;; only specify a global default here.
company-backends '(company-capf)
;; Company overrides `company-active-map' based on
;; `company-auto-complete-chars'; no magic please!
company-auto-complete-chars nil
;; Only search the current buffer for `company-dabbrev' (a backend that
;; suggests text your open buffers). This prevents Company from causing
;; lag once you have a lot of buffers open.
company-dabbrev-other-buffers nil
;; Make `company-dabbrev' fully case-sensitive, to improve UX with
;; domain-specific words with particular casing.
company-dabbrev-ignore-case nil
company-dabbrev-downcase nil)
:config
(when (featurep! :editor evil)
(add-hook 'company-mode-hook #'evil-normalize-keymaps)
@ -106,6 +123,8 @@
(ElispFeature . ,(all-the-icons-material "stars" :face 'all-the-icons-orange))
(ElispFace . ,(all-the-icons-material "format_paint" :face 'all-the-icons-pink)))))
(delq! 'company-echo-metadata-frontend company-frontends)
(defun +company-box-icons--elisp-fn (candidate)
(when (derived-mode-p 'emacs-lisp-mode)
(let ((sym (intern candidate)))

8
modules/completion/company/packages.el
View file

@ -1,8 +1,8 @@
;; -*- no-byte-compile: t; -*-
;;; completion/company/packages.el
(package! company :pin "61ddd9afb5")
(package! company-dict :pin "cd7b8394f6")
(package! company-prescient :pin "53307731f3")
(package! company :pin "6333fc4ebbbf4d28e834de8715561e984f149ecb")
(package! company-dict :pin "cd7b8394f6014c57897f65d335d6b2bd65dab1f4")
(package! company-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
(when (featurep! +childframe)
(package! company-box :pin "8fc6168f2d"))
(package! company-box :pin "3814fcb14e92f4b85b19e664e216a7c8d5c7144d"))

22
modules/completion/helm/packages.el
View file

@ -1,19 +1,19 @@
;; -*- no-byte-compile: t; -*-
;;; completion/helm/packages.el
(package! helm :pin "d978f20f4c")
(package! helm-rg :pin "785a80fe5c")
(package! helm-c-yasnippet :pin "65ca732b51")
(package! helm-company :pin "6eb5c2d730")
(package! helm :pin "b6db9fb47a8900704394e63b795f4a54cb4701a8")
(package! helm-rg :pin "785a80fe5cc87e27c5ea3d00a70049028d9e2847")
(package! helm-c-yasnippet :pin "65ca732b510bfc31636708aebcfe4d2d845b59b0")
(package! helm-company :pin "6eb5c2d730a60e394e005b47c1db018697094dde")
(package! helm-describe-modes
:recipe (:host github :repo "emacs-helm/helm-describe-modes")
:pin "11fb36af11")
(package! helm-projectile :pin "5328b74ddd")
(package! swiper-helm :pin "93fb6db87b")
:pin "11fb36af119b784539d31c6160002de1957408aa")
(package! helm-projectile :pin "5328b74dddcee8d1913803ca8167868831a07463")
(package! swiper-helm :pin "93fb6db87bc6a5967898b5fd3286954cc72a0008")
(when (featurep! +fuzzy)
(package! helm-flx :pin "6640fac5cb"))
(package! helm-flx :pin "6640fac5cb16bee73c95b8ed1248a4e5e113690e"))
(when (featurep! +childframe)
(package! posframe :pin "e62e584268"))
(package! posframe :pin "093b29a53cbeda6d637ccc9ef4dfc47123e79b9e"))
(when (featurep! :lang org)
(package! helm-org :pin "b7a18dfc17"))
(package! helm-descbinds :pin "b725159823")
(package! helm-org :pin "b7a18dfc17e8b933956d61d68c435eee03a96c24"))
(package! helm-descbinds :pin "b72515982396b6e336ad7beb6767e95a80fca192")

2
modules/completion/ido/config.el
View file

@ -33,7 +33,7 @@
(map! :map (ido-common-completion-map ido-file-completion-map)
"C-w" #'ido-delete-backward-word-updir
:map ido-common-completion-map
:map (ido-common-completion-map ido-file-dir-completion-map)
"C-n" #'ido-next-match
"C-p" #'ido-prev-match
[down] #'ido-next-match

10
modules/completion/ido/packages.el
View file

@ -1,8 +1,8 @@
;; -*- no-byte-compile: t; -*-
;;; completion/ido/packages.el
(package! flx-ido :pin "17f5c9cb2a")
(package! ido-completing-read+ :pin "98d3a6e56b")
(package! ido-sort-mtime :pin "f638ff0c92")
(package! ido-vertical-mode :pin "16c4c1a112")
(package! crm-custom :pin "f1aaccf643")
(package! flx-ido :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")
(package! ido-completing-read+ :pin "98d3a6e56b1d3652da7b47f49f76d77f82ea80ba")
(package! ido-sort-mtime :pin "f638ff0c922af862f5211779f2311a27fde428eb")
(package! ido-vertical-mode :pin "16c4c1a112796ee0bcf401ea39d3e2643a89feaf")
(package! crm-custom :pin "f1aaccf64306a5f99d9bf7ba815d7ea41c15518d")

15
modules/completion/ivy/config.el
View file

@ -129,7 +129,11 @@ evil-ex-specific constructs, so we disable it solely in evil-ex."
(ivy-rich-counsel-function-docstring (:face font-lock-doc-face))))
;; Apply switch buffer transformers to `counsel-projectile-switch-to-buffer' as well
'counsel-projectile-switch-to-buffer
(plist-get ivy-rich-display-transformers-list 'ivy-switch-buffer))
(plist-get ivy-rich-display-transformers-list 'ivy-switch-buffer)
'counsel-bookmark
'(:columns
((ivy-rich-candidate (:width 0.5))
(ivy-rich-bookmark-filename (:width 60)))))
;; Remove built-in coloring of buffer list; we do our own
(setq ivy-switch-buffer-faces-alist nil)
@ -260,11 +264,14 @@ evil-ex-specific constructs, so we disable it solely in evil-ex."
:override #'counsel--find-return-list
(cl-destructuring-bind (find-program . args)
(cond ((executable-find doom-projectile-fd-binary)
(cons doom-projectile-fd-binary (list "-t" "f" "-E" ".git")))
(cons doom-projectile-fd-binary
(list "--color=never" "-E" ".git"
"--type" "file" "--type" "symlink" "--follow")))
((executable-find "rg")
(append (list "rg" "--files" "--color=never" "--hidden" "--no-messages")
(append (list "rg" "--files" "--follow" "--color=never" "--hidden" "--no-messages")
(cl-loop for dir in projectile-globally-ignored-directories
collect "--glob" and collect (concat "!" dir))
collect "--glob"
collect (concat "!" dir))
(if IS-WINDOWS (list "--path-separator" "/"))))
((cons find-program args)))
(unless (listp args)

18
modules/completion/ivy/packages.el
View file

@ -1,23 +1,23 @@
;; -*- no-byte-compile: t; -*-
;;; completion/ivy/packages.el
(package! swiper :pin "64f05f4735")
(package! swiper :pin "9e0803cdb5b47e4e1844e8281516b46589ef26c7")
(package! ivy)
(package! ivy-hydra)
(package! counsel)
(package! amx :pin "e512e74e83")
(package! counsel-projectile :pin "b556ed8995")
(package! ivy-rich :pin "596874d146")
(package! wgrep :pin "5977b8e000")
(package! amx :pin "7fb7b874291e0cdeb1f0acb18564a686ec86788d")
(package! counsel-projectile :pin "b556ed8995f375e57496f3482aef4b0def565de8")
(package! ivy-rich :pin "3f818b201769bc13cc75aa73645217e374136aca")
(package! wgrep :pin "5977b8e00051c9003ca96e9d35133e0dea68db2c")
(if (featurep! +prescient)
(package! ivy-prescient :pin "53307731f3")
(package! ivy-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
(when (featurep! +fuzzy)
(package! flx :pin "17f5c9cb2a")))
(package! flx :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")))
(when (featurep! +childframe)
(package! ivy-posframe :pin "ae9bafe94f"))
(package! ivy-posframe :pin "ae9bafe94fe6b77b6fe45766ae6172646f6a5d50"))
(when (featurep! +icons)
(package! all-the-icons-ivy :pin "a70cbfa1ef"))
(package! all-the-icons-ivy :pin "a70cbfa1effe36efc946a823a580cec686d5e88d"))

13
modules/config/default/+emacs-bindings.el
View file

@ -39,13 +39,14 @@
:desc "Delete trailing whitespace" "w" #'delete-trailing-whitespace
:desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines
:desc "List errors" "x" #'flymake-show-diagnostics-buffer
(:when (featurep! :tools flycheck)
(:when (featurep! :checkers syntax)
:desc "List errors" "x" #'flycheck-list-errors)
(:when (featurep! :tools lsp)
:desc "LSP Code actions" "a" #'lsp-execute-code-action
:desc "LSP Format buffer/region" "F" #'+default/lsp-format-region-or-buffer
:desc "LSP Organize imports" "i" #'lsp-organize-imports
:desc "LSP Rename" "r" #'lsp-rename
(:after lsp-mode
:desc "LSP" "l" lsp-command-map)
(:when (featurep! :completion ivy)
:desc "Jump to symbol in current workspace" "j" #'lsp-ivy-workspace-symbol
:desc "Jump to symbol in any workspace" "J" #'lsp-ivy-global-workspace-symbol)
@ -180,7 +181,7 @@
:desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
(:when (featurep! :ui treemacs)
:desc "Project sidebar" "p" #'+treemacs/toggle
:desc "Find file in project rsidebar" "P" #'+treemacs/find-file)
:desc "Find file in project rsidebar" "P" #'treemacs-find-file)
(:when (featurep! :term shell)
:desc "Toggle shell popup" "t" #'+shell/toggle
:desc "Open shell here" "T" #'+shell/here)
@ -247,14 +248,14 @@
:desc "Indent style" "I" #'doom/toggle-indent-style
:desc "Line numbers" "l" #'doom/toggle-line-numbers
:desc "Word-wrap mode" "w" #'+word-wrap-mode
(:when (featurep! :tools flycheck)
(:when (featurep! :checkers syntax)
:desc "Flycheck" "f" #'flycheck-mode)
(:when (featurep! :ui indent-guides)
:desc "Indent guides" "i" #'highlight-indent-guides-mode)
(:when (featurep! :lang org +present)
:desc "org-tree-slide mode" "p" #'+org-present/start)
:desc "Read-only mode" "r" #'read-only-mode
(:when (featurep! :tools flyspell)
(:when (featurep! :checkers spell)
:desc "Flyspell" "s" #'flyspell-mode)
(:when (featurep! :lang org +pomodoro)
:desc "Pomodoro timer" "t" #'org-pomodoro)
@ -541,4 +542,4 @@
;;; treemacs
(:when (featurep! :ui treemacs)
"<f9>" #'+treemacs/toggle
"<C-f9>" #'+treemacs/find-file))
"<C-f9>" #'treemacs-find-file))

13
modules/config/default/+evil-bindings.el
View file

@ -26,6 +26,9 @@
"C-k" #'previous-line
"C-S-j" #'scroll-up-command
"C-S-k" #'scroll-down-command)
(define-key! :states 'insert :keymaps +default-minibuffer-maps
"C-j" #'next-line
"C-k" #'previous-line)
(define-key! read-expression-map
"C-j" #'next-line-or-history-element
"C-k" #'previous-line-or-history-element)))
@ -341,7 +344,6 @@
;;; <leader> c --- code
(:prefix-map ("c" . "code")
:desc "LSP Execute code action" "a" #'lsp-execute-code-action
:desc "Compile" "c" #'compile
:desc "Recompile" "C" #'recompile
:desc "Jump to definition" "d" #'+lookup/definition
@ -349,8 +351,6 @@
:desc "Evaluate buffer/region" "e" #'+eval/buffer-or-region
:desc "Evaluate & replace region" "E" #'+eval:replace-region
:desc "Format buffer/region" "f" #'+format/region-or-buffer
:desc "LSP Format buffer/region" "F" #'+default/lsp-format-region-or-buffer
:desc "LSP Organize imports" "i" #'lsp-organize-imports
(:when (featurep! :completion ivy)
:desc "Jump to symbol in current workspace" "j" #'lsp-ivy-workspace-symbol
:desc "Jump to symbol in any workspace" "J" #'lsp-ivy-global-workspace-symbol)
@ -358,7 +358,12 @@
:desc "Jump to symbol in current workspace" "j" #'helm-lsp-workspace-symbol
:desc "Jump to symbol in any workspace" "J" #'helm-lsp-global-workspace-symbol)
:desc "Jump to documentation" "k" #'+lookup/documentation
(:when (featurep! :tools lsp)
:desc "LSP Execute code action" "a" #'lsp-execute-code-action
:desc "LSP Organize imports" "i" #'lsp-organize-imports
:desc "LSP Rename" "r" #'lsp-rename
(:after lsp-mode
:desc "LSP" "l" lsp-command-map))
:desc "Send to repl" "s" #'+eval/send-region-to-repl
:desc "Delete trailing whitespace" "w" #'delete-trailing-whitespace
:desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines
@ -523,7 +528,7 @@
:desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
(:when (featurep! :ui treemacs)
:desc "Project sidebar" "p" #'+treemacs/toggle
:desc "Find file in project sidebar" "P" #'+treemacs/find-file)
:desc "Find file in project sidebar" "P" #'treemacs-find-file)
(:when (featurep! :term shell)
:desc "Toggle shell popup" "t" #'+shell/toggle
:desc "Open shell here" "T" #'+shell/here)

6
modules/config/default/autoload/search.el
View file

@ -25,7 +25,8 @@ If prefix ARG is set, prompt for a directory to search from."
"Conduct a text search in the current project root.
If prefix ARG is set, prompt for a known project to search from."
(interactive "P")
(let* ((disabled-command-function nil)
(let* ((projectile-project-root nil)
(disabled-command-function nil)
(default-directory
(if arg
(if-let (projects (projectile-relevant-known-projects))
@ -51,7 +52,8 @@ If prefix ARG is set, prompt for a known project to search from."
(interactive
(list (rxt-quote-pcre (or (doom-thing-at-point-or-region) ""))
current-prefix-arg))
(let ((default-directory
(let* ((projectile-project-root nil)
(default-directory
(if arg
(if-let (projects (projectile-relevant-known-projects))
(completing-read "Switch to project: " projects

15
modules/config/default/autoload/text.el
View file

@ -50,21 +50,6 @@ If `buffer-file-name' isn't set, uses `default-directory'."
(abbreviate-file-name path)
(file-name-nondirectory path)))))
;;;###autoload
(defun +default--newline-indent-and-continue-comments-a ()
"A replacement for `newline-and-indent'.
Continues comments if executed from a commented line, with special support for
languages with weak native comment continuation support (like C-family
languages)."
(interactive)
(if (and (sp-point-in-comment)
comment-line-break-function)
(funcall comment-line-break-function nil)
(delete-horizontal-space t)
(newline nil t)
(indent-according-to-mode)))
(defun doom--backward-delete-whitespace-to-column ()
"Delete back to the previous column of whitespace, or as much whitespace as

27
modules/config/default/config.el
View file

@ -1,5 +1,8 @@
;;; config/default/config.el -*- lexical-binding: t; -*-
(defvar +default-want-RET-continue-comments t
"If non-nil, RET will continue commented lines.")
(defvar +default-minibuffer-maps
(append '(minibuffer-local-map
minibuffer-local-ns-map
@ -220,8 +223,28 @@
;; f) do none of this when inside a string
(advice-add #'delete-backward-char :override #'+default--delete-backward-char-a))
;; Makes `newline-and-indent' continue comments (and more reliably)
(advice-add #'newline-and-indent :override #'+default--newline-indent-and-continue-comments-a))
;; HACK Makes `newline-and-indent' continue comments (and more reliably).
;; Consults `doom-point-in-comment-functions' to detect a commented
;; region and uses that mode's `comment-line-break-function' to continue
;; comments. If neither exists, it will fall back to the normal behavior
;; of `newline-and-indent'.
;;
;; We use an advice here instead of a remapping because many modes define
;; and remap to their own newline-and-indent commands, and tackling all
;; those cases was judged to be more work than dealing with the edge
;; cases on a case by case basis.
(defadvice! +default--newline-indent-and-continue-comments-a (&rest _)
"A replacement for `newline-and-indent'.
Continues comments if executed from a commented line. Consults
`doom-point-in-comment-functions' to determine if in a comment."
:before-until #'newline-and-indent
(interactive "*")
(when (and +default-want-RET-continue-comments
(doom-point-in-comment-p)
(fboundp comment-line-break-function))
(funcall comment-line-break-function nil)
t)))
;;

8
modules/config/default/packages.el
View file

@ -1,9 +1,9 @@
;; -*- no-byte-compile: t; -*-
;;; config/default/packages.el
(package! avy :pin "3bf83140fa")
(package! drag-stuff :pin "6d06d846cd")
(package! link-hint :pin "0d9cabcdb7")
(package! avy :pin "509471bad0e8094b8639729ec39ca141fae7d4bd")
(package! drag-stuff :pin "6d06d846cd37c052d79acd0f372c13006aa7e7c8")
(package! link-hint :pin "7440704cacb5c0fab35fff8ec59d30fbea17f44a")
(unless (featurep! :editor evil)
(package! expand-region :pin "ea6b4cbb99"))
(package! expand-region :pin "ea6b4cbb9985ddae532bd2faf9bb00570c9f2781"))

6
modules/editor/evil/autoload/advice.el
View file

@ -123,8 +123,7 @@ more information on modifiers."
(not (eq this-command 'evil-open-below))
(evil-insert-state-p))
(funcall orig-fn count)
(cl-letf (((symbol-function 'evil-insert-newline-below)
(lambda () (+evil--insert-newline))))
(letf! (defun evil-insert-newline-below () (+evil--insert-newline))
(let ((evil-auto-indent evil-auto-indent))
(funcall orig-fn count)))))
@ -134,8 +133,7 @@ more information on modifiers."
(not (eq this-command 'evil-open-above))
(evil-insert-state-p))
(funcall orig-fn count)
(cl-letf (((symbol-function 'evil-insert-newline-above)
(lambda () (+evil--insert-newline 'above))))
(letf! (defun evil-insert-newline-above () (+evil--insert-newline 'above))
(let ((evil-auto-indent evil-auto-indent))
(funcall orig-fn count)))))

11
modules/editor/evil/config.el
View file

@ -280,8 +280,13 @@ directives. By default, this only recognizes C directives.")
evil-escape-delay 0.15)
(evil-define-key* '(insert replace visual operator) 'global "\C-g" #'evil-escape)
:config
;; no `evil-escape' in minibuffer
(add-hook 'evil-escape-inhibit-functions #'minibufferp)
;; no `evil-escape' in minibuffer, unless `evil-collection-setup-minibuffer'
;; is enabled, where we could be in insert mode in the minibuffer.
(add-hook! 'evil-escape-inhibit-functions
(defun +evil-inhibit-escape-in-minibuffer-fn ()
(and (minibufferp)
(or (not (bound-and-true-p evil-collection-setup-minibuffer))
(evil-normal-state-p)))))
;; so that evil-escape-mode-hook runs, and can be toggled by evil-mc
(evil-escape-mode +1))
@ -488,7 +493,7 @@ To change these keys see `+evil-repeat-keys'."
:n "gr" #'notmuch-refresh-this-buffer
:n "gR" #'notmuch-poll-and-refresh-this-buffer)
(:after elfeed
:map elfeed-search-update--force
:map elfeed-search-mode-map
:n "gr" #'elfeed-search-update--force
:n "gR" #'elfeed-search-fetch))

3
modules/editor/evil/init.el
View file

@ -260,7 +260,8 @@ and complains if a module is loaded too early (during startup)."
(+evil-collection-init '(occur replace)))
(add-transient-hook! 'minibuffer-setup-hook
(when evil-collection-setup-minibuffer
(+evil-collection-init 'minibuffer)))
(+evil-collection-init 'minibuffer)
(evil-collection-minibuffer-insert)))
;; HACK Do this ourselves because evil-collection break's `eval-after-load'
;; load order by loading their target plugin before applying keys. This

38
modules/editor/evil/packages.el
View file

@ -1,27 +1,29 @@
;; -*- no-byte-compile: t; -*-
;;; editor/evil/packages.el
(package! evil :pin "8aa6337fa8")
(package! evil-args :pin "758ad5ae54")
(package! evil-easymotion :pin "79c13ed3bc")
(package! evil-embrace :pin "4379adea03")
(package! evil-escape :pin "f4e9116bfb")
(package! evil-exchange :pin "3030e21ee1")
(package! evil-indent-plus :pin "0c7501e6ef")
(package! evil-lion :pin "6b03593f5d")
(package! evil-nerd-commenter :pin "747e346f11")
(package! evil :pin "d243eae8649272799ec3864fde14c1164f036940")
(package! evil-args :pin "758ad5ae54ad34202064fec192c88151c08cb387")
(package! evil-easymotion :pin "f96c2ed38ddc07908db7c3c11bcd6285a3e8c2e9")
(package! evil-embrace :pin "4379adea032b25e359d01a36301b4a5afdd0d1b7")
(package! evil-escape
:recipe (:host github :repo "hlissner/evil-escape")
:pin "819f1ee1cf3f69a1ae920e6004f2c0baeebbe077")
(package! evil-exchange :pin "3030e21ee16a42dfce7f7cf86147b778b3f5d8c1")
(package! evil-indent-plus :pin "0c7501e6efed661242c3a20e0a6c79a6455c2c40")
(package! evil-lion :pin "6b03593f5dd6e7c9ca02207f9a73615cf94c93ab")
(package! evil-nerd-commenter :pin "1bd2de52011c39777a3e8779b14cee2790dc873b")
(package! evil-numbers
:recipe (:host github :repo "janpath/evil-numbers")
:pin "c2cfdd1eb1")
(package! evil-snipe :pin "3ec8adfd49")
(package! evil-surround :pin "9b0b17f06c")
(package! evil-textobj-anyblock :pin "ff00980f06")
(package! evil-traces :pin "bc25cae9fa")
(package! evil-visualstar :pin "06c053d8f7")
(package! exato :pin "d5daea3017")
:pin "c2cfdd1eb1f193bea28ee79b191b78309677058a")
(package! evil-snipe :pin "2ba6353bb9253dbbc4193f1d35403e7dcc1317b1")
(package! evil-surround :pin "9b0b17f06cef9bac81ee4800d121265e54718a17")
(package! evil-textobj-anyblock :pin "ff00980f0634f95bf2ad9956b615a155ea8743be")
(package! evil-traces :pin "bc25cae9fa5ab0ba1507827f0944f52ce0ca7462")
(package! evil-visualstar :pin "06c053d8f7381f91c53311b1234872ca96ced752")
(package! exato :pin "d5daea30176d48e74c9d063ac9bfc240ebeb97d0")
(package! evil-quick-diff
:recipe (:host github :repo "rgrinberg/evil-quick-diff")
:pin "69c883720b")
:pin "69c883720b30a892c63bc89f49d4f0e8b8028908")
;;
(when (featurep! +everywhere)
@ -31,4 +33,4 @@
(package! neotree)
(autoload 'neotree-make-executor "neotree" nil nil 'macro))
(package! evil-collection :pin "493d523c9b"))
(package! evil-collection :pin "ba3630476b3927d9d2e3ec75308a28e3a5bd54a8"))

2
modules/editor/file-templates/packages.el
View file

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*-
;;; editor/file-templates/packages.el
(package! yasnippet :pin "ac03c2f192")
(package! yasnippet :pin "5b1217ab085fab4abeb1118dccb260691b446703")

4
modules/editor/fold/packages.el
View file

@ -3,6 +3,6 @@
(package! hideshow :built-in t)
(package! vimish-fold :pin "d3248a41a7")
(package! vimish-fold :pin "63685239655a151181b9152e45478dad587f86f2")
(when (featurep! :editor evil)
(package! evil-vimish-fold :pin "b6e0e6b91b"))
(package! evil-vimish-fold :pin "b6e0e6b91b8cd047e80debef1a536d9d49eef31a"))

4
modules/editor/format/autoload/format.el
View file

@ -219,9 +219,11 @@ snippets or single lines."
is selected)."
(interactive)
(call-interactively
(if (bound-and-true-p lsp-mode)
#'+default/lsp-format-region-or-buffer
(if (use-region-p)
#'+format/region
#'+format/buffer)))
#'+format/buffer))))
;;

2
modules/editor/god/packages.el
View file

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*-
;;; editor/god/packages.el
(package! god-mode :pin "1eb6ef3a4f")
(package! god-mode :pin "1eb6ef3a4f67a805c5d6deb1e3895b6c853707d7")

4
modules/editor/lispy/packages.el
View file

@ -1,6 +1,6 @@
;; -*- no-byte-compile: t; -*-
;;; editor/lispyville/packages.el
(package! lispy :pin "c7e282ae06")
(package! lispy :pin "cdaa9c70ca39a880163cbbce924bb46cc56b9fa4")
(when (featurep! :editor evil)
(package! lispyville :pin "25a70126ea"))
(package! lispyville :pin "25a70126ea807653e0a8c512d4128c90ed673d7a"))

6
modules/editor/multiple-cursors/packages.el
View file

@ -3,7 +3,7 @@
(cond
((featurep! :editor evil)
(package! evil-multiedit :pin "9f271e0e60")
(package! evil-mc :pin "4d4c0172e4"))
(package! evil-multiedit :pin "9f271e0e6048297692f80ed6c5ae8994ac523abc")
(package! evil-mc :pin "4d4c0172e4c7f80acc1d0e73d5fb3e536929b262"))
((package! multiple-cursors :pin "b880554d04")))
((package! multiple-cursors :pin "b880554d04b8f61165afba7d4de19ac9e39bb7ab")))

2
modules/editor/objed/packages.el
View file

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*-
;;; editor/objed/packages.el
(package! objed :pin "8dc17701d1")
(package! objed :pin "e89d8dae3b2d4331a4455d2a7b203500537d184d")

2
modules/editor/parinfer/packages.el
View file

@ -11,4 +11,4 @@
;; separate session:
(autoload 'evil-define-key "evil-core" nil nil 'macro))
(package! parinfer :pin "eaad857ae4")
(package! parinfer :pin "eaad857ae4351f72a561ee3dec8943713510003f")

2
modules/editor/rotate-text/packages.el
View file

@ -3,4 +3,4 @@
(package! rotate-text
:recipe (:host github :repo "debug-ito/rotate-text.el")
:pin "48f193697d")
:pin "48f193697db996855aee1ad2bc99b38c6646fe76")

2
modules/editor/snippets/config.el
View file

@ -102,6 +102,6 @@
us who use yas-minor-mode and enable yasnippet more selectively. This advice
swaps `yas-global-mode' with `yas-minor-mode'."
:around '(aya-expand aya-open-line)
(cl-letf (((symbol-function #'yas-global-mode) #'yas-minor-mode)
(letf! ((#'yas-global-mode #'yas-minor-mode)
(yas-global-mode yas-minor-mode))
(apply orig-fn args))))

6
modules/editor/snippets/packages.el
View file

@ -1,10 +1,10 @@
;; -*- no-byte-compile: t; -*-
;;; editor/snippets/packages.el
(package! yasnippet :pin "5b1217ab08")
(package! auto-yasnippet :pin "db9e0dd433")
(package! yasnippet :pin "5b1217ab085fab4abeb1118dccb260691b446703")
(package! auto-yasnippet :pin "db9e0dd4335b2202cd5dac95bbbc87a1032d9bbe")
(package! doom-snippets
:recipe (:host github
:repo "hlissner/doom-snippets"
:files ("*.el" "*"))
:pin "feaedeb550")
:pin "422f683adfbec1b01fe00524690b64dc9e702ae0")

4
modules/editor/word-wrap/config.el
View file

@ -24,3 +24,7 @@ Otherwise no extra indentation will be used.")
'(text-mode markdown-mode markdown-view-mode gfm-mode gfm-view-mode rst-mode
latex-mode LaTeX-mode)
"Major-modes where `+word-wrap-mode' should not provide extra indentation.")
(when (memq 'visual-line-mode text-mode-hook)
(remove-hook 'text-mode-hook #'visual-line-mode)
(add-hook 'text-mode-hook #'+word-wrap-mode))

2
modules/editor/word-wrap/packages.el
View file

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*-
;;; editor/word-wrap/packages.el
(package! adaptive-wrap :pin "1810c0ee8d")
(package! adaptive-wrap :pin "1810c0ee8d827dd502ddeaae5bd759d4811fcbce")

8
modules/emacs/dired/config.el Executable file → Normal file
View file

@ -31,7 +31,7 @@
(setq insert-directory-program gls)
;; BSD ls doesn't support --group-directories-first
(setq args (delete "--group-directories-first" args))))
(setq dired-listing-switches (string-join args " ")))
(setq dired-listing-switches (string-join args " "))
(add-hook! 'dired-mode-hook
(defun +dired-disable-gnu-ls-flags-in-tramp-buffers-h ()
@ -40,11 +40,7 @@
This is because there's no guarantee the remote system has GNU ls, which is the
only variant that supports --group-directories-first."
(when (file-remote-p default-directory)
(setq-local dired-listing-switches
(string-join
(split-string dired-listing-switches
"--group-directories-first")
" ")))))
(setq-local dired-listing-switches (car args))))))
;; Don't complain about this command being disabled when we use it
(put 'dired-find-alternate-file 'disabled nil)

14
modules/emacs/dired/packages.el
View file

@ -1,12 +1,12 @@
;; -*- no-byte-compile: t; -*-
;;; emacs/dired/packages.el
(package! diredfl :pin "83567d00af")
(package! dired-git-info :pin "b47f2b0c3a")
(package! diff-hl :pin "2cf8b489f3")
(package! dired-rsync :pin "bfd5c155be")
(package! diredfl :pin "83567d00affce66a4e501563eddd0bd436ac48d0")
(package! dired-git-info :pin "b47f2b0c3a6cb9b7a62a4ee2605a492e512d40a9")
(package! diff-hl :pin "a625033fb1dde83f6e4c2fc21f632b22ec34b609")
(package! dired-rsync :pin "bfd5c155be1cb6b71c83e5f41116c81b6532b6d5")
(when (featurep! +ranger)
(package! ranger :pin "af6f781a60"))
(package! ranger :pin "ae9b3816a6da927cca5beb62c45400103797a2da"))
(when (featurep! +icons)
(package! all-the-icons-dired :pin "816987d339"))
(package! fd-dired :pin "fd4c3f490b")
(package! all-the-icons-dired :pin "fc2dfa1e9eb8bf1c402a675e7089638d702a27a5"))
(package! fd-dired :pin "001cc95effdd5c4d9974b3f2c40b2ddf1f0e3de2")

4
modules/emacs/ibuffer/packages.el
View file

@ -1,5 +1,5 @@
;; -*- no-byte-compile: t; -*-
;;; emacs/ibuffer/packages.el
(package! ibuffer-projectile :pin "504b0edaa0")
(package! ibuffer-vc :pin "1249c1e30c")
(package! ibuffer-projectile :pin "504b0edaa0d937ce60ccc8fdf09f2dae0a90fbaf")
(package! ibuffer-vc :pin "1249c1e30cf11badfe032ac3b1058f24ba510ace")

6
modules/emacs/undo/packages.el
View file

@ -2,6 +2,6 @@
;;; emacs/undo/packages.el
(if (featurep! +tree)
(package! undo-tree :pin "5b6df03781")
(package! undo-fu :pin "0c34b6747e")
(package! undo-fu-session :pin "b808ef0cdc"))
(package! undo-tree :pin "5b6df03781495d8a25695d846b0cce496d3d3058")
(package! undo-fu :pin "0ce9ac36144e80316fff50bfe1bc5dd7e5e7ded6")
(package! undo-fu-session :pin "b808ef0cdcdd2eef221c67eda567eed7fcb3d4af"))

8
modules/emacs/vc/packages.el
View file

@ -5,7 +5,7 @@
(package! vc-annotate :built-in t)
(package! smerge-mode :built-in t)
(package! browse-at-remote :pin "6aecae4b5d")
(package! git-timemachine :pin "391eb61050")
(package! gitconfig-mode :pin "55468314a5")
(package! gitignore-mode :pin "55468314a5")
(package! browse-at-remote :pin "6aecae4b5d202e582425fc8aa2c9c2b6a4779f25")
(package! git-timemachine :pin "391eb61050de321101e631fcf373fc70ec6e7700")
(package! gitconfig-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")
(package! gitignore-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")

3
modules/email/mu4e/config.el
View file

@ -92,6 +92,9 @@
;; Wrap text in messages
(setq-hook! 'mu4e-view-mode-hook truncate-lines nil)
;; Html mails might be better rendered in a browser
(add-to-list 'mu4e-view-actions '("View in browser" . mu4e-action-view-in-browser))
(when (fboundp 'imagemagick-register-types)
(imagemagick-register-types))

8
modules/email/notmuch/packages.el
View file

@ -1,9 +1,9 @@
;; -*- no-byte-compile: t; -*-
;;; email/notmuch/packages.el
(package! notmuch :pin "aba7fb375b")
(package! org-mime :pin "b189976217")
(package! notmuch :pin "ad9c2e91a012920bebfe70bc472d44678abc3259")
(package! org-mime :pin "9f8444603806e6baa94b2b67a23aab0ea52fef97")
(when (featurep! :completion ivy)
(package! counsel-notmuch :pin "a4a1562935"))
(package! counsel-notmuch :pin "a4a1562935e4180c42524c51609d1283e9be0688"))
(when (featurep! :completion helm)
(package! helm-notmuch :pin "97a01497e0"))
(package! helm-notmuch :pin "97a01497e079a7b6505987e9feba6b603bbec288"))

8
modules/email/wanderlust/packages.el
View file

@ -4,8 +4,8 @@
;; HACK These are wanderlust's dependencies (wanderlust depends on semi, semi
;; depends on flim, flim on apel), but they all have non-standard default
;; branches which straight cannot detect without our help.
(package! apel :recipe (:branch "apel-wl") :pin "d146ddbf88")
(package! flim :recipe (:branch "flim-1_14-wl") :pin "e4bd54fd7d")
(package! semi :recipe (:branch "semi-1_14-wl") :pin "16228dc2d1")
(package! apel :recipe (:branch "apel-wl") :pin "d146ddbf8818e81d3577d5eee7825d377bec0c73")
(package! flim :recipe (:branch "flim-1_14-wl") :pin "f303f2f6c124bc8635add96d3326a2209749437b")
(package! semi :recipe (:branch "semi-1_14-wl") :pin "57a948c5f07e57e78ab3c0e6fd76ffcd591bb4ac")
(package! wanderlust :pin "7a919e422a")
(package! wanderlust :pin "7af0d582cd48a37469e0606ea35887740d78c8b5")

8
modules/input/chinese/packages.el
View file

@ -1,7 +1,7 @@
;; -*- no-byte-compile: t; -*-
;;; input/chinese/packages.el
(package! pyim :pin "77170724fa")
(package! fcitx :pin "12dc2638dd")
(package! ace-pinyin :pin "8b2e9335b0")
(package! pangu-spacing :pin "f92898949b")
(package! pyim :pin "b934273bb33d6be6aea6e20e68930bc5aaf4a48a")
(package! fcitx :pin "12dc2638ddd15c8f6cfaecb20e1f428ab2bb5624")
(package! ace-pinyin :pin "8b2e9335b02486730ea4ceee790130cc5328f9ea")
(package! pangu-spacing :pin "f92898949ba3bf991fd229416f3bbb54e9c6c223")

8
modules/input/japanese/packages.el
View file

@ -1,7 +1,7 @@
;; -*- no-byte-compile: t; -*-
;;; input/japanese/packages.el
(package! migemo :pin "f42832c8ac")
(package! avy-migemo :pin "922a6dd82c")
(package! ddskk :pin "f9a2333ec3")
(package! pangu-spacing :pin "f92898949b")
(package! migemo :pin "f42832c8ac462ecbec9a16eb781194f876fba64a")
(package! avy-migemo :pin "922a6dd82c0bfa316b0fbb56a9d4dd4ffa5707e7")
(package! ddskk :pin "11d91b4cce988e15d7c5fc4345535c9d7a92d53b")
(package! pangu-spacing :pin "f92898949ba3bf991fd229416f3bbb54e9c6c223")

14
modules/lang/common-lisp/config.el
View file

@ -73,7 +73,17 @@
((message "WARNING: Couldn't find `inferior-lisp-program' (%s)"
inferior-lisp-program)))))
(map! :localleader
(map! (:map sly-db-mode-map
:n "gr" #'sly-db-restart-frame)
(:map sly-inspector-mode-map
:n "gr" #'sly-inspector-reinspect
:n "gR" #'sly-inspector-fetch-all
:n "K" #'sly-inspector-describe-inspectee)
(:map sly-xref-mode-map
:n "gr" #'sly-recompile-xref
:n "gR" #'sly-recompile-all-xrefs)
(:localleader
:map lisp-mode-map
:desc "Sly" "'" #'sly
:desc "Sly (ask)" ";" (λ!! #'sly '-)
@ -130,7 +140,7 @@
(:prefix ("t" . "trace")
:desc "Toggle" "t" #'sly-toggle-trace-fdefinition
:desc "Toggle (fancy)" "T" #'sly-toggle-fancy-trace
:desc "Untrace all" "u" #'sly-untrace-all))
:desc "Untrace all" "u" #'sly-untrace-all)))
(when (featurep! :editor evil +everywhere)
(add-hook 'sly-mode-hook #'evil-normalize-keymaps)))

2
modules/lang/dart/packages.el
View file

@ -4,7 +4,7 @@
(package! dart-mode :pin "04fcd649f1")
(when (featurep! +lsp)
(package! lsp-dart :pin "4cd73b77f4"))
(package! lsp-dart :pin "80f8ecaf62"))
(when (featurep! +flutter)
(package! flutter :pin "293b7225b9")

61
modules/lang/emacs-lisp/autoload.el
View file

@ -221,6 +221,67 @@ verbosity when editing a file in `doom-private-dir' or `doom-emacs-dir'."
(default-value 'flycheck-emacs-lisp-check-form)
")"))))
;;;###autoload
(defun +emacs-lisp-truncate-pin ()
"Truncates long SHA1 hashes in `package!' :pin's."
(save-excursion
(goto-char (match-beginning 0))
(and (stringp (plist-get (sexp-at-point) :pin))
(search-forward ":pin" nil t)
(let ((start (re-search-forward "\"[^\"]\\{10\\}" nil t))
(finish (and (re-search-forward "\"" (line-end-position) t)
(match-beginning 0))))
(when (and start finish)
(put-text-property start finish 'display "...")))))
nil)
;;;###autoload
(defun +emacs-lisp-indent-function (indent-point state)
"A replacement for `lisp-indent-function'.
Indents plists more sensibly. Adapted from
https://emacs.stackexchange.com/questions/10230/how-to-indent-keywords-aligned"
(let ((normal-indent (current-column))
(orig-point (point))
;; TODO Refactor `target' usage (ew!)
target)
(goto-char (1+ (elt state 1)))
(parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
(cond ((and (elt state 2)
(or (not (looking-at-p "\\sw\\|\\s_"))
(eq (char-after) ?:)))
(unless (> (save-excursion (forward-line 1) (point))
calculate-lisp-indent-last-sexp)
(goto-char calculate-lisp-indent-last-sexp)
(beginning-of-line)
(parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t))
(backward-prefix-chars)
(current-column))
((and (save-excursion
(goto-char indent-point)
(skip-syntax-forward " ")
(not (eq (char-after) ?:)))
(save-excursion
(goto-char orig-point)
(and (eq (char-after) ?:)
(eq (char-before) ?\()
(setq target (current-column)))))
(save-excursion
(move-to-column target t)
target))
((let* ((function (buffer-substring (point) (progn (forward-sexp 1) (point))))
(method (or (function-get (intern-soft function) 'lisp-indent-function)
(get (intern-soft function) 'lisp-indent-hook))))
(cond ((or (eq method 'defun)
(and (null method)
(> (length function) 3)
(string-match-p "\\`def" function)))
(lisp-indent-defform state indent-point))
((integerp method)
(lisp-indent-specform method state indent-point normal-indent))
(method
(funcall method indent-point state))))))))
;;;###autoload
(defun +emacs-lisp/edebug-instrument-defun-on ()
"Toggle on instrumentalisation for the function under `defun'."

8
modules/lang/emacs-lisp/config.el
View file

@ -43,7 +43,9 @@ This marks a foldable marker for `outline-minor-mode' in elisp buffers.")
mode-name "Elisp"
;; Don't treat autoloads or sexp openers as outline headers, we have
;; hideshow for that.
outline-regexp +emacs-lisp-outline-regexp)
outline-regexp +emacs-lisp-outline-regexp
;; Fixed indenter that intends plists sensibly.
lisp-indent-function #'+emacs-lisp-indent-function)
;; variable-width indentation is superior in elisp
(add-to-list 'doom-detect-indentation-excluded-modes 'emacs-lisp-mode nil #'eq)
@ -75,7 +77,9 @@ This marks a foldable marker for `outline-minor-mode' in elisp buffers.")
("^;;;###\\(autodef\\|if\\|package\\)[ \n]" (1 font-lock-warning-face t)))
;; highlight defined, special variables & functions
(when +emacs-lisp-enable-extra-fontification
`((+emacs-lisp-highlight-vars-and-faces . +emacs-lisp--face)))))
`((+emacs-lisp-highlight-vars-and-faces . +emacs-lisp--face)))
`(("(package!\\_>" (0 (+emacs-lisp-truncate-pin))))))
;; Recenter window after following definition
(advice-add #'elisp-def :after #'doom-recenter-a)

6
modules/lang/java/+lsp.el
View file

@ -3,11 +3,11 @@
(use-package! lsp-java
:after lsp-clients
:hook (java-mode-local-vars . lsp!)
:preface
(setq lsp-java-server-install-dir (concat doom-etc-dir "eclipse.jdt.ls/server/")
lsp-java-workspace-dir (concat doom-etc-dir "java-workspace"))
lsp-java-workspace-dir (concat doom-etc-dir "java-workspace")
lsp-jt-root (concat doom-etc-dir "eclipse.jdt.ls/server/java-test/server/"))
(add-hook! java-mode-local-vars #'lsp!)
:config
;; TODO keybinds
;; TODO treemacs integration (?)
)

114
modules/lang/java/README.org Normal file
View file

@ -0,0 +1,114 @@
#+TITLE: lang/java
#+DATE: January 16, 2017
#+SINCE: v1.3
#+STARTUP: inlineimages
* Table of Contents :TOC_3:noexport:
- [[#description][Description]]
- [[#module-flags][Module Flags]]
- [[#prerequisites][Prerequisites]]
- [[#openjdk-11][OpenJDK 11]]
- [[#ubuntu][Ubuntu]]
- [[#fedora][Fedora]]
- [[#oracle-jdk-11][Oracle JDK 11]]
- [[#ubuntu-1][Ubuntu]]
- [[#fedora-1][Fedora]]
- [[#features][Features]]
- [[#lsp-features][=+lsp= features]]
- [[#meghanada-features][=+meghanada= features]]
- [[#configuration][Configuration]]
* Description
This module adds [[https://www.java.com][java]] support to Doom Emacs, including =android-mode= and
=groovy-mode=.
** Module Flags
+ =+lsp= Enables integration for the eclipse.jdt.ls LSP server.
+ =+meghanada= Enables the [[https://github.com/mopemope/meghanada-emacs/tree/master][meghanada-mode]]
The =+lsp= and =+meghanada= packages are mutually exclusive and do not work
together. At the time of writing the =+meghanada= is already configured whereas
=+lsp= needs to manual configuring.
* Prerequisites
This module requires the Java SDK.
** OpenJDK 11
*** Ubuntu
#+BEGIN_SRC sh
sudo apt-get install openjdk-11-jdk-headless
#+END_SRC
*** Fedora
#+BEGIN_SRC sh
sudo dnf install java-11-openjdk
#+END_SRC
** Oracle JDK 11
*** Ubuntu
#+BEGIN_SRC sh
sudo add-apt-repository ppa:linuxuprising/java
sudo apt update
sudo apt install oracle-java11-installer
sudo apt install oracle-java11-set-default
#+END_SRC
*** Fedora
#+BEGIN_SRC sh
curl -O https://download.java.net/java/GA/jdk11/9/GPL/openjdk-11.0.2_linux-x64_bin.tar.gz
tar zxvf openjdk-11.0.2_linux-x64_bin.tar.gz
sudo mv jdk-11.0.2/ /usr/local/
#+END_SRC
Open =/etc/profile.d/jdk11.sh= as root and add
#+BEGIN_SRC sh
export JAVA_HOME=/usr/local/jdk-11.0.2
export PATH=$PATH:$JAVA_HOME/bin
#+END_SRC
Save the file and source the file
#+BEGIN_SRC sh
source /etc/profile.d/jdk11.sh
java -version
#+END_SRC
* Features
** =+lsp= features
According to [[https://github.com/emacs-lsp/lsp-java]] it adds
+ As you type reporting of parsing and compilation errors (via flycheck/[[https://github.com/emacs-lsp/lsp-ui][lsp-ui]])
+ Code completion - using [[https://github.com/tigersoldier/company-lsp][company-lsp]] or builtin complete-at-point
+ Javadoc hovers - using [[https://github.com/emacs-lsp/lsp-ui][lsp-ui]]
+ Code actions - using [[https://github.com/emacs-lsp/lsp-ui][lsp-ui]]
+ Code outline - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Imenu.html][imenu]]
+ Code navigation - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Xref.html][xref]]
+ Code lens (references/implementations) - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Xref.html][xref]]
+ Highlights
+ Code formatting
+ Maven pom.xml project support
+ Limited Gradle support
+ Visual debugger - [[https://github.com/yyoncho/dap-mode/][dap-mode]]
+ Test runner - [[https://github.com/yyoncho/dap-mode/][dap-mode]]
+ Project explorer integration - [[https://github.com/Alexander-Miller/treemacs][treemacs]]
+ Integration with [[https://start.spring.io/][Spring Initializr]]
** =+meghanada= features
According to [[https://github.com/mopemope/meghanada-emacs/]] it adds
+ Auto-update server module
+ [[https://gradle.org/][Gradle]] and [[http://maven.apache.org/][Maven]] and Eclipse project support
+ No need build tool's plugin
+ Run build tool task
+ Compile your project
+ Syntax check and analyze java source (=flycheck-meghanada=)
+ Support =Generic Types=
+ Code completion with [[http://company-mode.github.io/][company-mode]] (=company-meghanada=)
+ Optimize import and sort
+ Jump declaration
+ Run [[http://www.junit.org/][JUnit]] test (include test runner)
+ Diagnostic reporting with [[http://flycheck.org/][flycheck]] (=flycheck-meghanada=)
+ Show symbol's type info with =el-doc=
+ Search references
+ Full-featured text search
* TODO Configuration

7
modules/lang/javascript/config.el
View file

@ -135,7 +135,8 @@
(add-hook! '(js2-mode-local-vars-hook
typescript-mode-local-vars-hook
web-mode-local-vars-hook)
web-mode-local-vars-hook
rjsx-mode-local-vars-hook)
(defun +javascript-init-lsp-or-tide-maybe-h ()
"Start `lsp' or `tide' in the current buffer.
@ -152,7 +153,7 @@ to tide."
(if (not buffer-file-name)
;; necessary because `tide-setup' and `lsp' will error if not a
;; file-visiting buffer
(add-hook 'after-save-hook #'+javascript-init-tide-or-lsp-maybe-h nil 'local)
(add-hook 'after-save-hook #'+javascript-init-lsp-or-tide-maybe-h nil 'local)
(or (and (featurep! +lsp) (lsp!))
;; fall back to tide
(if (executable-find "node")
@ -160,7 +161,7 @@ to tide."
(progn (tide-setup) tide-mode))
(ignore
(doom-log "Couldn't start tide because 'node' is missing"))))
(remove-hook 'after-save-hook #'+javascript-init-tide-or-lsp-maybe-h 'local))))))
(remove-hook 'after-save-hook #'+javascript-init-lsp-or-tide-maybe-h 'local))))))
(use-package! tide

22
modules/lang/javascript/packages.el
View file

@ -2,21 +2,21 @@
;;; lang/javascript/packages.el
;; Major modes
(package! coffee-mode :pin "35a41c7d82")
(package! js2-mode :pin "fe53814dc2")
(package! rjsx-mode :pin "0061587a06")
(package! typescript-mode :pin "102587e458")
(package! coffee-mode :pin "35a41c7d8233eac0b267d9593e67fb8b6235e134")
(package! js2-mode :pin "fe53814dc2a0db2e95ac06083362e43923bf83fc")
(package! rjsx-mode :pin "0061587a06cdc2579a8d0e90863498d96bf982d8")
(package! typescript-mode :pin "102587e458d48ece6335cd708300647f22ec8b8d")
;; Tools
(package! js2-refactor :pin "d4c40b5fc8")
(package! npm-mode :pin "3ee7c0bad5")
(package! add-node-modules-path :pin "f31e69ccb6")
(package! js2-refactor :pin "d4c40b5fc86d3edd7c6a7d83ac86483ee1cb7a28")
(package! npm-mode :pin "3ee7c0bad5b7a041d4739ef3aaa06a3dc764e5eb")
(package! add-node-modules-path :pin "f31e69ccb681f882aebb806ce6e9478e3ac39708")
;; Eval
(package! nodejs-repl :pin "6fad7d764f")
(package! skewer-mode :pin "e5bed35193")
(package! nodejs-repl :pin "6fad7d764fa0d818ba497450bd722ae10cb8efed")
(package! skewer-mode :pin "e5bed351939c92a1f788f78398583c2f83f1bb3c")
;; Programming environment
(package! tide :pin "3b45610faa")
(package! tide :pin "3b45610faaab33bc53ae2d44e1e573f19f35a74a")
(when (featurep! :tools lookup)
(package! xref-js2 :pin "6f1ed5dae0"))
(package! xref-js2 :pin "6f1ed5dae0c2485416196a51f2fa92f32e4b8262"))

9
modules/lang/markdown/config.el
View file

@ -27,11 +27,17 @@ capture, the end position, and the output buffer.")
markdown-gfm-additional-languages '("sh")
markdown-make-gfm-checkboxes-buttons t
;; Preview/compilation defaults
;; `+markdown-compile' offers support for many transpilers (see
;; `+markdown-compile-functions'), which it tries until one succeeds.
markdown-command #'+markdown-compile
;; This is set to `nil' by default, which causes a wrong-type-arg error
;; when you use `markdown-open'. These are more sensible defaults.
markdown-open-command
(cond (IS-MAC "open")
(IS-LINUX "xdg-open"))
;; A sensible and simple default preamble for markdown exports that
;; takes after the github asthetic (plus highlightjs syntax coloring).
markdown-content-type "application/xhtml+xml"
markdown-css-paths
'("https://cdn.jsdelivr.net/npm/github-markdown-css/github-markdown.min.css"
@ -57,6 +63,7 @@ capture, the end position, and the output buffer.")
(sp-local-pair '(markdown-mode gfm-mode) "`" "`"
:unless '(:add sp-point-before-word-p sp-point-before-same-p))
;; Don't trigger autofill in code blocks (see `auto-fill-mode')
(setq-hook! 'markdown-mode-hook
fill-nobreak-predicate (cons #'markdown-code-block-at-point-p
fill-nobreak-predicate))

11
modules/lang/markdown/packages.el
View file

@ -1,13 +1,14 @@
;; -*- no-byte-compile: t; -*-
;;; lang/markdown/packages.el
(package! markdown-mode :pin "e9dff50d57")
(package! markdown-toc :pin "7038f4f6d5")
(package! edit-indirect :pin "935ded353b")
(package! markdown-mode :pin "c927a114b1b23cf7538181d62fd14679cce7fa25")
(package! markdown-toc :pin "eda9650a1bf0015e52e9678bd92b0a8beb1d7d71")
(package! edit-indirect :pin "935ded353b9ed3da67bc61abf245c21b58d88864")
(when (featurep! +grip)
(package! grip-mode :pin "9615c47747"))
(package! grip-mode :pin "9615c4774727a719d38313a679d70f2a2c6aca68"))
(when (featurep! :editor evil +everywhere)
(package! evil-markdown
:recipe (:host github :repo "Somelauw/evil-markdown") :pin "46cd81b379"))
:recipe (:host github :repo "Somelauw/evil-markdown")
:pin "46cd81b37991c4325fc24015a610f832b0ff995d"))

8
modules/lang/nix/packages.el
View file

@ -1,11 +1,11 @@
;; -*- no-byte-compile: t; -*-
;;; lang/nix/packages.el
(package! nix-mode :pin "5b5961780f")
(package! nix-update :pin "fc6c39c2da")
(package! nix-mode :pin "5b5961780f3b1c1b62453d2087f775298980f10d")
(package! nix-update :pin "fc6c39c2da3fcfa62f4796816c084a6389c8b6e7")
(when (featurep! :completion company)
(package! company-nixos-options :pin "977b9a505f"))
(package! company-nixos-options :pin "977b9a505ffc8b33b70ec7742f90e469b3168297"))
(when (featurep! :completion helm)
(package! helm-nixos-options :pin "977b9a505f"))
(package! helm-nixos-options :pin "977b9a505ffc8b33b70ec7742f90e469b3168297"))

2
modules/lang/org/autoload/org-capture.el
View file

@ -50,7 +50,7 @@ you're done. This can be called from an external shell script."
(with-selected-frame frame
(require 'org-capture)
(condition-case ex
(cl-letf (((symbol-function #'pop-to-buffer) #'switch-to-buffer))
(letf! ((#'pop-to-buffer #'switch-to-buffer))
(switch-to-buffer (doom-fallback-buffer))
(let ((org-capture-initial initial-input)
org-capture-entry)

38
modules/lang/org/config.el
View file

@ -4,6 +4,7 @@
'((cpp . C)
(C++ . C)
(D . C)
(elisp . emacs-lisp)
(sh . shell)
(bash . shell)
(matlab . octave)
@ -94,14 +95,11 @@ Is relative to `org-directory', unless it is absolute. Is used in Doom's default
org-entities-user
'(("flat" "\\flat" nil "" "" "266D" "♭")
("sharp" "\\sharp" nil "" "" "266F" "♯"))
org-fontify-done-headline t
org-fontify-quote-and-verse-blocks t
org-fontify-whole-heading-line t
org-footnote-auto-label 'plain
org-hide-leading-stars t
org-hide-leading-stars-before-indent-mode t
org-image-actual-width nil
org-list-description-max-indent 4
org-priority-faces
'((?A . error)
(?B . warning)
@ -120,9 +118,6 @@ Is relative to `org-directory', unless it is absolute. Is used in Doom's default
org-refile-use-outline-path 'file
org-outline-path-complete-in-steps nil)
;; Fontify latex blocks and entities, but not natively -- that's too slow
(setq org-highlight-latex-and-related '(latex script entities))
(plist-put org-format-latex-options :scale 1.5) ; larger previews
(add-hook! 'doom-load-theme-hook
(defun +org-refresh-latex-background-h ()
@ -168,12 +163,6 @@ This forces it to read the background before rendering."
("HOLD" . +org-todo-onhold)
("PROJ" . +org-todo-project)))
(after! org-eldoc
;; HACK Fix #2972: infinite recursion when eldoc kicks in in an 'org' src
;; block.
;; TODO Should be reported upstream!
(puthash "org" "ignore" org-eldoc-local-functions-cache))
(defadvice! +org-display-link-in-eldoc-a (&rest args)
"Display full link in minibuffer when cursor/mouse is over it."
:before-until #'org-eldoc-documentation-function
@ -501,6 +490,13 @@ eldoc string."
nil 'face `(:foreground ,(face-foreground face nil t) :weight bold)))
width prefix separator))
(after! org-eldoc
;; HACK Fix #2972: infinite recursion when eldoc kicks in in 'org' or
;; 'python' src blocks.
;; TODO Should be reported upstream!
(puthash "org" #'ignore org-eldoc-local-functions-cache)
(puthash "python" #'python-eldoc-function org-eldoc-local-functions-cache))
(defun +org--restart-mode-h ()
"Restart `org-mode', but only once."
(quiet! (org-mode-restart))
@ -541,11 +537,9 @@ current workspace (and clean them up)."
;; upstream (if ever).
(defadvice! +org--fix-inline-images-for-imagemagick-users-a (orig-fn &rest args)
:around #'org-display-inline-images
(cl-letf* ((old-create-image (symbol-function #'create-image))
((symbol-function #'create-image)
(lambda (file-or-data &optional type data-p &rest props)
(letf! (defun create-image (file-or-data &optional type data-p &rest props)
(let ((type (if (plist-get props :width) type)))
(apply old-create-image file-or-data type data-p props)))))
(apply create-image file-or-data type data-p props)))
(apply orig-fn args)))
(defadvice! +org--fix-inconsistent-uuidgen-case-a (uuid)
@ -797,6 +791,7 @@ compelling reason, so..."
:config
;; Make leading stars truly invisible, by rendering them as spaces!
(setq org-superstar-leading-bullet ?\s
org-superstar-leading-fallback ?\s
org-hide-leading-stars nil)
;; Don't do anything special for item bullets or TODOs by default; these slow
;; down larger org buffers.
@ -813,11 +808,14 @@ compelling reason, so..."
(use-package! org-crypt ; built-in
:commands org-encrypt-entries org-encrypt-entry org-decrypt-entries org-decrypt-entry
:hook (org-reveal-start . org-decrypt-entry)
:config
(add-hook! 'org-mode-hook
(add-hook 'before-save-hook 'org-encrypt-entries nil t))
:preface
;; org-crypt falls back to CRYPTKEY property then `epa-file-encrypt-to', which
;; is a better default than the empty string `org-crypt-key' defaults to.
(defvar org-crypt-key nil)
(after! org
(add-to-list 'org-tags-exclude-from-inheritance "crypt")
(setq org-crypt-key user-mail-address))
(add-hook! 'org-mode-hook
(add-hook 'before-save-hook 'org-encrypt-entries nil t))))
(use-package! org-clock ; built-in

5
modules/lang/org/contrib/present.el
View file

@ -41,8 +41,7 @@
(defadvice! +org-present--narrow-to-subtree-a (orig-fn &rest args)
"Narrow to the target subtree when you start the presentation."
:around #'org-tree-slide--display-tree-with-narrow
(cl-letf (((symbol-function #'org-narrow-to-subtree)
(lambda ()
(letf! ((defun org-narrow-to-subtree ()
(save-excursion
(save-match-data
(org-with-limited-levels
@ -56,5 +55,5 @@
(progn (org-end-of-subtree t t)
(when (and (org-at-heading-p) (not (eobp)))
(backward-char 1))
(point)))))))))
(point))))))))
(apply orig-fn args))))

15
modules/lang/org/contrib/roam.el
View file

@ -48,20 +48,7 @@
(cond ((featurep! :completion helm) 'helm)
((featurep! :completion ivy) 'ivy)
((featurep! :completion ido) 'ido)
('default))
org-roam-completion-fuzzy-match
(or (featurep! :completion helm +fuzzy)
(featurep! :completion ivy +fuzzy)))
;; HACK On first invocation, `org-roam-db-build-cache' builds the cache with a
;; list of unresolved file paths. If those are symlinks, you will later
;; end up with duplicate entries in your roam DB (e.g. after
;; `org-roam-capture'ing to an existing file).
;; REVIEW When jethrokuan/org-roam#518 is merged
(defadvice! +org-roam-resolve-symlinks-a (args)
:filter-args #'org-roam--list-files
(setcar args (file-truename (car args)))
args)
('default)))
;; Normally, the org-roam buffer doesn't open until you explicitly call
;; `org-roam'. If `+org-roam-open-buffer-on-find-file' is non-nil, the

72
modules/lang/org/packages.el
View file

@ -27,84 +27,84 @@
:recipe (:host github
:repo "emacs-straight/org-mode"
:files ("*.el" "lisp/*.el" "contrib/lisp/*.el"))
:pin "31068373dc")
:pin "e5eda0beeb3b6b0666550091bcc0df066d52c008")
;; ...And prevent other packages from pulling org; org-plus-contrib satisfies
;; the dependency already: https://github.com/raxod502/straight.el/issues/352
(package! org :recipe (:local-repo nil))
(package! avy)
(package! htmlize :pin "86f22f211e")
(package! org-superstar :pin "09ddc28383")
(package! htmlize :pin "86f22f211e9230857197c42a9823d3f05381deed")
(package! org-superstar :pin "09ddc28383d363a4b353348a433e24535b4af0e3")
(package! org-yt
:recipe (:host github :repo "TobiasZawada/org-yt")
:pin "40cc1ac76d")
(package! ox-clip :pin "bd36f9fb4e")
(package! toc-org :pin "5deaec41ed")
(package! org-cliplink :pin "82402cae7e")
:pin "40cc1ac76d741055cbefa13860d9f070a7ade001")
(package! ox-clip :pin "bd36f9fb4e3b1b9e8686b993b02ccd780ff75a96")
(package! toc-org :pin "5deaec41ed0e5c51715737d7f74c5ae1b3c00387")
(package! org-cliplink :pin "82402cae7e118d67de7328417fd018a18f95fac2")
(when (featurep! :editor evil +everywhere)
(package! evil-org
:recipe (:host github :repo "hlissner/evil-org-mode")
:pin "9cf661af8f"))
:pin "9cf661af8ff8ea768ef1e55045be14d0468a90f5"))
(when (featurep! :tools pdf)
(package! org-pdftools :pin "8cc15bb801"))
(package! org-pdftools :pin "8cc15bb8014ed1f047eecc0abd8bf447f86c0505"))
(when (featurep! :tools magit)
(package! orgit :pin "e147f05577"))
(package! orgit :pin "e147f055772cc934fe1f1d8619059badeb647c93"))
(when (featurep! +brain)
(package! org-brain :pin "7ffbf6816a"))
(package! org-brain :pin "ae7fe0f628bd093526786ece6917f7a4310e5e4d"))
(when (featurep! +dragndrop)
(package! org-download :pin "46417e2bd3"))
(package! org-download :pin "48d3952ad8ebc5ef5a6a77b8c6a4a0da61653036"))
(when (featurep! +gnuplot)
(package! gnuplot :pin "f0001c3001")
(package! gnuplot-mode :pin "601f639298"))
(package! gnuplot :pin "f0001c30010b2899e36d7d89046322467e923088")
(package! gnuplot-mode :pin "601f6392986f0cba332c87678d31ae0d0a496ce7"))
(when (featurep! +ipython) ; DEPRECATED
(package! ob-ipython :pin "7147455230"))
(package! ob-ipython :pin "7147455230841744fb5b95dcbe03320313a77124"))
(when (featurep! +jupyter)
(package! jupyter :pin "785edbbff6"))
(package! jupyter :pin "785edbbff65abb0c929dc2fbd8b8305c77fd529e"))
(when (featurep! +journal)
(package! org-journal :pin "8bf06b28d6"))
(package! org-journal :pin "8bf06b28d6f14f52d4968123e2b4b91930c8f947"))
(when (featurep! +noter)
(package! org-noter :pin "9ead81d42d"))
(package! org-noter :pin "9ead81d42dd4dd5074782d239b2efddf9b8b7b3d"))
(when (featurep! +pomodoro)
(package! org-pomodoro :pin "aa07c11318"))
(package! org-pomodoro :pin "aa07c11318f91219336197e62c47bc7a3d090479"))
(when (featurep! +present)
(package! centered-window
:recipe (:host github :repo "anler/centered-window-mode")
:pin "24f7c5be9d")
(package! org-tree-slide :pin "7bf09a02bd")
(package! org-re-reveal :pin "61549f4c00"))
:pin "f50859941ab5c7cbeaee410f2d38716252b552ac")
(package! org-tree-slide :pin "7bf09a02bd2d8f1ccfcb5209bfb18fbe02d1f44e")
(package! org-re-reveal :pin "61549f4c00284a30e34caa3d76001b233ea5d2ad"))
(when (featurep! +roam)
(package! org-roam :pin "963692f353")
(package! org-roam :pin "e698ed7f5378106da8a8fec4537658392157657c")
(when (featurep! :completion company)
(package! company-org-roam :pin "0913d86f16")))
(package! company-org-roam :pin "0913d86f167164e18831206e611f44bb8e7297e3")))
;;; Babel
(package! ob-async :pin "80a30b96a0")
(package! ob-async :pin "80a30b96a007d419ece12c976a81804ede340311")
(when (featurep! :lang crystal)
(package! ob-crystal :pin "d84c1adee4"))
(package! ob-crystal :pin "d84c1adee4b269cdba06a97caedb8071561a09af"))
(when (featurep! :lang go)
(package! ob-go :pin "2067ed55f4"))
(package! ob-go :pin "2067ed55f4c1d33a43cb3f6948609d240a8915f5"))
(when (featurep! :lang hy)
(package! ob-hy :pin "a42ecaf440"))
(package! ob-hy :pin "a42ecaf440adc03e279afe43ee5ef6093ddd542a"))
(when (featurep! :lang nim)
(package! ob-nim :pin "bf1642cb93"))
(package! ob-nim :pin "bf1642cb93f0a898804dc13fd9408d2964403bd2"))
(when (featurep! :lang racket)
(package! ob-racket
:recipe (:host github :repo "DEADB17/ob-racket")
:pin "d8fd51bddb"))
:pin "d8fd51bddb019b0eb68755255f88fc800cfe03cb"))
(when (featurep! :lang rest)
(package! ob-restclient :pin "f7449b2068"))
(package! ob-restclient :pin "f7449b2068498fe9d8ab9589e0a638148861533f"))
(when (featurep! :lang rust)
(package! ob-rust :pin "6a82587598"))
(package! ob-rust :pin "6a82587598cd097e9642be916243c31f1231b24a"))
(when (featurep! :lang scala)
(package! ob-ammonite :pin "39937dff39"))
(package! ob-ammonite :pin "39937dff395e70aff76a4224fa49cf2ec6c57cca"))
;;; Export
(when (featurep! +pandoc)
(package! ox-pandoc :pin "aa37dc7e94"))
(package! ox-pandoc :pin "aa37dc7e94213d4ebedb85c384c1ba35007da18e"))
(when (featurep! +hugo)
(package! ox-hugo
:recipe (:host github :repo "kaushalmodi/ox-hugo" :nonrecursive t)
:pin "5106b430a1"))
:pin "8f36181977377383cb54803651d93b24e370122d"))
(when (featurep! :lang rst)
(package! ox-rst :pin "9158bfd180"))
(package! ox-rst :pin "9158bfd18096c559e0a225ae62ab683f1c98a547"))

12
modules/lang/perl/config.el
View file

@ -2,9 +2,15 @@
;; There's also `perl-mode' for perl < 6, which is already set up.
(use-package! perl6-detect)
(use-package! raku-mode
:defer t
:init
(defalias 'perl6-mode #'raku-mode)
:config
(set-repl-handler! 'raku-mode #'run-raku))
(use-package! flycheck-perl6
(use-package! flycheck-raku
:when (featurep! :checkers syntax)
:after perl6-mode)
:after raku-mode)

6
modules/lang/perl/packages.el
View file

@ -1,7 +1,9 @@
;; -*- no-byte-compile: t; -*-
;;; lang/perl/packages.el
(package! perl6-mode :pin "88de065795")
(package! raku-mode :pin "d474216840251dc0efe4f4aa4f5c5f66ac26fa74")
(when (featurep! :checkers syntax)
(package! flycheck-perl6 :pin "b804702305"))
(package! flycheck-raku
:recipe (:host github :repo "widefox/flycheck-raku")
:pin "046f35abe0c61967157e151126e4dd7ec5d1c004"))

2
modules/lang/racket/packages.el
View file

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*-
;;; lang/racket/packages.el
(package! racket-mode :pin "202cc1b784")
(package! racket-mode :pin "8f3b214a5ea06e6a2a9492e7d20b19badd0c3bdf")

2
modules/lang/ruby/config.el
View file

@ -22,6 +22,7 @@
(add-hook 'ruby-mode-local-vars-hook #'lsp!))
(after! inf-ruby
(add-hook 'inf-ruby-mode-hook #'doom-mark-buffer-as-real-h)
;; switch to inf-ruby from compile if we detect a breakpoint has been hit
(add-hook 'compilation-filter-hook #'inf-ruby-auto-enter))
@ -173,6 +174,7 @@
(use-package! projectile-rails
:when (featurep! +rails)
:hook ((ruby-mode inf-ruby-mode projectile-rails-server-mode) . projectile-rails-mode)
:hook (projectile-rails-server-mode . doom-mark-buffer-as-real-h)
:init
(setq inf-ruby-console-environment "development")
(when (featurep! :lang web)

4
modules/lang/rust/packages.el
View file

@ -1,6 +1,6 @@
;; -*- no-byte-compile: t; -*-
;;; lang/rust/packages.el
(package! rustic :pin "61032eacf0")
(package! rustic :pin "32a962ab2d3f87bde0e12c4e8975fe73d8ba8579")
(unless (featurep! +lsp)
(package! racer :pin "a0bdf778f0"))
(package! racer :pin "a0bdf778f01e8c4b8a92591447257422ac0b455b"))

8
modules/lang/scheme/autoload.el
View file

@ -15,15 +15,18 @@ lists properly and names starting with 'default'."
(if (and (elt state 2)
;; NOTE looking-at -> looking-at-p
(not (looking-at-p "\\sw\\|\\s_")))
(progn
;; NOTE (if (not ...) (progn ...)) -> (unless ... ...)
(unless (> (save-excursion (forward-line 1) (point))
calculate-lisp-indent-last-sexp)
(goto-char calculate-lisp-indent-last-sexp)
(beginning-of-line)
(parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t))
(backward-prefix-chars)
(current-column)
(current-column))
(let* ((function (buffer-substring
(point) (progn (forward-sexp 1) (point))))
;; NOTE let -> let* & moved `method' def into let bindings
(method (or (get (intern-soft function) 'scheme-indent-function)
(get (intern-soft function) 'scheme-indent-hook))))
(cond ((or (eq method 'defun)
@ -32,11 +35,12 @@ lists properly and names starting with 'default'."
;; NOTE string-match -> string-match-p
;; NOTE The original regexp is "\\`def" but it will mess
;; indentation with such names as 'default-...'.
(string-match-p "\\`define" function)))
(string-match-p "\\`def" function)))
(lisp-indent-defform state indent-point))
;; NOTE Added this clause to handle alignment of keyword symbols
((and (null method)
(> (length function) 1)
;; NOTE string-match -> string-match-p
(string-match-p "\\`:" function))
(let ((lisp-body-indent 1))
(lisp-indent-defform state indent-point)))

4
modules/lang/sh/packages.el
View file

@ -2,7 +2,7 @@
;;; lang/sh/packages.el
(when (featurep! :completion company)
(package! company-shell :pin "52f3bf26b7"))
(package! company-shell :pin "52f3bf26b74adc30a275f5f4290a1fc72a6876ff"))
(when (featurep! +fish)
(package! fish-mode :pin "db257db810"))
(package! fish-mode :pin "db257db81058b0b12f788c324c264cc59b9a5bf4"))

6
modules/lang/solidity/packages.el
View file

@ -1,6 +1,6 @@
;; -*- no-byte-compile: t; -*-
;;; lang/solidity/packages.el
(package! solidity-mode :pin "b190993dcb")
(package! company-solidity :pin "b190993dcb")
(package! solidity-flycheck :pin "b190993dcb")
(package! solidity-mode :pin "022b3159832384a7dcdc2168809e698600826047")
(package! company-solidity)
(package! solidity-flycheck)

8
modules/lang/swift/packages.el
View file

@ -1,11 +1,11 @@
;; -*- no-byte-compile: t; -*-
;;; lang/swift/packages.el
(package! swift-mode :pin "1268425311")
(package! swift-mode :pin "2ab9ea1784a12a482ed9e3fb284b7a7658f40fff")
(if (featurep! +lsp)
(package! lsp-sourcekit :pin "04d75b6a0b")
(package! lsp-sourcekit :pin "04d75b6a0be5894fea4a55fec0b2ccedf5b3be58")
(when (featurep! :completion company)
(package! company-sourcekit :pin "abf9bc5a01"))
(package! company-sourcekit :pin "abf9bc5a0102eb666d3aa6d6bf22f6efcc852781"))
(when (featurep! :checkers syntax)
(package! flycheck-swift :pin "4c5ad40125")))
(package! flycheck-swift :pin "4c5ad401252400a78da395fd56a71e67ff8c2761")))

4
modules/lang/web/+html.el
View file

@ -162,4 +162,6 @@
(when (featurep! +lsp)
(add-hook! '(html-mode-hook web-mode-hook) #'lsp!))
(add-hook! '(html-mode-local-vars-hook
web-mode-local-vars-hook)
#'lsp!))

26
modules/lang/web/packages.el
View file

@ -2,23 +2,23 @@
;;; lang/web/packages.el
;; +html.el
(package! emmet-mode :pin "1acb821e01")
(package! haml-mode :pin "bf5b6c11b1")
(package! pug-mode :pin "685fd3414d")
(package! slim-mode :pin "3636d18ab1")
(when (package! web-mode :pin "b0bb4ab82b")
(package! emmet-mode :pin "1acb821e0142136344ccf40c1e5fb664d7db2e70")
(package! haml-mode :pin "bf5b6c11b1206759d2b28af48765e04882dd1fc4")
(package! pug-mode :pin "685fd3414d89736bf232f5d1a6bed9e0353b98fe")
(package! slim-mode :pin "3636d18ab1c8b316eea71c4732eb44743e2ded87")
(when (package! web-mode :pin "6774c596a9b3988989d3bc96b6194e6f0df1d1b6")
(when (featurep! :completion company)
(package! company-web :pin "f0cc9187c9")))
(package! company-web :pin "f0cc9187c9c34f72ad71f5649a69c74f996bae9a")))
;; +css.el
(package! css-mode :built-in t)
(package! less-css-mode :built-in t :pin "c7fa3d56d8")
(package! less-css-mode :built-in t :pin "c7fa3d56d83206b28657f2e56439dc62280a2bf2")
(package! sass-mode :pin "247a0d4b50")
(package! stylus-mode :pin "4dbde92542")
(package! sws-mode :pin "4dbde92542")
(package! rainbow-mode :pin "3ef813d637")
(package! sass-mode :pin "247a0d4b509f10b28e4687cd8763492bca03599b")
(package! stylus-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
(package! sws-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
(package! rainbow-mode :pin "f780ddb18c2a73a666d093f606df92058e5601ea")
(when (featurep! :completion ivy)
(package! counsel-css :pin "61a38c9d50"))
(package! counsel-css :pin "6427dfcbda0d2bbd81db03f9d6b56b06c260ac02"))
(when (featurep! :completion helm)
(package! helm-css-scss :pin "48b996f73a"))
(package! helm-css-scss :pin "48b996f73af1fef8d6e88a1c545d98f8c50b0cf3"))

Some files were not shown because too many files have changed in this diff Show more