342 lines
14 KiB
EmacsLisp
342 lines
14 KiB
EmacsLisp
;;; core-packages.el
|
|
|
|
;; Emacs package management is opinionated. Unfortunately, so am I. So I
|
|
;; combined `use-package`, quelpa and package.el to manage my plugins.
|
|
;;
|
|
;; Why all the trouble? Because:
|
|
;; 1. Scriptability: I want my plugins managable from the command line (as well
|
|
;; as an `doom/packages-update' command within emacs to update my plugins
|
|
;; automatically, rather than through package.el's interface).
|
|
;; 2. Flexibility: I want to install packages from sources other than ELPA
|
|
;; repositories. Such as github or the Emacs wiki. Some plugins are out of
|
|
;; date through official channels, have changed hands unofficially, or simply
|
|
;; haven't been submitted to an ELPA repo yet.
|
|
;; 3. Stability: I don't want to worry that each time I use my package
|
|
;; manager something might inexplicably go wrong. This was the case with
|
|
;; Cask, which I used previously. package.el and quelpa appear to be much
|
|
;; more stable.
|
|
;; 4. No external dependencies (e.g. Cask) for plugin management.
|
|
|
|
(defvar doom-enabled-modules nil
|
|
"List of enabled modules; each element is a cons cell (MODULE . SUBMODULE),
|
|
where MODULE is the module's property symbol, e.g. :lang, and SUBMODULE is the
|
|
submodule symbol, e.g. 'evil.")
|
|
|
|
(defvar doom-packages nil
|
|
"A list of enabled packages.")
|
|
|
|
(defvar doom-protected-packages '(quelpa use-package dash f s)
|
|
"A list of packages that shouldn't be deleted.")
|
|
|
|
(defvar doom-init-p nil
|
|
"Non-nil if doom's package system has been initialized or not. It may not be
|
|
if you have byte-compiled your configuration (as intended).")
|
|
|
|
(defvar doom-dont-load-p nil
|
|
"If non-nil, run DOOM emacs in declarative mode, meaning: don't actually load
|
|
anything, just track what should be loaded. Useful for scanning packages and
|
|
loaded modules.")
|
|
|
|
(defvar doom-reloading-p nil
|
|
"If non-nil, DOOM is reloading itself. Use this to determine to prevent
|
|
infinite recursion.")
|
|
|
|
(defvar doom-prefer-el-p noninteractive
|
|
"If non-nil, load uncompiled .el config files.")
|
|
|
|
(defvar doom--base-load-path (append (list doom-core-dir
|
|
doom-modules-dir)
|
|
load-path)
|
|
"A backup of `load-path', used as a bare-bones foundation for
|
|
`doom/packages-reload' or `doom-initialize'.")
|
|
|
|
(setq load-prefer-newer nil
|
|
package--init-file-ensured t
|
|
package-user-dir (expand-file-name "elpa" doom-packages-dir)
|
|
package-enable-at-startup nil
|
|
package-archives
|
|
'(("gnu" . "http://elpa.gnu.org/packages/")
|
|
("melpa" . "http://melpa.org/packages/")
|
|
("org" . "http://orgmode.org/elpa/"))
|
|
|
|
use-package-always-defer t
|
|
use-package-always-ensure nil
|
|
use-package-expand-minimally t
|
|
use-package-debug nil
|
|
use-package-verbose doom-debug-mode
|
|
quelpa-checkout-melpa-p nil
|
|
quelpa-update-melpa-p nil
|
|
quelpa-dir (expand-file-name "quelpa" doom-packages-dir)
|
|
;; ssh, no tears. Only compiling.
|
|
byte-compile-warnings
|
|
'(unresolved callargs obsolete noruntime cl-functions make-local constants suspicious))
|
|
|
|
|
|
;;
|
|
;; Bootstrap function
|
|
;;
|
|
|
|
(defmacro doom! (&rest packages)
|
|
"DOOM Emacs bootstrap macro. List the modules to load. Benefits from
|
|
byte-compilation."
|
|
(let (mode)
|
|
(dolist (p packages)
|
|
(cond ((string-prefix-p ":" (symbol-name p))
|
|
(setq mode p))
|
|
((not mode)
|
|
(error "No namespace specified on `doom!' for %s" p))
|
|
(t
|
|
(setq doom-enabled-modules (append doom-enabled-modules (list (cons mode p))))))))
|
|
`(unless doom-dont-load-p
|
|
(let (file-name-handler-alist)
|
|
,@(mapcar (lambda (pkg) `(load! ,(car pkg) ,(cdr pkg)))
|
|
doom-enabled-modules)
|
|
|
|
(when (display-graphic-p)
|
|
(require 'server)
|
|
(unless (server-running-p)
|
|
(server-start)))
|
|
|
|
;; Prevent any auto-displayed text + benchmarking
|
|
(advice-add 'display-startup-echo-area-message :override 'ignore)
|
|
(message "Loaded %s packages in %s"
|
|
(- (length load-path) (length doom--base-load-path))
|
|
(emacs-init-time)))))
|
|
|
|
(defun doom-initialize (&optional force-p)
|
|
"Initialize installed packages (using package.el) and ensure the core packages
|
|
are installed. If you byte compile core/core.el, calls to `package.el' are
|
|
avoided to speed up startup."
|
|
(unless (or doom-init-p force-p)
|
|
(setq load-path doom--base-load-path
|
|
package-activated-list nil)
|
|
(package-initialize t)
|
|
;; Sure, package-initialize fills the load-path, but it will error out on
|
|
;; missing packages. UNACCEPTAABBLLLE!
|
|
(setq load-path
|
|
(append load-path
|
|
(directory-files package-user-dir t "^[a-zA-Z0-9]" t)))
|
|
|
|
(unless (and (file-exists-p doom-packages-dir)
|
|
(require 'use-package nil t)
|
|
(require 'quelpa nil t))
|
|
(package-refresh-contents)
|
|
;; Ensure core packages are installed
|
|
(condition-case ex
|
|
(mapc (lambda (pkg)
|
|
(package-install pkg)
|
|
(unless (package-installed-p pkg)
|
|
(error "Couldn't install %s" pkg)))
|
|
doom-protected-packages)
|
|
(error
|
|
(delete-directory doom-packages-dir t)
|
|
(error "There was an error initializing DOOM. Try running it again"))))
|
|
|
|
(require 'quelpa)
|
|
(require 'use-package)
|
|
(advice-add 'package-delete :after 'doom*package-delete)
|
|
;; Remove package management keywords, I'll deal with the myself
|
|
(mapc (lambda (keyword) (setq use-package-keywords (delq keyword use-package-keywords)))
|
|
'(:ensure :pin))
|
|
(setq doom-init-p t)))
|
|
|
|
(defun doom-reload ()
|
|
"Rereads the Emacs config, reloading `doom-packages' and
|
|
`doom-enabled-modules'."
|
|
(unless doom-reloading-p
|
|
(doom-initialize)
|
|
(let ((doom-prefer-el-p t)
|
|
(doom-dont-load-p t)
|
|
(doom-reloading-p t)
|
|
noninteractive)
|
|
(setq doom-enabled-modules nil
|
|
doom-packages nil)
|
|
(let ((load-fn (lambda (file) (load file :noerror (not doom-debug-mode) :nosuffix))))
|
|
(mapc load-fn
|
|
(list (f-expand "init.el" doom-emacs-dir)
|
|
(f-expand "core.el" doom-core-dir)))
|
|
(mapc load-fn
|
|
(--map (doom-module-path (car it) (cdr it) "packages.el")
|
|
doom-enabled-modules))))))
|
|
|
|
|
|
;;
|
|
;; Macros
|
|
;;
|
|
|
|
(defvar __DIR__ nil "The directory of the currently loaded file (set by `load!')")
|
|
(defvar __FILE__ nil "The full path of the currently loaded file (set by `load!')")
|
|
(defvar __PACKAGE__ nil "The name of the current package.")
|
|
|
|
(defmacro use-package! (name &rest plist)
|
|
"A `use-package' wrapper. It exists so configs can adhere to the naming
|
|
conventions of DOOM emacs, as well as let-bind `__PACKAGE__' for the containing
|
|
forms. This is helpful for macros like `set!' and `add-hook!'. Note that
|
|
packages are deferred by default."
|
|
(declare (indent defun))
|
|
`(let ((__PACKAGE__ ',name))
|
|
(use-package ,name ,@plist)))
|
|
|
|
(defmacro package! (name &rest plist)
|
|
"Wraps around `use-package' to declare a deferred package (unless otherwise
|
|
indicated), takes the same arguments, but adds the :recipe property, which takes
|
|
a MELPA recipe. Also binds `__PACKAGE__` for PLIST forms to optionally use."
|
|
(declare (indent defun))
|
|
(let ((recipe (cadr (memq :recipe plist)))
|
|
(pin (cadr (memq :pin plist)))
|
|
(lpath (cadr (memq :load-path plist))))
|
|
(when (and recipe (= 0 (mod (length recipe) 2)))
|
|
(push name recipe))
|
|
(if (not lpath)
|
|
(cl-pushnew (cons name recipe) doom-packages :key 'car)
|
|
(cl-pushnew lpath doom--base-load-path)
|
|
(setq recipe nil
|
|
pin nil))
|
|
(when pin
|
|
(cl-pushnew (cons package (plist-get plist :pin)) package-pinned-packages :key 'car))
|
|
(setq plist (use-package-plist-delete plist :recipe))
|
|
(setq plist (use-package-plist-delete plist :pin))
|
|
(unless doom-dont-load-p
|
|
`(use-package! ,name ,@plist))))
|
|
|
|
(defmacro require! (feature)
|
|
"Like `require', but will prefer uncompiled files if `doom-prefer-el-p' is
|
|
non-nil or this is a noninteractive session."
|
|
(let ((prefer-el-p (or doom-prefer-el-p noninteractive)))
|
|
`(require ',feature
|
|
,(locate-file (concat (symbol-name feature) (if prefer-el-p ".el"))
|
|
load-path))))
|
|
|
|
(defmacro load! (module &optional submodule file)
|
|
"Load a module from `doom-modules-dir' when both MODULE and SUBMODULE is
|
|
provided (both symbols). If FILE is non-nil, append it to the resulting path. If
|
|
SUBMODULE is nil, MODULE is loaded relative to the current file (see `__DIR__').
|
|
When SUBMODULE is nil, FILE isn't used.
|
|
|
|
Will prefer uncompiled elisp sources if `doom-prefer-el-p' is non-nil or this is
|
|
an noninteractive session.
|
|
|
|
Examples:
|
|
(load! :lang emacs-lisp)
|
|
|
|
Loads modules/lang/emacs-lisp/FILE.el (defaults to config.el).
|
|
|
|
(load! +local-module)
|
|
|
|
Loads +local-module.el relative to `__DIR__' or `doom-core-dir'."
|
|
(let ((prefer-el-p (or doom-prefer-el-p noninteractive))
|
|
path file)
|
|
(cond ((null submodule)
|
|
(setq path __DIR__
|
|
file (concat (symbol-name module) ".el")))
|
|
(t
|
|
(cl-pushnew (cons module submodule)
|
|
doom-enabled-modules
|
|
:test (lambda (x y) (and (eq (car x) (car y))
|
|
(eq (cdr x) (cdr y)))))
|
|
(setq path (doom-module-path module submodule)
|
|
file (or file "config.el"))))
|
|
(setq path (f-slash path)
|
|
file (concat path file))
|
|
`(let ((__FILE__ ,file)
|
|
(__DIR__ ,path))
|
|
(load ,(if doom-prefer-el-p file (f-no-ext file))
|
|
nil (not doom-debug-mode) ,doom-prefer-el-p))))
|
|
|
|
(defun doom-module-path (module submodule &optional file)
|
|
"Get the full path to a module: e.g. :lang emacs-lisp maps to
|
|
~/.emacs.d/modules/lang/emacs-lisp/. Will append FILE if non-nil."
|
|
(setq module
|
|
(cond ((keywordp module) (substring (symbol-name module) 1))
|
|
((symbolp module) (symbol-name module))
|
|
((stringp module) module)
|
|
(t (error "Not a valid module name: %s" module))))
|
|
(when (symbolp submodule)
|
|
(setq submodule (symbol-name submodule)))
|
|
(f-expand (concat module "/" submodule "/" file)
|
|
doom-modules-dir))
|
|
|
|
|
|
;;
|
|
;; Commands
|
|
;;
|
|
|
|
(defun doom/reload ()
|
|
"Reload `load-path' by scanning all packages. Run this if you ran make update
|
|
or make clean outside of Emacs."
|
|
(interactive)
|
|
(doom-initialize t)
|
|
(message "Reloaded %s packages" (length package-alist)))
|
|
|
|
(defun doom/refresh-autoloads ()
|
|
"Refreshes the autoloads.el file, which tells Emacs where to find all the
|
|
autoloaded functions in the modules you use or among the core libraries.
|
|
|
|
In modules, checks for modules/*/autoload.el and modules/*/autoload/*.el.
|
|
|
|
Rerun this whenever you modify your init.el (or use `make autoloads` from the
|
|
command line)."
|
|
(interactive)
|
|
(unless doom-reloading-p
|
|
(doom-reload)
|
|
(let ((generated-autoload-file (concat doom-local-dir "autoloads.el"))
|
|
(autoload-files
|
|
(append (-flatten (mapcar (lambda (dir)
|
|
(let ((auto-dir (f-expand "autoload" dir))
|
|
(auto-file (f-expand "autoload.el" dir)))
|
|
(cond ((f-directory-p auto-dir)
|
|
(f-glob "*.el" auto-dir))
|
|
((f-exists-p auto-file)
|
|
auto-file))))
|
|
(--map (doom-module-path (car it) (cdr it)) doom-enabled-modules)))
|
|
(f-glob "autoload/*.el" doom-core-dir))))
|
|
(when (f-exists-p generated-autoload-file)
|
|
(f-delete generated-autoload-file)
|
|
(message "Deleted old autoloads.el"))
|
|
(dolist (file autoload-files)
|
|
(update-file-autoloads file)
|
|
(message "Detected: %s" (f-relative file doom-emacs-dir)))
|
|
(with-current-buffer (get-file-buffer generated-autoload-file)
|
|
(save-buffer)
|
|
(eval-buffer))
|
|
(message "Done!"))))
|
|
|
|
(defun doom/byte-compile (&optional comprehensive-p)
|
|
"Byte (re)compile the important files in your emacs configuration (i.e.
|
|
init.el, core/*.el and modules/*/*/config.el) DOOM Emacs was designed to benefit
|
|
a lot from this.
|
|
|
|
If COMPREHENSIVE-P is non-nil, then compile modules/*/*/*.el (except for
|
|
packages.el files). The benefit from this is minimal and may take more time."
|
|
(interactive)
|
|
(doom-reload)
|
|
(let ((targets (append
|
|
(list (f-expand "init.el" doom-emacs-dir)
|
|
(f-expand "core.el" doom-core-dir))
|
|
(f-glob "core-*.el" doom-core-dir)
|
|
(-flatten
|
|
(--map (f--entries (doom-module-path (car it) (cdr it))
|
|
(and (f-ext-p it "el")
|
|
(if comprehensive-p
|
|
(not (string= (f-base it) "packages"))
|
|
(string= (f-base it) "config")))
|
|
t)
|
|
doom-enabled-modules))))
|
|
(n 0)
|
|
results)
|
|
(mapc (lambda (file)
|
|
(push (cons (f-relative file doom-emacs-dir)
|
|
(when (byte-recompile-file file nil 0)
|
|
(setq n (1+ n))
|
|
t))
|
|
results))
|
|
targets)
|
|
(when noninteractive
|
|
(when targets (message "\n"))
|
|
(message "Compiling %s files:\n%s" n
|
|
(mapconcat (lambda (file) (concat "+ " (if (cdr file) "SUCCESS" "FAIL") ": " (car file)))
|
|
(reverse results) "\n")))))
|
|
|
|
(provide 'core-packages)
|
|
;;; core-packages.el ends here
|