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: > 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-mode@91e37a6 -> emacs-lsp/lsp-mode@c8188ef
> emacs-lsp/lsp-ui@cf6906c -> emacs-lsp/lsp-ui@582e153 > 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 > 4. You've included links to relevant issues, if any
> 5. You've deleted this template > 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")/.." :; DOOMBASE="$(dirname "$0")/.."
:; [ "$1" = -d ] || [ "$1" = --debug ] && { shift; export DEBUG=1; } :; [ "$1" = -d ] || [ "$1" = --debug ] && { shift; export DEBUG=1; }
:; [ "$1" = run ] && { cd "$DOOMBASE"; shift; exec $EMACS -q --no-splash -l bin/doom "$@"; exit 0; } :; [ "$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 :; exit 0
(let* ((load-prefer-newer t) (let* ((load-prefer-newer t)
@ -15,6 +15,13 @@
(user-emacs-directory (user-emacs-directory
(abbreviate-file-name (or emacsdir (expand-file-name "../" loaddir))))) (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) (push (expand-file-name "core" user-emacs-directory) load-path)
(require 'core) (require 'core)
(require 'core-cli) (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) (require 'core-packages)
(let ((default-directory doom-emacs-dir) (let ((default-directory doom-emacs-dir)
(doom-modules (doom-modules))) (doom-modules (doom-modules)))
(cl-letf (letf! (defun sh (&rest args) (cdr (apply #'doom-call-process args)))
(((symbol-function 'sh)
(lambda (&rest args)
(cdr (apply #'doom-call-process args)))))
`((emacs `((emacs
(version . ,emacs-version) (version . ,emacs-version)
(features ,@system-configuration-features) (features ,@system-configuration-features)

7
core/autoload/help.el
View file

@ -38,6 +38,7 @@
(LaTeX-mode :lang latex) (LaTeX-mode :lang latex)
(ledger-mode :lang ledger) (ledger-mode :lang ledger)
(lua-mode :lang lua) (lua-mode :lang lua)
(moonscript-mode :lang lua)
(markdown-mode :lang markdown) (markdown-mode :lang markdown)
(gfm-mode :lang markdown) (gfm-mode :lang markdown)
(nim-mode :lang nim) (nim-mode :lang nim)
@ -45,6 +46,7 @@
(taureg-mode :lang ocaml) (taureg-mode :lang ocaml)
(org-mode :lang org) (org-mode :lang org)
(perl-mode :lang perl) (perl-mode :lang perl)
(raku-mode :lang perl)
(php-mode :lang php) (php-mode :lang php)
(hack-mode :lang php) (hack-mode :lang php)
(plantuml-mode :lang plantuml) (plantuml-mode :lang plantuml)
@ -53,7 +55,9 @@
(restclient-mode :lang rest) (restclient-mode :lang rest)
(ruby-mode :lang ruby) (ruby-mode :lang ruby)
(rust-mode :lang rust) (rust-mode :lang rust)
(rustic-mode :lang rust)
(scala-mode :lang scala) (scala-mode :lang scala)
(scheme-mode :lang scheme)
(sh-mode :lang sh) (sh-mode :lang sh)
(swift-mode :lang swift) (swift-mode :lang swift)
(web-mode :lang web) (web-mode :lang web)
@ -131,7 +135,8 @@ selection of all minor-modes, active or not."
(list (or (+org-get-global-property "TITLE") (list (or (+org-get-global-property "TITLE")
(file-relative-name (buffer-file-name))))) (file-relative-name (buffer-file-name)))))
path 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) 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) (unless (file-readable-p dir)
(error "Directory %S isn't readable" dir)) (error "Directory %S isn't readable" dir))
(let* ((default-directory (file-truename (expand-file-name dir))) (let* ((default-directory (file-truename (expand-file-name dir)))
(project-root (doom-project-root default-directory)) (projectile-project-root (doom-project-root default-directory))
(projectile-project-root default-directory)
(projectile-enable-caching projectile-enable-caching)) (projectile-enable-caching projectile-enable-caching))
(cond ((and project-root (file-equal-p project-root projectile-project-root)) (cond ((and projectile-project-root (file-equal-p projectile-project-root default-directory))
(unless (doom-project-p projectile-project-root) (unless (doom-project-p default-directory)
;; Disable caching if this is not a real project; caching ;; Disable caching if this is not a real project; caching
;; non-projects easily has the potential to inflate the projectile ;; non-projects easily has the potential to inflate the projectile
;; cache beyond reason. ;; cache beyond reason.

5
core/autoload/sessions.el
View file

@ -130,8 +130,11 @@
(interactive "P") (interactive "P")
(setq doom-autosave-session nil) (setq doom-autosave-session nil)
(doom/quicksave-session) (doom/quicksave-session)
(save-some-buffers nil t)
(letf! ((#'save-buffers-kill-emacs #'kill-emacs)
(confirm-kill-emacs))
(restart-emacs (restart-emacs
(append (if debug (list "--debug-init")) (append (if debug (list "--debug-init"))
(when (boundp 'chemacs-current-emacs-profile) (when (boundp 'chemacs-current-emacs-profile)
(list "--with-profile" 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) (cl-check-type file string)
(and (print! (start "Generating core autoloads...")) (and (print! (start "Generating core autoloads..."))
(doom-cli--write-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 (cl-loop for dir
in (append (list doom-core-dir) in (append (list doom-core-dir)
(cdr (doom-module-load-path 'all-p)) (cdr (doom-module-load-path 'all-p))
@ -105,6 +107,12 @@ one wants that.")
(print! "M-x doom/restart") (print! "M-x doom/restart")
(print! "M-x doom/reload"))) (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) (defun doom-cli--generate-var-cache (vars)
`((setq ,@(cl-loop for var in vars `((setq ,@(cl-loop for var in vars
append `(,var ',(symbol-value var)))))) 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" "# run 'doom sync'. To create a safe-to-edit envvar file use:\n#\n"
"# doom env -o ~/.doom.d/myenv\n#\n" "# doom env -o ~/.doom.d/myenv\n#\n"
"# And load it with (doom-load-envvars-file \"~/.doom.d/myenv\").\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" "# (doom-load-envvars-file \"path/to/this/file\")\n#\n"
"# Use 'doom env -o path/to/this/file' to regenerate it.")) "# 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 ;; We assume that this noninteractive session was spawned from the
;; user's interactive shell, therefore we just dump ;; user's interactive shell, therefore we just dump
;; `process-environment' to a file. ;; `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 "="))) (if (cl-find-if (doom-rpartial #'string-match-p (car (split-string env "=")))
doom-env-ignored-vars) doom-env-ignored-vars)
(print! (info "Ignoring %s") env) (print! (info "Ignoring %s") env)
(insert env "\n"))) (insert env "\0\n")))
(print! (success "Successfully generated %S") (print! (success "Successfully generated %S")
(path env-file)) (path env-file))
t)))))) 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)) (print! "%2s) %s" (1+ (length options))
(if (cl-find-if (doom-rpartial #'string-match-p desc) (if (cl-find-if (doom-rpartial #'string-match-p desc)
doom--cli-straight-discard-options) doom--cli-straight-discard-options)
(concat desc " (Recommended)") (green (concat desc " (Recommended)"))
desc)))) desc))))
(terpri) (terpri)
(let* ((options (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 `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'." files, so we replace calls to `pp' with the much faster `prin1'."
:around #'save-place-alist-to-file :around #'save-place-alist-to-file
(cl-letf (((symbol-function #'pp) #'prin1)) (letf! ((#'pp #'prin1)) (funcall orig-fn))))
(funcall orig-fn)))
(save-place-mode +1))
(use-package! server (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." `nim-mode'. This prevents them from leaving Emacs in a broken state."
:around #'dtrt-indent-mode :around #'dtrt-indent-mode
(let ((dtrt-indent-run-after-smie dtrt-indent-run-after-smie)) (let ((dtrt-indent-run-after-smie dtrt-indent-run-after-smie))
(cl-letf* ((old-smie-config-guess (symbol-function 'smie-config-guess)) (letf! ((defun symbol-config--guess (beg end)
(old-smie-config--guess (symbol-function 'symbol-config--guess)) (funcall symbol-config--guess beg (min end 10000)))
((symbol-function 'symbol-config--guess) (defun smie-config-guess ()
(lambda (beg end) (condition-case e (funcall smie-config-guess)
(funcall old-smie-config--guess beg (min end 10000))))
((symbol-function 'smie-config-guess)
(lambda ()
(condition-case e (funcall old-smie-config-guess)
(error (setq dtrt-indent-run-after-smie t) (error (setq dtrt-indent-run-after-smie t)
(message "[WARNING] Indent detection: %s" (message "[WARNING] Indent detection: %s"
(error-message-string e)) (error-message-string e))
(message "")))))) ; warn silently (message ""))))) ; warn silently
(funcall orig-fn arg))))) (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) (defun doom-use-helpful-a (orig-fn &rest args)
"Force ORIG-FN to use helpful instead of the old describe-* commands." "Force ORIG-FN to use helpful instead of the old describe-* commands."
(cl-letf (((symbol-function #'describe-function) #'helpful-function) (letf! ((#'describe-function #'helpful-function)
((symbol-function #'describe-variable) #'helpful-variable)) (#'describe-variable #'helpful-variable))
(apply orig-fn args))) (apply orig-fn args)))
(after! apropos (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 () (defun doom-init-smartparens-in-minibuffer-maybe-h ()
"Enable `smartparens-mode' in the minibuffer, during `eval-expression', "Enable `smartparens-mode' in the minibuffer, during `eval-expression',
`pp-eval-expression' or `evil-ex'." `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)))) (smartparens-mode))))
;; You're likely writing lisp in the minibuffer, therefore, disable these ;; 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))) 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 ;; specials
(defvar doom--map-forms nil) (defvar doom--map-forms nil)
(defvar doom--map-fn nil) (defvar doom--map-fn nil)

403
core/core-lib.el
View file

@ -1,8 +1,5 @@
;;; core-lib.el -*- lexical-binding: t; -*- ;;; core-lib.el -*- lexical-binding: t; -*-
(require 'cl-lib)
(require 'subr-x)
;; ;;
;;; Helpers ;;; Helpers
@ -85,6 +82,60 @@ Accepts the same arguments as `message'."
format-string) format-string)
,@args)))) ,@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) (defalias 'doom-partial #'apply-partially)
(defun doom-rpartial (fn &rest args) (defun doom-rpartial (fn &rest args)
@ -119,6 +170,11 @@ aliases."
(call-interactively command)))) (call-interactively command))))
(defalias 'lambda!! 'λ!!) (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! () (defun file! ()
"Return the emacs lisp file this macro is called from." "Return the emacs lisp file this macro is called from."
(cond ((bound-and-true-p byte-compile-current-file)) (cond ((bound-and-true-p byte-compile-current-file))
@ -128,10 +184,129 @@ aliases."
(buffer-file-name) (buffer-file-name)
((error "Cannot get this file-path")))) ((error "Cannot get this file-path"))))
(defun dir! () (defmacro letenv! (envvars &rest body)
"Returns the directory of the emacs lisp file this macro is called from." "Lexically bind ENVVARS in BODY, like `let' but for `process-environment'."
(when-let (path (file!)) (declare (indent 1))
(directory-file-name (file-name-directory path)))) `(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) (defmacro after! (package &rest body)
"Evaluate BODY after PACKAGE have loaded. "Evaluate BODY after PACKAGE have loaded.
@ -183,58 +358,84 @@ This is a wrapper around `eval-after-load' that:
(setq body `((after! ,next ,@body)))) (setq body `((after! ,next ,@body))))
(car body)))))) (car body))))))
(defmacro setq! (&rest settings) (defun doom--handle-load-error (e target path)
"A stripped-down `customize-set-variable' with the syntax of `setq'. (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 (defmacro load! (filename &optional path noerror)
property in its `defcustom' declaration). This trigger setters. `setq' does "Load a file relative to the current executing file (`load-file-name').
not."
(macroexp-progn
(cl-loop for (var val) on settings by 'cddr
collect `(funcall (or (get ',var 'custom-set) #'set)
',var ,val))))
(defmacro pushnew! (place &rest values) FILENAME is either a file path string or a form that should evaluate to such a
"Push VALUES sequentially into PLACE, if they aren't already present. string at run time. PATH is where to look for the file (a string representing a
This is a variadic `cl-pushnew'." directory path). If omitted, the lookup is relative to either `load-file-name',
(let ((var (make-symbol "result"))) `byte-compile-current-file' or `buffer-file-name' (checked in that order).
`(dolist (,var (list ,@values) (with-no-warnings ,place))
(cl-pushnew ,var ,place :test #'equal))))
(defmacro prependq! (sym &rest lists) If NOERROR is non-nil, don't throw an error if the file doesn't exist."
"Prepend LISTS to SYM in place." (let* ((path (or path
`(setq ,sym (append ,@lists ,sym))) (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) (defmacro defer-until! (condition &rest body)
"Append LISTS to SYM in place." "Run BODY when CONDITION is true (checks on `after-load-functions'). Meant to
`(setq ,sym (append ,sym ,@lists))) 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) (defmacro defer-feature! (feature &optional fn)
"`delq' ELT from LIST in-place. "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)." Some packages (like `elisp-mode' and `lisp-mode') are loaded immediately at
`(setq ,list startup, which will prematurely trigger `after!' (and `with-eval-after-load')
(delq ,(if fetcher blocks. To get around this we make Emacs believe FEATURE hasn't been loaded yet,
`(funcall ,fetcher ,elt ,list) then wait until FEATURE-hook (or MODE-hook, if FN is provided) is triggered to
elt) reverse this and trigger `after!' blocks at a more reasonable time."
,list))) (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 ;;; Hooks
(defvar doom--transient-counter 0) (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) in (doom--setq-hook-fns hooks vars 'singles)
collect `(remove-hook ',hook #',fn)))) 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 ;;; Definers
(defmacro defadvice! (symbol arglist &optional docstring &rest body) (defmacro defadvice! (symbol arglist &optional docstring &rest body)
"Define an advice called SYMBOL and add it to PLACES. "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)) (declare (pure t) (side-effect-free t))
(append (list doom-private-dir) (append (list doom-private-dir)
(if module-dirs (if module-dirs
(mapcar (lambda (m) (doom-module-locate-path (car m) (cdr m)))
(doom-files-in (if (listp module-dirs) (doom-files-in (if (listp module-dirs)
module-dirs module-dirs
doom-modules-dirs) doom-modules-dirs)
:map #'doom-module-from-path
:type 'dirs :type 'dirs
:mindepth 1 :mindepth 1
:depth 1) :depth 1))
(cl-loop for plist being the hash-values of (doom-modules) (cl-loop for plist being the hash-values of doom-modules
collect (plist-get plist :path))) collect (plist-get plist :path)))
nil)) nil))

8
core/core-packages.el
View file

@ -269,9 +269,13 @@ elsewhere."
recipe recipe
;; Expand :local-repo from current directory ;; Expand :local-repo from current directory
(when local-repo (when local-repo
(plist-put! plist :recipe (plist-put!
plist :recipe
(plist-put recipe :local-repo (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 (error
(signal 'doom-package-error (signal 'doom-package-error
(cons ,(symbol-name name) (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 ;; REVIEW Resolve the project root once, when the file/buffer is opened. This
;; speeds up projectile's project root resolution by leaps, but does ;; speeds up projectile's project root resolution by leaps, but does
;; put you at risk of having a stale project root. ;; 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 ;; In case the user saves the file to a new location
after-save-hook after-save-hook
;; ...or makes external changes then returns to Emacs ;; ...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. ;; .gitignore. This is recommended in the projectile docs.
((executable-find doom-projectile-fd-binary) ((executable-find doom-projectile-fd-binary)
(setq projectile-generic-command (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) doom-projectile-fd-binary)
projectile-git-command projectile-generic-command projectile-git-command projectile-generic-command
projectile-git-submodule-command nil 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 ;; Otherwise, resort to ripgrep, which is also faster than find
((executable-find "rg") ((executable-find "rg")
(setq projectile-generic-command (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 (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-command projectile-generic-command
projectile-git-submodule-command nil projectile-git-submodule-command nil
;; ensure Windows users get rg's benefits ;; 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 It is recommended you don't set specify a font-size, as to inherit `doom-font's
size.") size.")
(defvar doom-unicode-extra-fonts nil
"Fonts to inject into the unicode charset before `doom-unicode-font'.")
;; ;;
;;; Custom hooks ;;; Custom hooks
@ -85,48 +88,51 @@ size.")
(defvar doom--last-frame nil) (defvar doom--last-frame nil)
(defun doom-run-switch-window-hooks-h () (defun doom-run-switch-window-hooks-h ()
(let ((gc-cons-threshold most-positive-fixnum))
(unless (or doom-inhibit-switch-window-hooks (unless (or doom-inhibit-switch-window-hooks
(eq doom--last-window (selected-window)) (eq doom--last-window (selected-window))
(minibufferp)) (minibufferp))
(let ((doom-inhibit-switch-window-hooks t) (let ((gc-cons-threshold most-positive-fixnum)
(doom-inhibit-switch-window-hooks t)
(inhibit-redisplay t)) (inhibit-redisplay t))
(run-hooks 'doom-switch-window-hook) (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 _) (defun doom-run-switch-frame-hooks-h (&rest _)
(unless (or doom-inhibit-switch-frame-hooks (unless (or doom-inhibit-switch-frame-hooks
(eq doom--last-frame (selected-frame)) (eq doom--last-frame (selected-frame))
(frame-parameter nil 'parent-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) (run-hooks 'doom-switch-frame-hook)
(setq doom--last-frame (selected-frame))))) (setq doom--last-frame (selected-frame)))))
(defun doom-run-switch-buffer-hooks-a (orig-fn buffer-or-name &rest args) (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 (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))) (and (eq orig-fn #'switch-to-buffer) (car args)))
(apply orig-fn buffer-or-name 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)) (inhibit-redisplay t))
(when-let (buffer (apply orig-fn buffer-or-name args)) (when-let (buffer (apply orig-fn buffer-or-name args))
(with-current-buffer (if (windowp buffer) (with-current-buffer (if (windowp buffer)
(window-buffer buffer) (window-buffer buffer)
buffer) buffer)
(run-hooks 'doom-switch-buffer-hook)) (run-hooks 'doom-switch-buffer-hook))
buffer))))) buffer))))
(defun doom-run-switch-to-next-prev-buffer-hooks-a (orig-fn &rest args) (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 (if doom-inhibit-switch-buffer-hooks
(apply orig-fn args) (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)) (inhibit-redisplay t))
(when-let (buffer (apply orig-fn args)) (when-let (buffer (apply orig-fn args))
(with-current-buffer buffer (with-current-buffer buffer
(run-hooks 'doom-switch-buffer-hook)) (run-hooks 'doom-switch-buffer-hook))
buffer))))) buffer))))
(defun doom-protect-fallback-buffer-h () (defun doom-protect-fallback-buffer-h ()
"Don't kill the scratch buffer. Meant for `kill-buffer-query-functions'." "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 '(tool-bar-lines . 0))
(add-to-list 'default-frame-alist '(vertical-scroll-bars))) (add-to-list 'default-frame-alist '(vertical-scroll-bars)))
(when IS-MAC (when! IS-MAC
;; Curse Lion and its sudden but inevitable fullscreen mode! ;; Curse Lion and its sudden but inevitable fullscreen mode!
;; NOTE Meaningless to railwaycat's emacs-mac build ;; NOTE Meaningless to railwaycat's emacs-mac build
(setq ns-use-native-fullscreen nil) (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))))) (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 (use-package! hl-line
;; Highlights the current line ;; Highlights the current line
:hook ((prog-mode text-mode conf-mode special-mode) . hl-line-mode) :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-wicon
all-the-icons-material all-the-icons-material
all-the-icons-alltheicon) all-the-icons-alltheicon)
:preface
(setq doom-unicode-extra-fonts
(list "Weather Icons"
"github-octicons"
"FontAwesome"
"all-the-icons"
"file-icons"
"Material Icons"))
:config :config
(cond ((daemonp) (cond ((daemonp)
(defadvice! doom--disable-all-the-icons-in-tty-a (orig-fn &rest args) (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)) (set-face-attribute 'fixed-pitch-serif nil :font doom-serif-font))
(when doom-variable-pitch-font (when doom-variable-pitch-font
(set-face-attribute 'variable-pitch nil :font doom-variable-pitch-font)) (set-face-attribute 'variable-pitch nil :font doom-variable-pitch-font))
(when (and doom-unicode-font (fboundp 'set-fontset-font)) (when (fboundp 'set-fontset-font)
(set-fontset-font t 'unicode doom-unicode-font nil 'prepend))) (dolist (font (append doom-unicode-extra-fonts (doom-enlist doom-unicode-font)))
(set-fontset-font t 'unicode font nil 'prepend))))
((debug error) ((debug error)
(if (string-prefix-p "Font not available: " (error-message-string e)) (if (string-prefix-p "Font not available: " (error-message-string e))
(lwarn 'doom-ui :warning (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 (unless no-enable
(setq doom-theme theme (setq doom-theme theme
doom-init-theme-p t) 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)) (mapc #'disable-theme (remq theme custom-enabled-themes))
(run-hooks 'doom-load-theme-hook)) (run-hooks 'doom-load-theme-hook))
result))) result)))
(unless EMACS27+ (when! (not EMACS27+)
;; DEPRECATED Not needed in Emacs 27 ;; DEPRECATED Not needed in Emacs 27
(defadvice! doom--prefer-compiled-theme-a (orig-fn &rest args) (defadvice! doom--prefer-compiled-theme-a (orig-fn &rest args)
"Have `load-theme' prioritize the byte-compiled theme. "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 :around #'load-theme
(if (or (null after-init-time) (if (or (null after-init-time)
doom--prefer-theme-elc) doom--prefer-theme-elc)
(cl-letf* ((old-locate-file (symbol-function 'locate-file)) (letf! (defun locate-file (filename path &optional _suffixes predicate)
((symbol-function 'locate-file) (funcall locate-file filename path '("c" "") predicate))
(lambda (filename path &optional _suffixes predicate)
(funcall old-locate-file filename path '("c" "") predicate))))
(apply orig-fn args)) (apply orig-fn args))
(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-WINDOWS (memq system-type '(cygwin windows-nt ms-dos)))
(defconst IS-BSD (or IS-MAC (eq system-type 'berkeley-unix))) (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' ;; Ensure `doom-core-dir' is in `load-path'
(add-to-list 'load-path (file-name-directory load-file-name)) (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)) (add-hook 'emacs-startup-hook #'doom-reset-file-handler-alist-h))
;; Just the bare necessities ;; Just the bare necessities
(require 'subr-x)
(require 'cl-lib)
(require 'core-lib) (require 'core-lib)
@ -207,27 +213,22 @@ users).")
;; https://www.keylength.com/en/4/ ;; https://www.keylength.com/en/4/
gnutls-min-prime-bits 3072 gnutls-min-prime-bits 3072
tls-checktrust gnutls-verify-error tls-checktrust gnutls-verify-error
;; Emacs is built with `gnutls' by default, so `tls-program' would not ;; Emacs is built with `gnutls' by default, so `tls-program' would not be
;; be used in that case. Otherwiese, people have reasons to not go with ;; used in that case. Otherwise, people have reasons to not go with
;; `gnutls', we use `openssl' instead. ;; `gnutls', we use `openssl' instead. For more details, see
;; For more details, see https://redd.it/8sykl1 ;; https://redd.it/8sykl1
tls-program '("openssl s_client -connect %h:%p -CAfile %t -nbio -no_ssl3 -no_tls1 -no_tls1_1 -ign_eof" 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 \ "gnutls-cli -p %p --dh-bits=3072 --ocsp --x509cafile=%t \
--strict-tofu --priority='SECURE192:+SECURE128:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3' %h" --strict-tofu --priority='SECURE192:+SECURE128:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3' %h"
;; compatibility fallbacks ;; compatibility fallbacks
"gnutls-cli -p %p %h")) "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 ;; This file stores usernames, passwords, and other such treasures for the
;; aspiring malicious third party. ;; 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")) "~/.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 ;; Don't litter `doom-emacs-dir'. We don't use `no-littering' because it's a
;; mote too opinionated for our needs. ;; mote too opinionated for our needs.
(setq abbrev-file-name (concat doom-local-dir "abbrev.el") (setq abbrev-file-name (concat doom-local-dir "abbrev.el")
@ -274,11 +275,6 @@ users).")
;; quickly self-correct. ;; quickly self-correct.
(setq fast-but-imprecise-scrolling t) (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 ;; 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 ;; 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). ;; fonts that are larger than the system default (which would resize the frame).
@ -288,7 +284,7 @@ users).")
(setq ffap-machine-p-known 'reject) (setq ffap-machine-p-known 'reject)
;; Font compacting can be terribly expensive, especially for rendering icon ;; 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. ;; been determined, but we inhibit it there anyway.
(setq inhibit-compacting-font-caches t) (setq inhibit-compacting-font-caches t)
@ -432,17 +428,6 @@ If this is a daemon session, load them all immediately instead."
;; ;;
;;; Bootstrap helpers ;;; 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) (defun doom-display-benchmark-h (&optional return-p)
"Display a benchmark including number of packages and modules loaded. "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 (setq doom-init-time
(float-time (time-subtract (current-time) before-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) (defun doom-initialize (&optional force-p noerror)
"Bootstrap Doom, if it hasn't already (or if FORCE-P is non-nil). "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 Module config.el files
~/.doom.d/config.el ~/.doom.d/config.el
`doom-init-modules-hook' `doom-init-modules-hook'
`doom-after-init-hook' (`after-init-hook') `doom-after-init-modules-hook' (`after-init-hook')
`emacs-startup-hook' `emacs-startup-hook'
`doom-init-ui-hook' `doom-init-ui-hook'
`window-setup-hook' `window-setup-hook'

41
core/packages.el
View file

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

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 ** Persist Emacs' initial frame position, dimensions and/or full-screen state across sessions
#+BEGIN_SRC elisp #+BEGIN_SRC elisp
;; add to ~/.doom.d/config.el ;; 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 (cl-destructuring-bind ((left . top) width height fullscreen) dims
(setq initial-frame-alist (setq initial-frame-alist
(append 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)))))) (fullscreen . ,fullscreen))))))
(defun save-frame-dimensions () (defun save-frame-dimensions ()
(doom-cache-set 'last-frame-size (doom-store-set 'last-frame-size
(list (frame-position) (list (frame-position)
(frame-width) (frame-width)
(frame-height) (frame-height)

13
docs/getting_started.org
View file

@ -17,6 +17,7 @@ us know!
- [[#on-linux][On Linux]] - [[#on-linux][On Linux]]
- [[#arch-linux][Arch Linux:]] - [[#arch-linux][Arch Linux:]]
- [[#ubuntu][Ubuntu:]] - [[#ubuntu][Ubuntu:]]
- [[#fedora][Fedora:]]
- [[#nixos][NixOS]] - [[#nixos][NixOS]]
- [[#on-macos][On macOS]] - [[#on-macos][On macOS]]
- [[#with-homebrew][With Homebrew]] - [[#with-homebrew][With Homebrew]]
@ -143,6 +144,14 @@ apt-get update
apt-get install emacs26 apt-get install emacs26
#+END_SRC #+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 **** NixOS
On NixOS Emacs 26.3 can be installed via ~nix-env -Ai nixos.emacs~, or 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~: 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 #+begin_quote
I recommend you add =~/.emacs.d/bin= to your ~PATH~ so you can call =doom= 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 directly and from anywhere. Accomplish this by adding this to your .bashrc or
.zshrc file: .zshrc file: ~export PATH=~/.emacs.d/bin:$PATH~
~export PATH="$HOME/.emacs.d/bin:$PATH"~
#+end_quote #+end_quote
*** Install Doom Manually *** Install Doom Manually

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

@ -42,10 +42,10 @@
org-gcal-fetch org-gcal-fetch
org-gcal-post-at-point org-gcal-post-at-point
org-gcal-delete-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 :config
;; hack to avoid the deferred.el error ;; hack to avoid the deferred.el error
(defun org-gcal--notify (title mes) (defun org-gcal--notify (title mes)
(message "org-gcal::%s - %s" 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; -*- ;; -*- no-byte-compile: t; -*-
;;; app/calendar/packages.el ;;; app/calendar/packages.el
(package! calfw :pin "03abce9762") (package! calfw :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
(package! calfw-org :pin "03abce9762") (package! calfw-org :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
(package! org-gcal :pin "6821e34967") (package! org-gcal :pin "2ee2b31547e6f4e33db70fb812d552e55d612fd6")

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

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

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

@ -101,10 +101,9 @@
;;;###autoload ;;;###autoload
(defun +rss-put-sliced-image-fn (spec alt &optional flags) (defun +rss-put-sliced-image-fn (spec alt &optional flags)
"TODO" "TODO"
(cl-letf (((symbol-function #'insert-image) (letf! (defun insert-image (image &optional alt _area _slice)
(lambda (image &optional alt _area _slice)
(let ((height (cdr (image-size image t)))) (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))) (shr-put-image spec alt flags)))
;;;###autoload ;;;###autoload

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

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

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

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

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

@ -8,15 +8,16 @@
:init (setq langtool-default-language "en-US") :init (setq langtool-default-language "en-US")
:config :config
(unless (or langtool-bin (unless (or langtool-bin
langtool-language-tool-jar) langtool-language-tool-jar
(setq langtool-language-tool-jar langtool-java-classpath)
(cond (IS-MAC (cond (IS-MAC
(setq langtool-language-tool-jar
(locate-file "libexec/languagetool-commandline.jar" (locate-file "libexec/languagetool-commandline.jar"
(doom-files-in "/usr/local/Cellar/languagetool" (doom-files-in "/usr/local/Cellar/languagetool"
:type 'dirs :type 'dirs
:depth 2))) :depth 2))))
(IS-LINUX (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 ;; 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; -*- ;; -*- no-byte-compile: t; -*-
;;; checkers/grammar/packages.el ;;; checkers/grammar/packages.el
(package! langtool :pin "a71ed02ce0") (package! langtool :pin "a71ed02ce06920ae3cafd6708de1c21811ce14c3")
(package! writegood-mode :pin "b71757ec33") (package! writegood-mode :pin "b71757ec337e226909fb0422f0224e31acc71733")

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

@ -1,11 +1,11 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; checkers/spell/packages.el ;;; checkers/spell/packages.el
(package! flyspell-correct :pin "e765d1a3d9") (package! flyspell-correct :pin "fd8ac7a4f922ce5ea1cc5d4583a7d584847cb6b5")
(cond ((featurep! :completion ivy) (cond ((featurep! :completion ivy)
(package! flyspell-correct-ivy :pin "e765d1a3d9")) (package! flyspell-correct-ivy))
((featurep! :completion helm) ((featurep! :completion helm)
(package! flyspell-correct-helm :pin "e765d1a3d9")) (package! flyspell-correct-helm))
((package! flyspell-correct-popup :pin "e765d1a3d9"))) ((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; -*- ;; -*- no-byte-compile: t; -*-
;;; checkers/syntax/packages.el ;;; checkers/syntax/packages.el
(package! flycheck :pin "f19a51c0f1") (package! flycheck :pin "246e1d4380721ca03962464f11d02dd1372860ce")
(package! flycheck-popup-tip :pin "ef86aad907") (package! flycheck-popup-tip :pin "ef86aad907f27ca076859d8d9416f4f7727619c6")
(when (featurep! +childframe) (when (featurep! +childframe)
(package! flycheck-posframe :pin "2b3e94c2e4")) (package! flycheck-posframe :pin "2b3e94c2e427ec9831c513007460c5ea9e2225a3"))
;; TODO flymake? ;; TODO flymake?

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

@ -11,9 +11,26 @@
company-require-match 'never company-require-match 'never
company-global-modes company-global-modes
'(not erc-mode message-mode help-mode gud-mode) '(not erc-mode message-mode help-mode gud-mode)
company-backends '(company-capf)
company-frontends '(company-pseudo-tooltip-frontend 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 :config
(when (featurep! :editor evil) (when (featurep! :editor evil)
(add-hook 'company-mode-hook #'evil-normalize-keymaps) (add-hook 'company-mode-hook #'evil-normalize-keymaps)
@ -106,6 +123,8 @@
(ElispFeature . ,(all-the-icons-material "stars" :face 'all-the-icons-orange)) (ElispFeature . ,(all-the-icons-material "stars" :face 'all-the-icons-orange))
(ElispFace . ,(all-the-icons-material "format_paint" :face 'all-the-icons-pink))))) (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) (defun +company-box-icons--elisp-fn (candidate)
(when (derived-mode-p 'emacs-lisp-mode) (when (derived-mode-p 'emacs-lisp-mode)
(let ((sym (intern candidate))) (let ((sym (intern candidate)))

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

@ -1,8 +1,8 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; completion/company/packages.el ;;; completion/company/packages.el
(package! company :pin "61ddd9afb5") (package! company :pin "6333fc4ebbbf4d28e834de8715561e984f149ecb")
(package! company-dict :pin "cd7b8394f6") (package! company-dict :pin "cd7b8394f6014c57897f65d335d6b2bd65dab1f4")
(package! company-prescient :pin "53307731f3") (package! company-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
(when (featurep! +childframe) (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; -*- ;; -*- no-byte-compile: t; -*-
;;; completion/helm/packages.el ;;; completion/helm/packages.el
(package! helm :pin "d978f20f4c") (package! helm :pin "b6db9fb47a8900704394e63b795f4a54cb4701a8")
(package! helm-rg :pin "785a80fe5c") (package! helm-rg :pin "785a80fe5cc87e27c5ea3d00a70049028d9e2847")
(package! helm-c-yasnippet :pin "65ca732b51") (package! helm-c-yasnippet :pin "65ca732b510bfc31636708aebcfe4d2d845b59b0")
(package! helm-company :pin "6eb5c2d730") (package! helm-company :pin "6eb5c2d730a60e394e005b47c1db018697094dde")
(package! helm-describe-modes (package! helm-describe-modes
:recipe (:host github :repo "emacs-helm/helm-describe-modes") :recipe (:host github :repo "emacs-helm/helm-describe-modes")
:pin "11fb36af11") :pin "11fb36af119b784539d31c6160002de1957408aa")
(package! helm-projectile :pin "5328b74ddd") (package! helm-projectile :pin "5328b74dddcee8d1913803ca8167868831a07463")
(package! swiper-helm :pin "93fb6db87b") (package! swiper-helm :pin "93fb6db87bc6a5967898b5fd3286954cc72a0008")
(when (featurep! +fuzzy) (when (featurep! +fuzzy)
(package! helm-flx :pin "6640fac5cb")) (package! helm-flx :pin "6640fac5cb16bee73c95b8ed1248a4e5e113690e"))
(when (featurep! +childframe) (when (featurep! +childframe)
(package! posframe :pin "e62e584268")) (package! posframe :pin "093b29a53cbeda6d637ccc9ef4dfc47123e79b9e"))
(when (featurep! :lang org) (when (featurep! :lang org)
(package! helm-org :pin "b7a18dfc17")) (package! helm-org :pin "b7a18dfc17e8b933956d61d68c435eee03a96c24"))
(package! helm-descbinds :pin "b725159823") (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) (map! :map (ido-common-completion-map ido-file-completion-map)
"C-w" #'ido-delete-backward-word-updir "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-n" #'ido-next-match
"C-p" #'ido-prev-match "C-p" #'ido-prev-match
[down] #'ido-next-match [down] #'ido-next-match

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

@ -1,8 +1,8 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; completion/ido/packages.el ;;; completion/ido/packages.el
(package! flx-ido :pin "17f5c9cb2a") (package! flx-ido :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")
(package! ido-completing-read+ :pin "98d3a6e56b") (package! ido-completing-read+ :pin "98d3a6e56b1d3652da7b47f49f76d77f82ea80ba")
(package! ido-sort-mtime :pin "f638ff0c92") (package! ido-sort-mtime :pin "f638ff0c922af862f5211779f2311a27fde428eb")
(package! ido-vertical-mode :pin "16c4c1a112") (package! ido-vertical-mode :pin "16c4c1a112796ee0bcf401ea39d3e2643a89feaf")
(package! crm-custom :pin "f1aaccf643") (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)))) (ivy-rich-counsel-function-docstring (:face font-lock-doc-face))))
;; Apply switch buffer transformers to `counsel-projectile-switch-to-buffer' as well ;; Apply switch buffer transformers to `counsel-projectile-switch-to-buffer' as well
'counsel-projectile-switch-to-buffer '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 ;; Remove built-in coloring of buffer list; we do our own
(setq ivy-switch-buffer-faces-alist nil) (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 :override #'counsel--find-return-list
(cl-destructuring-bind (find-program . args) (cl-destructuring-bind (find-program . args)
(cond ((executable-find doom-projectile-fd-binary) (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") ((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 (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" "/")))) (if IS-WINDOWS (list "--path-separator" "/"))))
((cons find-program args))) ((cons find-program args)))
(unless (listp args) (unless (listp args)

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

@ -1,23 +1,23 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; completion/ivy/packages.el ;;; completion/ivy/packages.el
(package! swiper :pin "64f05f4735") (package! swiper :pin "9e0803cdb5b47e4e1844e8281516b46589ef26c7")
(package! ivy) (package! ivy)
(package! ivy-hydra) (package! ivy-hydra)
(package! counsel) (package! counsel)
(package! amx :pin "e512e74e83") (package! amx :pin "7fb7b874291e0cdeb1f0acb18564a686ec86788d")
(package! counsel-projectile :pin "b556ed8995") (package! counsel-projectile :pin "b556ed8995f375e57496f3482aef4b0def565de8")
(package! ivy-rich :pin "596874d146") (package! ivy-rich :pin "3f818b201769bc13cc75aa73645217e374136aca")
(package! wgrep :pin "5977b8e000") (package! wgrep :pin "5977b8e00051c9003ca96e9d35133e0dea68db2c")
(if (featurep! +prescient) (if (featurep! +prescient)
(package! ivy-prescient :pin "53307731f3") (package! ivy-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
(when (featurep! +fuzzy) (when (featurep! +fuzzy)
(package! flx :pin "17f5c9cb2a"))) (package! flx :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")))
(when (featurep! +childframe) (when (featurep! +childframe)
(package! ivy-posframe :pin "ae9bafe94f")) (package! ivy-posframe :pin "ae9bafe94fe6b77b6fe45766ae6172646f6a5d50"))
(when (featurep! +icons) (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 whitespace" "w" #'delete-trailing-whitespace
:desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines :desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines
:desc "List errors" "x" #'flymake-show-diagnostics-buffer :desc "List errors" "x" #'flymake-show-diagnostics-buffer
(:when (featurep! :tools flycheck) (:when (featurep! :checkers syntax)
:desc "List errors" "x" #'flycheck-list-errors) :desc "List errors" "x" #'flycheck-list-errors)
(:when (featurep! :tools lsp) (:when (featurep! :tools lsp)
:desc "LSP Code actions" "a" #'lsp-execute-code-action :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 Organize imports" "i" #'lsp-organize-imports
:desc "LSP Rename" "r" #'lsp-rename :desc "LSP Rename" "r" #'lsp-rename
(:after lsp-mode
:desc "LSP" "l" lsp-command-map)
(:when (featurep! :completion ivy) (:when (featurep! :completion ivy)
:desc "Jump to symbol in current workspace" "j" #'lsp-ivy-workspace-symbol :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) :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) :desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
(:when (featurep! :ui treemacs) (:when (featurep! :ui treemacs)
:desc "Project sidebar" "p" #'+treemacs/toggle :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) (:when (featurep! :term shell)
:desc "Toggle shell popup" "t" #'+shell/toggle :desc "Toggle shell popup" "t" #'+shell/toggle
:desc "Open shell here" "T" #'+shell/here) :desc "Open shell here" "T" #'+shell/here)
@ -247,14 +248,14 @@
:desc "Indent style" "I" #'doom/toggle-indent-style :desc "Indent style" "I" #'doom/toggle-indent-style
:desc "Line numbers" "l" #'doom/toggle-line-numbers :desc "Line numbers" "l" #'doom/toggle-line-numbers
:desc "Word-wrap mode" "w" #'+word-wrap-mode :desc "Word-wrap mode" "w" #'+word-wrap-mode
(:when (featurep! :tools flycheck) (:when (featurep! :checkers syntax)
:desc "Flycheck" "f" #'flycheck-mode) :desc "Flycheck" "f" #'flycheck-mode)
(:when (featurep! :ui indent-guides) (:when (featurep! :ui indent-guides)
:desc "Indent guides" "i" #'highlight-indent-guides-mode) :desc "Indent guides" "i" #'highlight-indent-guides-mode)
(:when (featurep! :lang org +present) (:when (featurep! :lang org +present)
:desc "org-tree-slide mode" "p" #'+org-present/start) :desc "org-tree-slide mode" "p" #'+org-present/start)
:desc "Read-only mode" "r" #'read-only-mode :desc "Read-only mode" "r" #'read-only-mode
(:when (featurep! :tools flyspell) (:when (featurep! :checkers spell)
:desc "Flyspell" "s" #'flyspell-mode) :desc "Flyspell" "s" #'flyspell-mode)
(:when (featurep! :lang org +pomodoro) (:when (featurep! :lang org +pomodoro)
:desc "Pomodoro timer" "t" #'org-pomodoro) :desc "Pomodoro timer" "t" #'org-pomodoro)
@ -541,4 +542,4 @@
;;; treemacs ;;; treemacs
(:when (featurep! :ui treemacs) (:when (featurep! :ui treemacs)
"<f9>" #'+treemacs/toggle "<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-k" #'previous-line
"C-S-j" #'scroll-up-command "C-S-j" #'scroll-up-command
"C-S-k" #'scroll-down-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 (define-key! read-expression-map
"C-j" #'next-line-or-history-element "C-j" #'next-line-or-history-element
"C-k" #'previous-line-or-history-element))) "C-k" #'previous-line-or-history-element)))
@ -341,7 +344,6 @@
;;; <leader> c --- code ;;; <leader> c --- code
(:prefix-map ("c" . "code") (:prefix-map ("c" . "code")
:desc "LSP Execute code action" "a" #'lsp-execute-code-action
:desc "Compile" "c" #'compile :desc "Compile" "c" #'compile
:desc "Recompile" "C" #'recompile :desc "Recompile" "C" #'recompile
:desc "Jump to definition" "d" #'+lookup/definition :desc "Jump to definition" "d" #'+lookup/definition
@ -349,8 +351,6 @@
:desc "Evaluate buffer/region" "e" #'+eval/buffer-or-region :desc "Evaluate buffer/region" "e" #'+eval/buffer-or-region
:desc "Evaluate & replace region" "E" #'+eval:replace-region :desc "Evaluate & replace region" "E" #'+eval:replace-region
:desc "Format buffer/region" "f" #'+format/region-or-buffer :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) (:when (featurep! :completion ivy)
:desc "Jump to symbol in current workspace" "j" #'lsp-ivy-workspace-symbol :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) :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 current workspace" "j" #'helm-lsp-workspace-symbol
:desc "Jump to symbol in any workspace" "J" #'helm-lsp-global-workspace-symbol) :desc "Jump to symbol in any workspace" "J" #'helm-lsp-global-workspace-symbol)
:desc "Jump to documentation" "k" #'+lookup/documentation :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 :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 "Send to repl" "s" #'+eval/send-region-to-repl
:desc "Delete trailing whitespace" "w" #'delete-trailing-whitespace :desc "Delete trailing whitespace" "w" #'delete-trailing-whitespace
:desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines :desc "Delete trailing newlines" "W" #'doom/delete-trailing-newlines
@ -523,7 +528,7 @@
:desc "Find file in project sidebar" "P" #'+neotree/find-this-file) :desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
(:when (featurep! :ui treemacs) (:when (featurep! :ui treemacs)
:desc "Project sidebar" "p" #'+treemacs/toggle :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) (:when (featurep! :term shell)
:desc "Toggle shell popup" "t" #'+shell/toggle :desc "Toggle shell popup" "t" #'+shell/toggle
:desc "Open shell here" "T" #'+shell/here) :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. "Conduct a text search in the current project root.
If prefix ARG is set, prompt for a known project to search from." If prefix ARG is set, prompt for a known project to search from."
(interactive "P") (interactive "P")
(let* ((disabled-command-function nil) (let* ((projectile-project-root nil)
(disabled-command-function nil)
(default-directory (default-directory
(if arg (if arg
(if-let (projects (projectile-relevant-known-projects)) (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 (interactive
(list (rxt-quote-pcre (or (doom-thing-at-point-or-region) "")) (list (rxt-quote-pcre (or (doom-thing-at-point-or-region) ""))
current-prefix-arg)) current-prefix-arg))
(let ((default-directory (let* ((projectile-project-root nil)
(default-directory
(if arg (if arg
(if-let (projects (projectile-relevant-known-projects)) (if-let (projects (projectile-relevant-known-projects))
(completing-read "Switch to project: " 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) (abbreviate-file-name path)
(file-name-nondirectory 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 () (defun doom--backward-delete-whitespace-to-column ()
"Delete back to the previous column of whitespace, or as much whitespace as "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; -*- ;;; 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 (defvar +default-minibuffer-maps
(append '(minibuffer-local-map (append '(minibuffer-local-map
minibuffer-local-ns-map minibuffer-local-ns-map
@ -220,8 +223,28 @@
;; f) do none of this when inside a string ;; f) do none of this when inside a string
(advice-add #'delete-backward-char :override #'+default--delete-backward-char-a)) (advice-add #'delete-backward-char :override #'+default--delete-backward-char-a))
;; Makes `newline-and-indent' continue comments (and more reliably) ;; HACK Makes `newline-and-indent' continue comments (and more reliably).
(advice-add #'newline-and-indent :override #'+default--newline-indent-and-continue-comments-a)) ;; 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; -*- ;; -*- no-byte-compile: t; -*-
;;; config/default/packages.el ;;; config/default/packages.el
(package! avy :pin "3bf83140fa") (package! avy :pin "509471bad0e8094b8639729ec39ca141fae7d4bd")
(package! drag-stuff :pin "6d06d846cd") (package! drag-stuff :pin "6d06d846cd37c052d79acd0f372c13006aa7e7c8")
(package! link-hint :pin "0d9cabcdb7") (package! link-hint :pin "7440704cacb5c0fab35fff8ec59d30fbea17f44a")
(unless (featurep! :editor evil) (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)) (not (eq this-command 'evil-open-below))
(evil-insert-state-p)) (evil-insert-state-p))
(funcall orig-fn count) (funcall orig-fn count)
(cl-letf (((symbol-function 'evil-insert-newline-below) (letf! (defun evil-insert-newline-below () (+evil--insert-newline))
(lambda () (+evil--insert-newline))))
(let ((evil-auto-indent evil-auto-indent)) (let ((evil-auto-indent evil-auto-indent))
(funcall orig-fn count))))) (funcall orig-fn count)))))
@ -134,8 +133,7 @@ more information on modifiers."
(not (eq this-command 'evil-open-above)) (not (eq this-command 'evil-open-above))
(evil-insert-state-p)) (evil-insert-state-p))
(funcall orig-fn count) (funcall orig-fn count)
(cl-letf (((symbol-function 'evil-insert-newline-above) (letf! (defun evil-insert-newline-above () (+evil--insert-newline 'above))
(lambda () (+evil--insert-newline 'above))))
(let ((evil-auto-indent evil-auto-indent)) (let ((evil-auto-indent evil-auto-indent))
(funcall orig-fn count))))) (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-escape-delay 0.15)
(evil-define-key* '(insert replace visual operator) 'global "\C-g" #'evil-escape) (evil-define-key* '(insert replace visual operator) 'global "\C-g" #'evil-escape)
:config :config
;; no `evil-escape' in minibuffer ;; no `evil-escape' in minibuffer, unless `evil-collection-setup-minibuffer'
(add-hook 'evil-escape-inhibit-functions #'minibufferp) ;; 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 ;; so that evil-escape-mode-hook runs, and can be toggled by evil-mc
(evil-escape-mode +1)) (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-refresh-this-buffer
:n "gR" #'notmuch-poll-and-refresh-this-buffer) :n "gR" #'notmuch-poll-and-refresh-this-buffer)
(:after elfeed (:after elfeed
:map elfeed-search-update--force :map elfeed-search-mode-map
:n "gr" #'elfeed-search-update--force :n "gr" #'elfeed-search-update--force
:n "gR" #'elfeed-search-fetch)) :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))) (+evil-collection-init '(occur replace)))
(add-transient-hook! 'minibuffer-setup-hook (add-transient-hook! 'minibuffer-setup-hook
(when evil-collection-setup-minibuffer (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' ;; HACK Do this ourselves because evil-collection break's `eval-after-load'
;; load order by loading their target plugin before applying keys. This ;; 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; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/evil/packages.el ;;; editor/evil/packages.el
(package! evil :pin "8aa6337fa8") (package! evil :pin "d243eae8649272799ec3864fde14c1164f036940")
(package! evil-args :pin "758ad5ae54") (package! evil-args :pin "758ad5ae54ad34202064fec192c88151c08cb387")
(package! evil-easymotion :pin "79c13ed3bc") (package! evil-easymotion :pin "f96c2ed38ddc07908db7c3c11bcd6285a3e8c2e9")
(package! evil-embrace :pin "4379adea03") (package! evil-embrace :pin "4379adea032b25e359d01a36301b4a5afdd0d1b7")
(package! evil-escape :pin "f4e9116bfb") (package! evil-escape
(package! evil-exchange :pin "3030e21ee1") :recipe (:host github :repo "hlissner/evil-escape")
(package! evil-indent-plus :pin "0c7501e6ef") :pin "819f1ee1cf3f69a1ae920e6004f2c0baeebbe077")
(package! evil-lion :pin "6b03593f5d") (package! evil-exchange :pin "3030e21ee16a42dfce7f7cf86147b778b3f5d8c1")
(package! evil-nerd-commenter :pin "747e346f11") (package! evil-indent-plus :pin "0c7501e6efed661242c3a20e0a6c79a6455c2c40")
(package! evil-lion :pin "6b03593f5dd6e7c9ca02207f9a73615cf94c93ab")
(package! evil-nerd-commenter :pin "1bd2de52011c39777a3e8779b14cee2790dc873b")
(package! evil-numbers (package! evil-numbers
:recipe (:host github :repo "janpath/evil-numbers") :recipe (:host github :repo "janpath/evil-numbers")
:pin "c2cfdd1eb1") :pin "c2cfdd1eb1f193bea28ee79b191b78309677058a")
(package! evil-snipe :pin "3ec8adfd49") (package! evil-snipe :pin "2ba6353bb9253dbbc4193f1d35403e7dcc1317b1")
(package! evil-surround :pin "9b0b17f06c") (package! evil-surround :pin "9b0b17f06cef9bac81ee4800d121265e54718a17")
(package! evil-textobj-anyblock :pin "ff00980f06") (package! evil-textobj-anyblock :pin "ff00980f0634f95bf2ad9956b615a155ea8743be")
(package! evil-traces :pin "bc25cae9fa") (package! evil-traces :pin "bc25cae9fa5ab0ba1507827f0944f52ce0ca7462")
(package! evil-visualstar :pin "06c053d8f7") (package! evil-visualstar :pin "06c053d8f7381f91c53311b1234872ca96ced752")
(package! exato :pin "d5daea3017") (package! exato :pin "d5daea30176d48e74c9d063ac9bfc240ebeb97d0")
(package! evil-quick-diff (package! evil-quick-diff
:recipe (:host github :repo "rgrinberg/evil-quick-diff") :recipe (:host github :repo "rgrinberg/evil-quick-diff")
:pin "69c883720b") :pin "69c883720b30a892c63bc89f49d4f0e8b8028908")
;; ;;
(when (featurep! +everywhere) (when (featurep! +everywhere)
@ -31,4 +33,4 @@
(package! neotree) (package! neotree)
(autoload 'neotree-make-executor "neotree" nil nil 'macro)) (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; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/file-templates/packages.el ;;; 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! hideshow :built-in t)
(package! vimish-fold :pin "d3248a41a7") (package! vimish-fold :pin "63685239655a151181b9152e45478dad587f86f2")
(when (featurep! :editor evil) (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)." is selected)."
(interactive) (interactive)
(call-interactively (call-interactively
(if (bound-and-true-p lsp-mode)
#'+default/lsp-format-region-or-buffer
(if (use-region-p) (if (use-region-p)
#'+format/region #'+format/region
#'+format/buffer))) #'+format/buffer))))
;; ;;

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

@ -1,4 +1,4 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/god/packages.el ;;; 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; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/lispyville/packages.el ;;; editor/lispyville/packages.el
(package! lispy :pin "c7e282ae06") (package! lispy :pin "cdaa9c70ca39a880163cbbce924bb46cc56b9fa4")
(when (featurep! :editor evil) (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 (cond
((featurep! :editor evil) ((featurep! :editor evil)
(package! evil-multiedit :pin "9f271e0e60") (package! evil-multiedit :pin "9f271e0e6048297692f80ed6c5ae8994ac523abc")
(package! evil-mc :pin "4d4c0172e4")) (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; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/objed/packages.el ;;; 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: ;; separate session:
(autoload 'evil-define-key "evil-core" nil nil 'macro)) (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 (package! rotate-text
:recipe (:host github :repo "debug-ito/rotate-text.el") :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 us who use yas-minor-mode and enable yasnippet more selectively. This advice
swaps `yas-global-mode' with `yas-minor-mode'." swaps `yas-global-mode' with `yas-minor-mode'."
:around '(aya-expand aya-open-line) :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)) (yas-global-mode yas-minor-mode))
(apply orig-fn args)))) (apply orig-fn args))))

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

@ -1,10 +1,10 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/snippets/packages.el ;;; editor/snippets/packages.el
(package! yasnippet :pin "5b1217ab08") (package! yasnippet :pin "5b1217ab085fab4abeb1118dccb260691b446703")
(package! auto-yasnippet :pin "db9e0dd433") (package! auto-yasnippet :pin "db9e0dd4335b2202cd5dac95bbbc87a1032d9bbe")
(package! doom-snippets (package! doom-snippets
:recipe (:host github :recipe (:host github
:repo "hlissner/doom-snippets" :repo "hlissner/doom-snippets"
:files ("*.el" "*")) :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 '(text-mode markdown-mode markdown-view-mode gfm-mode gfm-view-mode rst-mode
latex-mode LaTeX-mode) latex-mode LaTeX-mode)
"Major-modes where `+word-wrap-mode' should not provide extra indentation.") "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; -*- ;; -*- no-byte-compile: t; -*-
;;; editor/word-wrap/packages.el ;;; 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) (setq insert-directory-program gls)
;; BSD ls doesn't support --group-directories-first ;; BSD ls doesn't support --group-directories-first
(setq args (delete "--group-directories-first" args)))) (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 (add-hook! 'dired-mode-hook
(defun +dired-disable-gnu-ls-flags-in-tramp-buffers-h () (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 This is because there's no guarantee the remote system has GNU ls, which is the
only variant that supports --group-directories-first." only variant that supports --group-directories-first."
(when (file-remote-p default-directory) (when (file-remote-p default-directory)
(setq-local dired-listing-switches (setq-local dired-listing-switches (car args))))))
(string-join
(split-string dired-listing-switches
"--group-directories-first")
" ")))))
;; Don't complain about this command being disabled when we use it ;; Don't complain about this command being disabled when we use it
(put 'dired-find-alternate-file 'disabled nil) (put 'dired-find-alternate-file 'disabled nil)

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

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

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

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

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

@ -2,6 +2,6 @@
;;; emacs/undo/packages.el ;;; emacs/undo/packages.el
(if (featurep! +tree) (if (featurep! +tree)
(package! undo-tree :pin "5b6df03781") (package! undo-tree :pin "5b6df03781495d8a25695d846b0cce496d3d3058")
(package! undo-fu :pin "0c34b6747e") (package! undo-fu :pin "0ce9ac36144e80316fff50bfe1bc5dd7e5e7ded6")
(package! undo-fu-session :pin "b808ef0cdc")) (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! vc-annotate :built-in t)
(package! smerge-mode :built-in t) (package! smerge-mode :built-in t)
(package! browse-at-remote :pin "6aecae4b5d") (package! browse-at-remote :pin "6aecae4b5d202e582425fc8aa2c9c2b6a4779f25")
(package! git-timemachine :pin "391eb61050") (package! git-timemachine :pin "391eb61050de321101e631fcf373fc70ec6e7700")
(package! gitconfig-mode :pin "55468314a5") (package! gitconfig-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")
(package! gitignore-mode :pin "55468314a5") (package! gitignore-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")

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

@ -92,6 +92,9 @@
;; Wrap text in messages ;; Wrap text in messages
(setq-hook! 'mu4e-view-mode-hook truncate-lines nil) (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) (when (fboundp 'imagemagick-register-types)
(imagemagick-register-types)) (imagemagick-register-types))

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

@ -1,9 +1,9 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; email/notmuch/packages.el ;;; email/notmuch/packages.el
(package! notmuch :pin "aba7fb375b") (package! notmuch :pin "ad9c2e91a012920bebfe70bc472d44678abc3259")
(package! org-mime :pin "b189976217") (package! org-mime :pin "9f8444603806e6baa94b2b67a23aab0ea52fef97")
(when (featurep! :completion ivy) (when (featurep! :completion ivy)
(package! counsel-notmuch :pin "a4a1562935")) (package! counsel-notmuch :pin "a4a1562935e4180c42524c51609d1283e9be0688"))
(when (featurep! :completion helm) (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 ;; HACK These are wanderlust's dependencies (wanderlust depends on semi, semi
;; depends on flim, flim on apel), but they all have non-standard default ;; depends on flim, flim on apel), but they all have non-standard default
;; branches which straight cannot detect without our help. ;; branches which straight cannot detect without our help.
(package! apel :recipe (:branch "apel-wl") :pin "d146ddbf88") (package! apel :recipe (:branch "apel-wl") :pin "d146ddbf8818e81d3577d5eee7825d377bec0c73")
(package! flim :recipe (:branch "flim-1_14-wl") :pin "e4bd54fd7d") (package! flim :recipe (:branch "flim-1_14-wl") :pin "f303f2f6c124bc8635add96d3326a2209749437b")
(package! semi :recipe (:branch "semi-1_14-wl") :pin "16228dc2d1") (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; -*- ;; -*- no-byte-compile: t; -*-
;;; input/chinese/packages.el ;;; input/chinese/packages.el
(package! pyim :pin "77170724fa") (package! pyim :pin "b934273bb33d6be6aea6e20e68930bc5aaf4a48a")
(package! fcitx :pin "12dc2638dd") (package! fcitx :pin "12dc2638ddd15c8f6cfaecb20e1f428ab2bb5624")
(package! ace-pinyin :pin "8b2e9335b0") (package! ace-pinyin :pin "8b2e9335b02486730ea4ceee790130cc5328f9ea")
(package! pangu-spacing :pin "f92898949b") (package! pangu-spacing :pin "f92898949ba3bf991fd229416f3bbb54e9c6c223")

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

@ -1,7 +1,7 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; input/japanese/packages.el ;;; input/japanese/packages.el
(package! migemo :pin "f42832c8ac") (package! migemo :pin "f42832c8ac462ecbec9a16eb781194f876fba64a")
(package! avy-migemo :pin "922a6dd82c") (package! avy-migemo :pin "922a6dd82c0bfa316b0fbb56a9d4dd4ffa5707e7")
(package! ddskk :pin "f9a2333ec3") (package! ddskk :pin "11d91b4cce988e15d7c5fc4345535c9d7a92d53b")
(package! pangu-spacing :pin "f92898949b") (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)" ((message "WARNING: Couldn't find `inferior-lisp-program' (%s)"
inferior-lisp-program))))) 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 :map lisp-mode-map
:desc "Sly" "'" #'sly :desc "Sly" "'" #'sly
:desc "Sly (ask)" ";" (λ!! #'sly '-) :desc "Sly (ask)" ";" (λ!! #'sly '-)
@ -130,7 +140,7 @@
(:prefix ("t" . "trace") (:prefix ("t" . "trace")
:desc "Toggle" "t" #'sly-toggle-trace-fdefinition :desc "Toggle" "t" #'sly-toggle-trace-fdefinition
:desc "Toggle (fancy)" "T" #'sly-toggle-fancy-trace :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) (when (featurep! :editor evil +everywhere)
(add-hook 'sly-mode-hook #'evil-normalize-keymaps))) (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") (package! dart-mode :pin "04fcd649f1")
(when (featurep! +lsp) (when (featurep! +lsp)
(package! lsp-dart :pin "4cd73b77f4")) (package! lsp-dart :pin "80f8ecaf62"))
(when (featurep! +flutter) (when (featurep! +flutter)
(package! flutter :pin "293b7225b9") (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) (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 ;;;###autoload
(defun +emacs-lisp/edebug-instrument-defun-on () (defun +emacs-lisp/edebug-instrument-defun-on ()
"Toggle on instrumentalisation for the function under `defun'." "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" mode-name "Elisp"
;; Don't treat autoloads or sexp openers as outline headers, we have ;; Don't treat autoloads or sexp openers as outline headers, we have
;; hideshow for that. ;; 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 ;; variable-width indentation is superior in elisp
(add-to-list 'doom-detect-indentation-excluded-modes 'emacs-lisp-mode nil #'eq) (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))) ("^;;;###\\(autodef\\|if\\|package\\)[ \n]" (1 font-lock-warning-face t)))
;; highlight defined, special variables & functions ;; highlight defined, special variables & functions
(when +emacs-lisp-enable-extra-fontification (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 ;; Recenter window after following definition
(advice-add #'elisp-def :after #'doom-recenter-a) (advice-add #'elisp-def :after #'doom-recenter-a)

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

@ -3,11 +3,11 @@
(use-package! lsp-java (use-package! lsp-java
:after lsp-clients :after lsp-clients
:hook (java-mode-local-vars . lsp!)
:preface :preface
(setq lsp-java-server-install-dir (concat doom-etc-dir "eclipse.jdt.ls/server/") (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 :config
;; TODO keybinds ;; 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 (add-hook! '(js2-mode-local-vars-hook
typescript-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 () (defun +javascript-init-lsp-or-tide-maybe-h ()
"Start `lsp' or `tide' in the current buffer. "Start `lsp' or `tide' in the current buffer.
@ -152,7 +153,7 @@ to tide."
(if (not buffer-file-name) (if (not buffer-file-name)
;; necessary because `tide-setup' and `lsp' will error if not a ;; necessary because `tide-setup' and `lsp' will error if not a
;; file-visiting buffer ;; 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!)) (or (and (featurep! +lsp) (lsp!))
;; fall back to tide ;; fall back to tide
(if (executable-find "node") (if (executable-find "node")
@ -160,7 +161,7 @@ to tide."
(progn (tide-setup) tide-mode)) (progn (tide-setup) tide-mode))
(ignore (ignore
(doom-log "Couldn't start tide because 'node' is missing")))) (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 (use-package! tide

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

@ -2,21 +2,21 @@
;;; lang/javascript/packages.el ;;; lang/javascript/packages.el
;; Major modes ;; Major modes
(package! coffee-mode :pin "35a41c7d82") (package! coffee-mode :pin "35a41c7d8233eac0b267d9593e67fb8b6235e134")
(package! js2-mode :pin "fe53814dc2") (package! js2-mode :pin "fe53814dc2a0db2e95ac06083362e43923bf83fc")
(package! rjsx-mode :pin "0061587a06") (package! rjsx-mode :pin "0061587a06cdc2579a8d0e90863498d96bf982d8")
(package! typescript-mode :pin "102587e458") (package! typescript-mode :pin "102587e458d48ece6335cd708300647f22ec8b8d")
;; Tools ;; Tools
(package! js2-refactor :pin "d4c40b5fc8") (package! js2-refactor :pin "d4c40b5fc86d3edd7c6a7d83ac86483ee1cb7a28")
(package! npm-mode :pin "3ee7c0bad5") (package! npm-mode :pin "3ee7c0bad5b7a041d4739ef3aaa06a3dc764e5eb")
(package! add-node-modules-path :pin "f31e69ccb6") (package! add-node-modules-path :pin "f31e69ccb681f882aebb806ce6e9478e3ac39708")
;; Eval ;; Eval
(package! nodejs-repl :pin "6fad7d764f") (package! nodejs-repl :pin "6fad7d764fa0d818ba497450bd722ae10cb8efed")
(package! skewer-mode :pin "e5bed35193") (package! skewer-mode :pin "e5bed351939c92a1f788f78398583c2f83f1bb3c")
;; Programming environment ;; Programming environment
(package! tide :pin "3b45610faa") (package! tide :pin "3b45610faaab33bc53ae2d44e1e573f19f35a74a")
(when (featurep! :tools lookup) (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-gfm-additional-languages '("sh")
markdown-make-gfm-checkboxes-buttons t 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 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 markdown-open-command
(cond (IS-MAC "open") (cond (IS-MAC "open")
(IS-LINUX "xdg-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-content-type "application/xhtml+xml"
markdown-css-paths markdown-css-paths
'("https://cdn.jsdelivr.net/npm/github-markdown-css/github-markdown.min.css" '("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) "`" "`" (sp-local-pair '(markdown-mode gfm-mode) "`" "`"
:unless '(:add sp-point-before-word-p sp-point-before-same-p)) :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 (setq-hook! 'markdown-mode-hook
fill-nobreak-predicate (cons #'markdown-code-block-at-point-p fill-nobreak-predicate (cons #'markdown-code-block-at-point-p
fill-nobreak-predicate)) fill-nobreak-predicate))

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

@ -1,13 +1,14 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/markdown/packages.el ;;; lang/markdown/packages.el
(package! markdown-mode :pin "e9dff50d57") (package! markdown-mode :pin "c927a114b1b23cf7538181d62fd14679cce7fa25")
(package! markdown-toc :pin "7038f4f6d5") (package! markdown-toc :pin "eda9650a1bf0015e52e9678bd92b0a8beb1d7d71")
(package! edit-indirect :pin "935ded353b") (package! edit-indirect :pin "935ded353b9ed3da67bc61abf245c21b58d88864")
(when (featurep! +grip) (when (featurep! +grip)
(package! grip-mode :pin "9615c47747")) (package! grip-mode :pin "9615c4774727a719d38313a679d70f2a2c6aca68"))
(when (featurep! :editor evil +everywhere) (when (featurep! :editor evil +everywhere)
(package! evil-markdown (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; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/nix/packages.el ;;; lang/nix/packages.el
(package! nix-mode :pin "5b5961780f") (package! nix-mode :pin "5b5961780f3b1c1b62453d2087f775298980f10d")
(package! nix-update :pin "fc6c39c2da") (package! nix-update :pin "fc6c39c2da3fcfa62f4796816c084a6389c8b6e7")
(when (featurep! :completion company) (when (featurep! :completion company)
(package! company-nixos-options :pin "977b9a505f")) (package! company-nixos-options :pin "977b9a505ffc8b33b70ec7742f90e469b3168297"))
(when (featurep! :completion helm) (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 (with-selected-frame frame
(require 'org-capture) (require 'org-capture)
(condition-case ex (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)) (switch-to-buffer (doom-fallback-buffer))
(let ((org-capture-initial initial-input) (let ((org-capture-initial initial-input)
org-capture-entry) org-capture-entry)

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

@ -4,6 +4,7 @@
'((cpp . C) '((cpp . C)
(C++ . C) (C++ . C)
(D . C) (D . C)
(elisp . emacs-lisp)
(sh . shell) (sh . shell)
(bash . shell) (bash . shell)
(matlab . octave) (matlab . octave)
@ -94,14 +95,11 @@ Is relative to `org-directory', unless it is absolute. Is used in Doom's default
org-entities-user org-entities-user
'(("flat" "\\flat" nil "" "" "266D" "♭") '(("flat" "\\flat" nil "" "" "266D" "♭")
("sharp" "\\sharp" nil "" "" "266F" "♯")) ("sharp" "\\sharp" nil "" "" "266F" "♯"))
org-fontify-done-headline t
org-fontify-quote-and-verse-blocks t org-fontify-quote-and-verse-blocks t
org-fontify-whole-heading-line t org-fontify-whole-heading-line t
org-footnote-auto-label 'plain org-footnote-auto-label 'plain
org-hide-leading-stars t org-hide-leading-stars t
org-hide-leading-stars-before-indent-mode t
org-image-actual-width nil org-image-actual-width nil
org-list-description-max-indent 4
org-priority-faces org-priority-faces
'((?A . error) '((?A . error)
(?B . warning) (?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-refile-use-outline-path 'file
org-outline-path-complete-in-steps nil) 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 (plist-put org-format-latex-options :scale 1.5) ; larger previews
(add-hook! 'doom-load-theme-hook (add-hook! 'doom-load-theme-hook
(defun +org-refresh-latex-background-h () (defun +org-refresh-latex-background-h ()
@ -168,12 +163,6 @@ This forces it to read the background before rendering."
("HOLD" . +org-todo-onhold) ("HOLD" . +org-todo-onhold)
("PROJ" . +org-todo-project))) ("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) (defadvice! +org-display-link-in-eldoc-a (&rest args)
"Display full link in minibuffer when cursor/mouse is over it." "Display full link in minibuffer when cursor/mouse is over it."
:before-until #'org-eldoc-documentation-function :before-until #'org-eldoc-documentation-function
@ -501,6 +490,13 @@ eldoc string."
nil 'face `(:foreground ,(face-foreground face nil t) :weight bold))) nil 'face `(:foreground ,(face-foreground face nil t) :weight bold)))
width prefix separator)) 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 () (defun +org--restart-mode-h ()
"Restart `org-mode', but only once." "Restart `org-mode', but only once."
(quiet! (org-mode-restart)) (quiet! (org-mode-restart))
@ -541,11 +537,9 @@ current workspace (and clean them up)."
;; upstream (if ever). ;; upstream (if ever).
(defadvice! +org--fix-inline-images-for-imagemagick-users-a (orig-fn &rest args) (defadvice! +org--fix-inline-images-for-imagemagick-users-a (orig-fn &rest args)
:around #'org-display-inline-images :around #'org-display-inline-images
(cl-letf* ((old-create-image (symbol-function #'create-image)) (letf! (defun create-image (file-or-data &optional type data-p &rest props)
((symbol-function #'create-image)
(lambda (file-or-data &optional type data-p &rest props)
(let ((type (if (plist-get props :width) type))) (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))) (apply orig-fn args)))
(defadvice! +org--fix-inconsistent-uuidgen-case-a (uuid) (defadvice! +org--fix-inconsistent-uuidgen-case-a (uuid)
@ -797,6 +791,7 @@ compelling reason, so..."
:config :config
;; Make leading stars truly invisible, by rendering them as spaces! ;; Make leading stars truly invisible, by rendering them as spaces!
(setq org-superstar-leading-bullet ?\s (setq org-superstar-leading-bullet ?\s
org-superstar-leading-fallback ?\s
org-hide-leading-stars nil) org-hide-leading-stars nil)
;; Don't do anything special for item bullets or TODOs by default; these slow ;; Don't do anything special for item bullets or TODOs by default; these slow
;; down larger org buffers. ;; down larger org buffers.
@ -813,11 +808,14 @@ compelling reason, so..."
(use-package! org-crypt ; built-in (use-package! org-crypt ; built-in
:commands org-encrypt-entries org-encrypt-entry org-decrypt-entries org-decrypt-entry :commands org-encrypt-entries org-encrypt-entry org-decrypt-entries org-decrypt-entry
:hook (org-reveal-start . org-decrypt-entry) :hook (org-reveal-start . org-decrypt-entry)
:config :preface
(add-hook! 'org-mode-hook ;; org-crypt falls back to CRYPTKEY property then `epa-file-encrypt-to', which
(add-hook 'before-save-hook 'org-encrypt-entries nil t)) ;; 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") (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 (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) (defadvice! +org-present--narrow-to-subtree-a (orig-fn &rest args)
"Narrow to the target subtree when you start the presentation." "Narrow to the target subtree when you start the presentation."
:around #'org-tree-slide--display-tree-with-narrow :around #'org-tree-slide--display-tree-with-narrow
(cl-letf (((symbol-function #'org-narrow-to-subtree) (letf! ((defun org-narrow-to-subtree ()
(lambda ()
(save-excursion (save-excursion
(save-match-data (save-match-data
(org-with-limited-levels (org-with-limited-levels
@ -56,5 +55,5 @@
(progn (org-end-of-subtree t t) (progn (org-end-of-subtree t t)
(when (and (org-at-heading-p) (not (eobp))) (when (and (org-at-heading-p) (not (eobp)))
(backward-char 1)) (backward-char 1))
(point))))))))) (point))))))))
(apply orig-fn args)))) (apply orig-fn args))))

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

@ -48,20 +48,7 @@
(cond ((featurep! :completion helm) 'helm) (cond ((featurep! :completion helm) 'helm)
((featurep! :completion ivy) 'ivy) ((featurep! :completion ivy) 'ivy)
((featurep! :completion ido) 'ido) ((featurep! :completion ido) 'ido)
('default)) ('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)
;; Normally, the org-roam buffer doesn't open until you explicitly call ;; 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 ;; `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 :recipe (:host github
:repo "emacs-straight/org-mode" :repo "emacs-straight/org-mode"
:files ("*.el" "lisp/*.el" "contrib/lisp/*.el")) :files ("*.el" "lisp/*.el" "contrib/lisp/*.el"))
:pin "31068373dc") :pin "e5eda0beeb3b6b0666550091bcc0df066d52c008")
;; ...And prevent other packages from pulling org; org-plus-contrib satisfies ;; ...And prevent other packages from pulling org; org-plus-contrib satisfies
;; the dependency already: https://github.com/raxod502/straight.el/issues/352 ;; the dependency already: https://github.com/raxod502/straight.el/issues/352
(package! org :recipe (:local-repo nil)) (package! org :recipe (:local-repo nil))
(package! avy) (package! avy)
(package! htmlize :pin "86f22f211e") (package! htmlize :pin "86f22f211e9230857197c42a9823d3f05381deed")
(package! org-superstar :pin "09ddc28383") (package! org-superstar :pin "09ddc28383d363a4b353348a433e24535b4af0e3")
(package! org-yt (package! org-yt
:recipe (:host github :repo "TobiasZawada/org-yt") :recipe (:host github :repo "TobiasZawada/org-yt")
:pin "40cc1ac76d") :pin "40cc1ac76d741055cbefa13860d9f070a7ade001")
(package! ox-clip :pin "bd36f9fb4e") (package! ox-clip :pin "bd36f9fb4e3b1b9e8686b993b02ccd780ff75a96")
(package! toc-org :pin "5deaec41ed") (package! toc-org :pin "5deaec41ed0e5c51715737d7f74c5ae1b3c00387")
(package! org-cliplink :pin "82402cae7e") (package! org-cliplink :pin "82402cae7e118d67de7328417fd018a18f95fac2")
(when (featurep! :editor evil +everywhere) (when (featurep! :editor evil +everywhere)
(package! evil-org (package! evil-org
:recipe (:host github :repo "hlissner/evil-org-mode") :recipe (:host github :repo "hlissner/evil-org-mode")
:pin "9cf661af8f")) :pin "9cf661af8ff8ea768ef1e55045be14d0468a90f5"))
(when (featurep! :tools pdf) (when (featurep! :tools pdf)
(package! org-pdftools :pin "8cc15bb801")) (package! org-pdftools :pin "8cc15bb8014ed1f047eecc0abd8bf447f86c0505"))
(when (featurep! :tools magit) (when (featurep! :tools magit)
(package! orgit :pin "e147f05577")) (package! orgit :pin "e147f055772cc934fe1f1d8619059badeb647c93"))
(when (featurep! +brain) (when (featurep! +brain)
(package! org-brain :pin "7ffbf6816a")) (package! org-brain :pin "ae7fe0f628bd093526786ece6917f7a4310e5e4d"))
(when (featurep! +dragndrop) (when (featurep! +dragndrop)
(package! org-download :pin "46417e2bd3")) (package! org-download :pin "48d3952ad8ebc5ef5a6a77b8c6a4a0da61653036"))
(when (featurep! +gnuplot) (when (featurep! +gnuplot)
(package! gnuplot :pin "f0001c3001") (package! gnuplot :pin "f0001c30010b2899e36d7d89046322467e923088")
(package! gnuplot-mode :pin "601f639298")) (package! gnuplot-mode :pin "601f6392986f0cba332c87678d31ae0d0a496ce7"))
(when (featurep! +ipython) ; DEPRECATED (when (featurep! +ipython) ; DEPRECATED
(package! ob-ipython :pin "7147455230")) (package! ob-ipython :pin "7147455230841744fb5b95dcbe03320313a77124"))
(when (featurep! +jupyter) (when (featurep! +jupyter)
(package! jupyter :pin "785edbbff6")) (package! jupyter :pin "785edbbff65abb0c929dc2fbd8b8305c77fd529e"))
(when (featurep! +journal) (when (featurep! +journal)
(package! org-journal :pin "8bf06b28d6")) (package! org-journal :pin "8bf06b28d6f14f52d4968123e2b4b91930c8f947"))
(when (featurep! +noter) (when (featurep! +noter)
(package! org-noter :pin "9ead81d42d")) (package! org-noter :pin "9ead81d42dd4dd5074782d239b2efddf9b8b7b3d"))
(when (featurep! +pomodoro) (when (featurep! +pomodoro)
(package! org-pomodoro :pin "aa07c11318")) (package! org-pomodoro :pin "aa07c11318f91219336197e62c47bc7a3d090479"))
(when (featurep! +present) (when (featurep! +present)
(package! centered-window (package! centered-window
:recipe (:host github :repo "anler/centered-window-mode") :recipe (:host github :repo "anler/centered-window-mode")
:pin "24f7c5be9d") :pin "f50859941ab5c7cbeaee410f2d38716252b552ac")
(package! org-tree-slide :pin "7bf09a02bd") (package! org-tree-slide :pin "7bf09a02bd2d8f1ccfcb5209bfb18fbe02d1f44e")
(package! org-re-reveal :pin "61549f4c00")) (package! org-re-reveal :pin "61549f4c00284a30e34caa3d76001b233ea5d2ad"))
(when (featurep! +roam) (when (featurep! +roam)
(package! org-roam :pin "963692f353") (package! org-roam :pin "e698ed7f5378106da8a8fec4537658392157657c")
(when (featurep! :completion company) (when (featurep! :completion company)
(package! company-org-roam :pin "0913d86f16"))) (package! company-org-roam :pin "0913d86f167164e18831206e611f44bb8e7297e3")))
;;; Babel ;;; Babel
(package! ob-async :pin "80a30b96a0") (package! ob-async :pin "80a30b96a007d419ece12c976a81804ede340311")
(when (featurep! :lang crystal) (when (featurep! :lang crystal)
(package! ob-crystal :pin "d84c1adee4")) (package! ob-crystal :pin "d84c1adee4b269cdba06a97caedb8071561a09af"))
(when (featurep! :lang go) (when (featurep! :lang go)
(package! ob-go :pin "2067ed55f4")) (package! ob-go :pin "2067ed55f4c1d33a43cb3f6948609d240a8915f5"))
(when (featurep! :lang hy) (when (featurep! :lang hy)
(package! ob-hy :pin "a42ecaf440")) (package! ob-hy :pin "a42ecaf440adc03e279afe43ee5ef6093ddd542a"))
(when (featurep! :lang nim) (when (featurep! :lang nim)
(package! ob-nim :pin "bf1642cb93")) (package! ob-nim :pin "bf1642cb93f0a898804dc13fd9408d2964403bd2"))
(when (featurep! :lang racket) (when (featurep! :lang racket)
(package! ob-racket (package! ob-racket
:recipe (:host github :repo "DEADB17/ob-racket") :recipe (:host github :repo "DEADB17/ob-racket")
:pin "d8fd51bddb")) :pin "d8fd51bddb019b0eb68755255f88fc800cfe03cb"))
(when (featurep! :lang rest) (when (featurep! :lang rest)
(package! ob-restclient :pin "f7449b2068")) (package! ob-restclient :pin "f7449b2068498fe9d8ab9589e0a638148861533f"))
(when (featurep! :lang rust) (when (featurep! :lang rust)
(package! ob-rust :pin "6a82587598")) (package! ob-rust :pin "6a82587598cd097e9642be916243c31f1231b24a"))
(when (featurep! :lang scala) (when (featurep! :lang scala)
(package! ob-ammonite :pin "39937dff39")) (package! ob-ammonite :pin "39937dff395e70aff76a4224fa49cf2ec6c57cca"))
;;; Export ;;; Export
(when (featurep! +pandoc) (when (featurep! +pandoc)
(package! ox-pandoc :pin "aa37dc7e94")) (package! ox-pandoc :pin "aa37dc7e94213d4ebedb85c384c1ba35007da18e"))
(when (featurep! +hugo) (when (featurep! +hugo)
(package! ox-hugo (package! ox-hugo
:recipe (:host github :repo "kaushalmodi/ox-hugo" :nonrecursive t) :recipe (:host github :repo "kaushalmodi/ox-hugo" :nonrecursive t)
:pin "5106b430a1")) :pin "8f36181977377383cb54803651d93b24e370122d"))
(when (featurep! :lang rst) (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. ;; 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) :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; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/perl/packages.el ;;; lang/perl/packages.el
(package! perl6-mode :pin "88de065795") (package! raku-mode :pin "d474216840251dc0efe4f4aa4f5c5f66ac26fa74")
(when (featurep! :checkers syntax) (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; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/racket/packages.el ;;; 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!)) (add-hook 'ruby-mode-local-vars-hook #'lsp!))
(after! inf-ruby (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 ;; switch to inf-ruby from compile if we detect a breakpoint has been hit
(add-hook 'compilation-filter-hook #'inf-ruby-auto-enter)) (add-hook 'compilation-filter-hook #'inf-ruby-auto-enter))
@ -173,6 +174,7 @@
(use-package! projectile-rails (use-package! projectile-rails
:when (featurep! +rails) :when (featurep! +rails)
:hook ((ruby-mode inf-ruby-mode projectile-rails-server-mode) . projectile-rails-mode) :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 :init
(setq inf-ruby-console-environment "development") (setq inf-ruby-console-environment "development")
(when (featurep! :lang web) (when (featurep! :lang web)

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

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

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

@ -2,7 +2,7 @@
;;; lang/sh/packages.el ;;; lang/sh/packages.el
(when (featurep! :completion company) (when (featurep! :completion company)
(package! company-shell :pin "52f3bf26b7")) (package! company-shell :pin "52f3bf26b74adc30a275f5f4290a1fc72a6876ff"))
(when (featurep! +fish) (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; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/solidity/packages.el ;;; lang/solidity/packages.el
(package! solidity-mode :pin "b190993dcb") (package! solidity-mode :pin "022b3159832384a7dcdc2168809e698600826047")
(package! company-solidity :pin "b190993dcb") (package! company-solidity)
(package! solidity-flycheck :pin "b190993dcb") (package! solidity-flycheck)

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

@ -1,11 +1,11 @@
;; -*- no-byte-compile: t; -*- ;; -*- no-byte-compile: t; -*-
;;; lang/swift/packages.el ;;; lang/swift/packages.el
(package! swift-mode :pin "1268425311") (package! swift-mode :pin "2ab9ea1784a12a482ed9e3fb284b7a7658f40fff")
(if (featurep! +lsp) (if (featurep! +lsp)
(package! lsp-sourcekit :pin "04d75b6a0b") (package! lsp-sourcekit :pin "04d75b6a0be5894fea4a55fec0b2ccedf5b3be58")
(when (featurep! :completion company) (when (featurep! :completion company)
(package! company-sourcekit :pin "abf9bc5a01")) (package! company-sourcekit :pin "abf9bc5a0102eb666d3aa6d6bf22f6efcc852781"))
(when (featurep! :checkers syntax) (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) (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 ;;; lang/web/packages.el
;; +html.el ;; +html.el
(package! emmet-mode :pin "1acb821e01") (package! emmet-mode :pin "1acb821e0142136344ccf40c1e5fb664d7db2e70")
(package! haml-mode :pin "bf5b6c11b1") (package! haml-mode :pin "bf5b6c11b1206759d2b28af48765e04882dd1fc4")
(package! pug-mode :pin "685fd3414d") (package! pug-mode :pin "685fd3414d89736bf232f5d1a6bed9e0353b98fe")
(package! slim-mode :pin "3636d18ab1") (package! slim-mode :pin "3636d18ab1c8b316eea71c4732eb44743e2ded87")
(when (package! web-mode :pin "b0bb4ab82b") (when (package! web-mode :pin "6774c596a9b3988989d3bc96b6194e6f0df1d1b6")
(when (featurep! :completion company) (when (featurep! :completion company)
(package! company-web :pin "f0cc9187c9"))) (package! company-web :pin "f0cc9187c9c34f72ad71f5649a69c74f996bae9a")))
;; +css.el ;; +css.el
(package! css-mode :built-in t) (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! sass-mode :pin "247a0d4b509f10b28e4687cd8763492bca03599b")
(package! stylus-mode :pin "4dbde92542") (package! stylus-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
(package! sws-mode :pin "4dbde92542") (package! sws-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
(package! rainbow-mode :pin "3ef813d637") (package! rainbow-mode :pin "f780ddb18c2a73a666d093f606df92058e5601ea")
(when (featurep! :completion ivy) (when (featurep! :completion ivy)
(package! counsel-css :pin "61a38c9d50")) (package! counsel-css :pin "6427dfcbda0d2bbd81db03f9d6b56b06c260ac02"))
(when (featurep! :completion helm) (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