This makes package.el commands safe to use in Doom, and prevents errors
caused by unitialized state, by running package-initialize before
you use a package.el command.
Formerly, you were required to have a doom! call (even a blank one) in
~/.doom.d/init.el if you wanted to have private sub-modules in
~/.doom.d/modules/.
No more. It is no longer doom!'s responsibility to affect
`doom-modules-dirs`. This is now done by :config private, while the
Doom modules directory is now the initial entry in doom-modules-dirs.
+ Fix#446, where the .local/packages.el cache was generated with
a faulty load-path.
+ Entries in the doom-modules hash table are now plists, containing
:flags and :path, at least.
+ Add doom-initialize-modules for loading module config.el files.
+ Add doom-module-get for accessing this plist, e.g.
(doom-module-get :some module) ; returns plist
(doom-module-get :some module :flags) ; return specific property
+ Replace doom-module-enable with doom-module-set, e.g.
(doom-module-set :some module :flags '(+a +b +c))
+ Remove doom-module-flags (use doom-module-get instead)
+ Rename doom-module-enabled-p with doom-module-p
+ Replace doom-module-path with doom-module-find-path and
doom-module-expand-file. The former will search for an existing module
or file in doom-modules-dirs. The latter will expand the path from
whatever path is stored in doom-modules.
+ Replace doom-module-paths with doom-module-load-path
+ Changed doom! to allow for nested doom! calls by delaying the loading
of module config.el files until as late as possible.
+ Refactor doom-initialize-packages to only ihitialize package state
(i.e. doom-packages, package-alist, and quelpa-cache), rather than its
previous behavior of loading all Doom files (and sometimes all module
files). This is faster and more predictable.
Doom saves a lot of startup time by avoiding package-initialize, because
it loads every packages' autoloads file, which is expensive.
Unfortunately, these autoloads files are necessary for some plugins with
abnormal file structures (such as ESS). Previously, I was content with
loading them myself, but these occurrences have become more frequent, so
it would be safest if I relied on package-initialize more.
So doom-initialize will now do so. However, it will cache the load-path
(and Info-directory-list, fixing the lost info buffers) on first run.
This makes byte-compiling Doom almost useless, but it makes startup just
as fast as Doom would be if you had.
This needs more testing.
Autoload paths used to be relative to arbitrary roots (usually
doom-modules-dir). This commit changes doom//reload-autoloads to iterate
over autoloads in doom-autoloads-file and replace their file paths with
an absolute one.
Theoretically this should make Emacs feel marginally faster, but we
*probably* get more of a benefit from a shorter load-path (because we no
longer need doom-modules-dirs, doom-core-dir or doom-psuedo-module-paths
in the load-path).
This is highly experimental however!
Any module can now use a doom! call to declare a module tree root.
This means that if you have a doom! block in
~/.emacs.d/modules/lang/org/init.el, then you can have submodules in
~/.emacs.d/modules/lang/org/modules/MODULE/SUBMODULE if you wanted to
for some reason.
This is only really truly useful for private modules. A doom! block in
~/.doom.d/init.el will recognize and enable modules in
~/.doom.d/modules/.
~/.doom.d/modules is now a full module tree, like ~/.emacs.d/modules.
Symlinks are no longer involved.
Private modules can now shadow Doom modules. e.g.
~/.doom.d/modules/lang/org will take precendence over
~/.emacs.d/modules/lang/org.
Also, made doom--*-load-path variables public (e.g. doom--site-load-path
=> doom-site-load-path), and rearranged the load-path for a 10-15%
startup boost.
Originally, I built the load-path with site-lisp paths first, then
packages. There was a modest ~10% startup boost doing this, because
there were considerably more site packages loaded at startup than
plugins.
However, this meant built-in packages would get precedence over plugins,
which is undesirable. In org's case, I simply modified the load-path
in lang/org/init.el. However, this issue has cropped up again in #340.
Evidently, that 10% boost may not be worth the risk it imposes, so I've
rearranged the load-path with packages first.
+ map-delete is shorter and faster than assq-delete-all
+ map-put is simpler than the delete-then-set workflow
+ map-merge is great for merging default and user settings
`get-file-buffer` returns nil if no buffer for that file already exists.
In an edge case on Windows, `update-file-autoloads` doesn't leave
a hanging buffer, possibly ignoring its SAVE-AFTER argument. Using
`find-file-noselect` fixes this, which will open a buffer if one doesn't
already exist.
Now that the org ELPA archive has https support, we can add it to
package-archives. This fixes some 'org is unavailable' errors when
installing org packages that have declared earlier versions of org as
a dependency.
This also makes installing a newer version of org-mode much simpler.
Woo!
This causes errors because of arbitrary module load order. This happens
in Emacs 25.x, because hash-table-keys there uses maphash, while in
Emacs 26+ it uses cl-loop.
Local cache and data files were stored in a parent folder named after
your host, because I'd symlink the same config across computers via
dropbox. This would cause byte-compile issues in packages, so I stopped
doing this.
Now that each computer gets its own clone, host-namespaced local
directories are unnecessary. There's no other benefit to having them.
User module (named after user-login-name) is no longer automatically
loaded or detected, and must be explicitly mentioned in the doom! macro
of your emacs init.el file.
Also, any module can now have an init.el file, which will be run before
any modules are loaded.
Use-package broke in a recent update, as with Doom, since it relies so
heavily on it. To combat this issue arising again, use-package will be
installed from melpa-stable from now on.
Addresses #283
For example:
(doom! :feature (version-control +git))
I leave it to modules to interpret these flags, and they can be detected
through one of the following:
+ (featurep! :feature version-control +git)
+ (featurep! +git) -- syntactic sugar, only available from within
modules.
+ (doom-module-flags :feature version-control) -- returns a list of
flags for this module.
Flags are also available from packages.el files.
doom-initialize-packages re-initializes certain important variables,
like gc-cons-threshold (which causes intermittent freezing when set too
high), without resetting them to sensible defaults. This ensures those
variable are reset afterwards.
It would reload all files; which is harmless, but does unnecessarily
inflate variables that get push-ed or nconc-ed to. It's best to compile
from the command line.
+ Moved unit tests out of tests/ and into their respective modules.
+ Rewrite makefile and added these tasks:
+ <MODULE>/<SUBMODULE> -- byte-compile a specific module
+ test:<MODULE>/<SUBMODULE> -- runs tests for a specific module
+ testi -- run tests in an interactive session of Emacs (WIP)
+ run -- opens an Emacs session with this config; useful when it is in
a non-standard location.
This refactor is about improving how Emacs deals with errors.
A large net is now cast at startup to catch possible errors, produce
more helpful error messages, and localize the damage. Significantly
reducing the risk of later modules not loading (and leaving you
stranded in a half-broken Emacs session).
The DOOM core files are an exception. If something messes up in there,
it *should* choke.
+ use-package will now report missing packages or slow-loading/broken
def-package! configurations.
+ Persp-mode no longer (inadvertantly) hides buffers that pop up at
startup, like the *Warnings*, *Backtrace* or debugger buffers.
+ `make autoloads` (or doom/reload-autoloads) now produces a slightly
more informative error message if an error occurs while building the
autoloads file.
+ Error handling for package management is *slightly* better now; error
messages now include the type of error; this needs work.
+ Add doom-init-hook and doom-post-init-hook to simplify Emacs init
hooks into less ambiguous ones.
+ Attach former after-init-hook and emacs-startup-hook hooks to new doom
init hooks.
+ Vastly improves daemon and tty support: preventing incorrect colors
from bleeding across face class barriers, and into GUI Emacs and vice
versa, when spawned with emacsclient.
+ Fix persp-mode breaking Emacs daemon, and ensuring that initialization
is done properly in terminal Emacs (and emacsclient frames).
+ enable lexical-scope everywhere (lexical-binding = t): ~5-10% faster
startup; ~5-20% general boost
+ reduce consing, function calls & garbage collection by preferring
cl-loop & dolist over lambda closures (for mapc[ar], add-hook, and
various cl-lib filter/map/reduce functions) -- where possible
+ prefer functions with dedicated opcodes, like assq (see byte-defop's
in bytecomp.el for more)
+ prefer pcase & cond (faster) over cl-case
+ general refactor for code readability
+ ensure naming & style conventions are adhered to
+ appease byte-compiler by marking unused variables with underscore
+ defer minor mode activation to after-init, emacs-startup or
window-setup hooks; a customization opportunity for users + ensures
custom functionality won't interfere with startup.
Ensures that private settings are available during byte-compilation.
Also fixes a compile error when private init.el (which should be an
optional file) doesn't exist.
