emenel/doomemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
doomemacs/core/autoload/packages.el

624 lines
24 KiB
EmacsLisp
Raw Normal View History

Major optimization refactor, across the board + 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.
2017-06-08 11:47:56 +02:00
;;; core/autoload/packages.el -*- lexical-binding: t; -*-
Move package commands to core/autoload/packages.el
2017-02-02 19:15:58 -05:00
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(require 'core-packages)
(load! "cache") ; in case autoloads haven't been generated yet
Fix package-refresh-contents loop bug in package management
2017-04-04 12:29:34 -04:00
Allow use of package.el #444 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.
2018-03-14 18:25:22 -04:00
(defun doom--packages-choose (prompt)
(let ((table (cl-loop for pkg in package-alist
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
unless (doom-package-built-in-p (cdr pkg))
Allow use of package.el #444 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.
2018-03-14 18:25:22 -04:00
collect (cons (package-desc-full-name (cdr pkg))
(cdr pkg)))))
(cdr (assoc (completing-read prompt
(mapcar #'car table)
nil t)
table))))
(defun doom--refresh-pkg-cache ()
"Clear the cache for `doom-refresh-packages-maybe'."
(setq doom--refreshed-p nil)
(doom-cache-set 'last-pkg-refresh nil))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
Allow use of package.el #444 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.
2018-03-14 18:25:22 -04:00
(defun doom-refresh-packages-maybe (&optional force-p)
"Refresh ELPA packages, if it hasn't been refreshed recently."
Refactor doom-refresh-packages (and make it async)
2017-05-27 18:29:32 +02:00
(when force-p
Allow use of package.el #444 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.
2018-03-14 18:25:22 -04:00
(doom--refresh-pkg-cache))
Add new cache library (persistent-soft wrapper)
2018-01-06 17:00:14 -05:00
(unless (or (doom-cache-get 'last-pkg-refresh)
Run doom//reload-autoloads in separate session Includes a minor refactor core/core-packages.el
2017-11-08 22:49:11 +01:00
doom--refreshed-p)
Minor error handler refactor in package management Allow debugger to produce better backtraces.
2018-06-20 02:23:55 +02:00
(condition-case e
Improve error handling for package management
2017-05-19 22:29:47 +02:00
(progn
Refactor doom-refresh-packages (and make it async)
2017-05-27 18:29:32 +02:00
(message "Refreshing package archives")
Don't async refresh package contents The performance benefit is minor and the loss of feedback is major in case of errors.
2018-06-20 12:45:03 +02:00
(package-refresh-contents)
Increase last-pkg-refresh ttl from 900 -> 1200s
2018-05-24 16:41:14 +02:00
(doom-cache-set 'last-pkg-refresh t 1200))
Minor error handler refactor in package management Allow debugger to produce better backtraces.
2018-06-20 02:23:55 +02:00
((debug error)
Allow use of package.el #444 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.
2018-03-14 18:25:22 -04:00
(doom--refresh-pkg-cache)
Minor error handler refactor in package management Allow debugger to produce better backtraces.
2018-06-20 02:23:55 +02:00
(signal 'doom-error e)))))
Improve error handling for package management
2017-05-19 22:29:47 +02:00
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
;;
;;; Package metadata
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(defun doom-package-plist (package)
"Returns PACKAGE's `package!' recipe from `doom-packages'."
(cdr (assq package doom-packages)))
;;;###autoload
(defun doom-package-desc (package)
"Returns PACKAGE's desc struct from `package-alist'."
(cadr (assq (or (car (doom-package-prop package :recipe))
package)
package-alist)))
;;;###autoload
(defun doom-package-true-name (package)
"Return PACKAGE's true name.
It is possible for quelpa packages to be given a psuedonym (the first argument
of `package!'). Its real name is the car of package's :recipe. e.g.
(package! X :recipe (Y :fetcher github :repo \"abc/def\"))
X's real name is Y."
(let ((sym (car (doom-package-prop package :recipe))))
(or (and (symbolp sym)
(not (keywordp sym))
sym)
package)))
;;;###autoload
(defun doom-package-psuedo-name (package)
"TODO"
(or (cl-loop for (package . plist) in doom-packages
for recipe-name = (car (plist-get plist :recipe))
if (eq recipe-name package)
return recipe-name)
package))
;;;###autoload
(defun doom-package-backend (package &optional noerror)
"Return backend that PACKAGE was installed with.
Can either be elpa, quelpa or emacs (built-in). Throws an error if NOERROR is
nil and the package isn't installed.
See `doom-package-recipe-backend' to get the backend PACKAGE is registered with
\(as opposed to what it is was installed with)."
(cl-check-type package symbol)
(let ((package-truename (doom-package-true-name package)))
(cond ((assq package-truename quelpa-cache) 'quelpa)
((assq package-truename package-alist) 'elpa)
((doom-package-built-in-p package) 'emacs)
((not noerror) (error "%s package is not installed" package)))))
;;;###autoload
(defun doom-package-recipe-backend (package &optional noerror)
"Return backend that PACKAGE is registered with.
See `doom-package-backend' to get backend for currently installed package."
(cl-check-type package symbol)
(cond ((not (doom-package-registered-p package))
(unless noerror
(error "%s package is not registered" package)))
((eval (doom-package-prop package :built-in))
'emacs)
((doom-package-prop package :recipe)
'quelpa)
('elpa)))
;;;###autoload
(defun doom-package-prop (package prop &optional nil-value)
"Return PROPerty in PACKAGE's plist.
Otherwise returns NIL-VALUE if package isn't registered or PROP doesn't
exist/isn't specified."
(cl-check-type package symbol)
(cl-check-type prop keyword)
(if-let (plist (doom-package-plist package))
(if (plist-member plist prop)
(plist-get plist prop)
nil-value)
nil-value))
;;
;;; Predicate functions
;;;###autoload
(defun doom-package-built-in-p (package)
"Return non-nil if PACKAGE (a symbol) is built-in."
(unless (doom-package-installed-p package)
(or (package-built-in-p (doom-package-true-name package))
(locate-library (symbol-name package) nil doom-site-load-path))))
;;;###autoload
(defun doom-package-installed-p (package)
"Return non-nil if PACKAGE (a symbol) is installed."
(when-let (desc (doom-package-desc package))
(and (package-installed-p desc)
(file-directory-p (package-desc-dir desc)))))
;;;###autoload
(defun doom-package-registered-p (package)
"Return non-nil if PACKAGE (a symbol) has been registered with `package!'.
Excludes packages that have a non-nil :built-in property."
(let ((package (or (cl-loop for (pkg . plist) in doom-packages
for newname = (car (plist-get plist :recipe))
if (and (symbolp newname)
(eq newname package))
return pkg)
package)))
(when-let (plist (doom-package-plist package))
(not (eval (plist-get plist :ignore))))))
;;;###autoload
(defun doom-package-private-p (package)
"Return non-nil if PACKAGE was installed by the user's private config."
(doom-package-prop package :private))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
;;;###autoload
(defun doom-package-protected-p (package)
"Return non-nil if PACKAGE is protected.
A protected package cannot be deleted and will be auto-installed if missing."
(memq (doom-package-true-name package) doom-core-packages))
;;;###autoload
(defun doom-package-core-p (package)
"Return non-nil if PACKAGE is a core Doom package."
(or (doom-package-protected-p package)
(assq :core (doom-package-prop package :modules))))
;;;###autoload
(defun doom-package-different-backend-p (package)
"Return t if a PACKAGE (a symbol) has a new backend than what it was installed
with. Returns nil otherwise, or if package isn't installed."
(cl-check-type package symbol)
(and (doom-package-installed-p package)
(not (doom-get-depending-on package)) ; not a dependency
(not (eq (doom-package-backend package 'noerror)
(doom-package-recipe-backend package 'noerror)))))
;;;###autoload
(defun doom-package-different-recipe-p (name)
"Return t if a package named NAME (a symbol) has a different recipe than it
was installed with."
(cl-check-type name symbol)
(when (doom-package-installed-p name)
(let ((package-truename (doom-package-true-name name)))
(when-let* ((quelpa-recipe (assq package-truename quelpa-cache))
(doom-recipe (assq package-truename doom-packages)))
(not (equal (cdr quelpa-recipe)
(cdr (plist-get (cdr doom-recipe) :recipe))))))))
(defvar quelpa-upgrade-p)
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
(defun doom-package-outdated-p (name)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
"Determine whether NAME (a symbol) is outdated or not.
If outdated, returns a list, whose car is NAME, and cdr the current version list
and latest version list of the package."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(when-let (desc (doom-package-desc name))
General cleanup & refactor
2017-08-06 16:30:53 +02:00
(let* ((old-version (package-desc-version desc))
Refactor package management system
2017-02-11 00:46:42 -05:00
(new-version
(pcase (doom-package-backend name)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(`quelpa
(let ((recipe (doom-package-prop name :recipe))
Polish package management system
2017-02-19 06:59:55 -05:00
(dir (expand-file-name (symbol-name name) quelpa-build-dir))
Fix outdated quelpa package detection
2017-06-03 21:29:33 +02:00
(inhibit-message (not doom-debug-mode))
(quelpa-upgrade-p t))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(if-let (ver (quelpa-checkout recipe dir))
Refactor package management system
2017-02-11 00:46:42 -05:00
(version-to-list ver)
old-version)))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(`elpa
Refactor package management system
2017-02-11 00:46:42 -05:00
(let ((desc (cadr (assq name package-archive-contents))))
(when (package-desc-p desc)
(package-desc-version desc)))))))
Error if doom-package-outdated-p cannot discern package's version
2018-04-05 02:28:42 -04:00
(unless (and (listp old-version) (listp new-version))
(error "Couldn't get version for %s" name))
(when (version-list-< old-version new-version)
Refactor package management system
2017-02-11 00:46:42 -05:00
(list name old-version new-version)))))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
;;
;;; Package list getters
And changed-quelpa-recipe detection These packages are now reinstalled on make install.
2018-02-20 17:55:53 -05:00
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
(cl-defun doom-find-packages (&key (installed 'any)
(private 'any)
(disabled 'any)
(pinned 'any)
(ignored 'any)
(core 'any)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
_changed
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
backend
deps)
Redesign doom-get-package Now more useful for filtering packages by certain properties.
2018-06-10 17:07:23 +02:00
"Retrieves a list of primary packages (i.e. non-dependencies). Each element is
a cons cell, whose car is the package symbol and whose cdr is the quelpa recipe
(if any).
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Major refactor of package management API Fixes issues where: + package!'s :disable property was ignored and def-package! wouldn't ignore disabled packages. + Certain quelpa packages were being removed/reinstalled infinitely + Improved flexibility of doom-get-packages (its docstring needs to be updated!)
2018-06-11 23:21:56 +02:00
You can build a filtering criteria using one or more of the following
properties:
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
:backend 'quelpa|'elpa|'emacs|'any
Include packages installed through 'quelpa, 'elpa or 'emacs. 'any is the
wildcard.
:installed BOOL|'any
t = only include installed packages
nil = exclude installed packages
:private BOOL|'any
t = only include user-installed packages
nil = exclude user-installed packages
:core BOOL|'any
t = only include Doom core packages
nil = exclude Doom core packages
:disabled BOOL|'any
t = only include disabled packages
nil = exclude disabled packages
:ignored BOOL|'any
t = only include ignored packages
nil = exclude ignored packages
Major refactor of package management API Fixes issues where: + package!'s :disable property was ignored and def-package! wouldn't ignore disabled packages. + Certain quelpa packages were being removed/reinstalled infinitely + Improved flexibility of doom-get-packages (its docstring needs to be updated!)
2018-06-11 23:21:56 +02:00
:pinned BOOL|ARCHIVE
Only return packages that are pinned (t), not pinned (nil) or pinned to a
specific archive (stringp)
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
:deps BOOL
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
Includes the package's dependencies (t) or not (nil).
Major refactor of package management API Fixes issues where: + package!'s :disable property was ignored and def-package! wouldn't ignore disabled packages. + Certain quelpa packages were being removed/reinstalled infinitely + Improved flexibility of doom-get-packages (its docstring needs to be updated!)
2018-06-11 23:21:56 +02:00
Redesign doom-get-package Now more useful for filtering packages by certain properties.
2018-06-10 17:07:23 +02:00
Warning: this function is expensive, as it re-evaluates your all packages.el
files."
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(delete-dups
(cl-loop for (sym . plist) in doom-packages
if (and (or (not backend)
(eq (doom-package-backend sym 'noerror) backend))
(or (eq ignored 'any)
(let* ((form (plist-get plist :ignore))
(value (eval form)))
(if ignored value (not value))))
(or (eq disabled 'any)
(if disabled
(plist-get plist :disable)
(not (plist-get plist :disable))))
(or (eq installed 'any)
(if installed
(doom-package-installed-p sym)
(not (doom-package-installed-p sym))))
(or (eq private 'any)
(let ((modules (plist-get plist :modules)))
(if private
(assq :private modules)
(not (assq :private modules)))))
(or (eq core 'any)
(let ((modules (plist-get plist :modules)))
(if core
(assq :core modules)
(not (assq :core modules)))))
(or (eq pinned 'any)
(cond ((eq pinned 't)
(plist-get plist :pin))
((null pinned)
(not (plist-get plist :pin)))
((equal (plist-get plist :pin) pinned)))))
collect (cons sym plist)
and if (and deps (not (doom-package-built-in-p sym)))
nconc
(cl-loop for pkg in (doom-get-dependencies-for sym 'recursive 'noerror)
if (or (eq installed 'any)
(if installed
(doom-package-installed-p pkg)
(not (doom-package-installed-p pkg))))
collect (cons pkg (cdr (assq pkg doom-packages)))))))
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
Allow doom-package-list to scrape *all* packages Even ones that are conditional. This does mean its plist is unevaluated, however.
2019-03-10 08:10:59 -04:00
(defun doom--read-module-packages-file (file &optional raw noerror)
(with-temp-buffer ; prevent buffer-local settings from propagating
(condition-case e
(if (not raw)
(load file noerror t t)
(when (file-readable-p file)
(insert-file-contents file)
(while (re-search-forward "(package! " nil t)
(save-excursion
(goto-char (match-beginning 0))
(cl-destructuring-bind (name . plist) (cdr (sexp-at-point))
(push (cons name
(plist-put plist :modules
(cond ((file-in-directory-p file doom-private-dir)
Add and expand doom/help* commands Adds the following commands: - doom/help (opens the Doom manual) - doom/help-search (for searching through org headlines in Doom's documentation) - doom/help-faq (for searching the FAQ) - doom/help-news (for browsing the Doom newsletters) - doom/help-autodefs (renamed from doom/describe-autodef -- for looking up documentation on autodef function/macros, like `set-lookup-handler!`) - doom/help-modules (renamed from doom/describe-module, for jumping to a Doom module's documentation) - doom/help-packages (renamed from doom/describe-package and recently fixed -- looks up information about installed packages, including what Doom module(s) install it and where it is configured) - doom/help-package-config (for searching and jumping to any block where a package is configured in Doom Emacs) Also adds the SPC h d (or C-h d) prefix for Doom-specific help commands. SPC h D will invoke doom/help. However, the documentation itself hasn't been committed yet, so some of these commands may be useless atm. Sorry!
2019-04-23 20:46:58 -04:00
'((:private)))
Allow doom-package-list to scrape *all* packages Even ones that are conditional. This does mean its plist is unevaluated, however.
2019-03-10 08:10:59 -04:00
((file-in-directory-p file doom-core-dir)
Add and expand doom/help* commands Adds the following commands: - doom/help (opens the Doom manual) - doom/help-search (for searching through org headlines in Doom's documentation) - doom/help-faq (for searching the FAQ) - doom/help-news (for browsing the Doom newsletters) - doom/help-autodefs (renamed from doom/describe-autodef -- for looking up documentation on autodef function/macros, like `set-lookup-handler!`) - doom/help-modules (renamed from doom/describe-module, for jumping to a Doom module's documentation) - doom/help-packages (renamed from doom/describe-package and recently fixed -- looks up information about installed packages, including what Doom module(s) install it and where it is configured) - doom/help-package-config (for searching and jumping to any block where a package is configured in Doom Emacs) Also adds the SPC h d (or C-h d) prefix for Doom-specific help commands. SPC h D will invoke doom/help. However, the documentation itself hasn't been committed yet, so some of these commands may be useless atm. Sorry!
2019-04-23 20:46:58 -04:00
'((:core)))
Allow doom-package-list to scrape *all* packages Even ones that are conditional. This does mean its plist is unevaluated, however.
2019-03-10 08:10:59 -04:00
((doom-module-from-path file)))))
doom-packages))))))
((debug error)
(signal 'doom-package-error
(list (or (doom-module-from-path file)
'(:private . packages))
e))))))
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
;;;###autoload
(defun doom-package-list (&optional all-p)
"Retrieve a list of explicitly declared packages from enabled modules.
This excludes core packages listed in `doom-core-packages'.
Allow doom-package-list to scrape *all* packages Even ones that are conditional. This does mean its plist is unevaluated, however.
2019-03-10 08:10:59 -04:00
If ALL-P, gather packages unconditionally across all modules, including disabled
ones."
(let ((noninteractive t)
(doom--stage 'packages)
(doom-modules (doom-modules))
doom-packages
doom-disabled-packages
package-pinned-packages)
(doom--read-module-packages-file (expand-file-name "packages.el" doom-core-dir) all-p)
(let ((private-packages (expand-file-name "packages.el" doom-private-dir)))
(unless all-p
;; We load the private packages file twice to ensure disabled packages
;; are seen ASAP, and a second time to ensure privately overridden
;; packages are properly overwritten.
(doom--read-module-packages-file private-packages nil t))
(if all-p
(mapc #'doom--read-module-packages-file
(doom-files-in doom-modules-dir
:depth 2
:full t
doom-files-in: replace NOSORT w/ SORT; change default MATCH - SORT defaults to t - MATCH's new default regexp excludes files that start with underscore.
2019-06-16 15:27:49 +02:00
:match "/packages\\.el$"
:sort nil))
Allow doom-package-list to scrape *all* packages Even ones that are conditional. This does mean its plist is unevaluated, however.
2019-03-10 08:10:59 -04:00
(cl-loop for key being the hash-keys of doom-modules
for path = (doom-module-path (car key) (cdr key) "packages.el")
for doom--current-module = key
do (doom--read-module-packages-file path nil t)))
(doom--read-module-packages-file private-packages all-p t))
(append (cl-loop for package in doom-core-packages
collect (list package :modules '((:core internal))))
(nreverse doom-packages))))
Polish package management system
2017-02-19 06:59:55 -05:00
Add doom-get-package-alist New function returns a list of (NAME . DESC) cons cells in the order they were declared (in module packages.el files). Fixes a load-order issue where autoloads from one package would depend on the autoloads of another package, but was inserted into doom-package-autoload-file *before* the depended package, causing void-variable errors. Also allows for a big refactor of the :plugins byte-compile target.
2018-06-14 00:04:12 +02:00
;;;###autoload
(defun doom-get-package-alist ()
"Returns a list of all desired packages, their dependencies and their desc
objects, in the order of their `package! blocks.'"
(cl-remove-duplicates
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
(cl-loop for name in (mapcar #'car doom-packages)
Install/compile packages in order of declaration This should fix an issue where a package A, which uses macros from a package B, is installed before package B, causing void-function errors. The currently known and affected packages are neotree, parinfer, and evil-collection.
2018-09-25 10:31:52 -04:00
if (assq name package-alist)
nconc (cl-loop for dep in (package--get-deps name)
if (assq dep package-alist)
collect (cons dep (cadr it)))
and collect (cons name (cadr it)))
Add doom-get-package-alist New function returns a list of (NAME . DESC) cons cells in the order they were declared (in module packages.el files). Fixes a load-order issue where autoloads from one package would depend on the autoloads of another package, but was inserted into doom-package-autoload-file *before* the depended package, causing void-variable errors. Also allows for a big refactor of the :plugins byte-compile target.
2018-06-14 00:04:12 +02:00
:key #'car
:from-end t))
Polish package management system
2017-02-19 06:59:55 -05:00
;;;###autoload
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(defun doom-get-depending-on (name &optional noerror)
Polish package management system
2017-02-19 06:59:55 -05:00
"Return a list of packages that depend on the package named NAME."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(setq name (or (car (doom-package-prop name :recipe)) name))
(unless (doom-package-built-in-p name)
(if-let (desc (cadr (assq name package-alist)))
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(mapcar #'package-desc-name (package--used-elsewhere-p desc nil t))
(unless noerror
(error "Couldn't find %s, is it installed?" name)))))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
packages: rewrote doom-get-dependencies-for, add doom-get-depending-on
2017-04-04 22:17:33 -04:00
;;;###autoload
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(defun doom-get-dependencies-for (name &optional recursive noerror)
packages: rewrote doom-get-dependencies-for, add doom-get-depending-on
2017-04-04 22:17:33 -04:00
"Return a list of dependencies for a package."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
;; can't get dependencies for built-in packages
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(unless (doom-package-built-in-p name)
(if-let (desc (doom-package-desc name))
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(let* ((deps (mapcar #'car (package-desc-reqs desc)))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(deps (cl-remove-if #'doom-package-built-in-p deps)))
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(if recursive
(nconc deps (mapcan (lambda (dep) (doom-get-dependencies-for dep t t))
deps))
deps))
(unless noerror
(error "Couldn't find %s, is it installed?" name)))))
packages: rewrote doom-get-dependencies-for, add doom-get-depending-on
2017-04-04 22:17:33 -04:00
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
Add :ignore & :freeze support to package!
2017-06-05 14:21:07 +02:00
(defun doom-get-outdated-packages (&optional include-frozen-p)
Refactor package management system
2017-02-11 00:46:42 -05:00
"Return a list of packages that are out of date. Each element is a list,
containing (PACKAGE-SYMBOL OLD-VERSION-LIST NEW-VERSION-LIST).
Update/improve documentation for core defuns
2017-02-09 04:25:32 -05:00
Add :ignore & :freeze support to package!
2017-06-05 14:21:07 +02:00
If INCLUDE-FROZEN-P is non-nil, check frozen packages as well.
Remove doom//x naming convention This naming convention was meant to be for batch commands, but it grew to include "commands that were helpful with managing Doom", but many of these commands shouldn't be interactive in the first place!
2018-06-17 21:35:58 +02:00
Used by `doom-packages-update'."
Adjust package state initialization strategies
2018-05-25 02:53:48 +02:00
(doom-refresh-packages-maybe doom-debug-mode)
Make doom-get-outdated-packages synchronous Concurrency doesn't speed this up enough to justify its problems. It swallows errors emitted from the child processes and a child process can block indefinitely.
2019-04-24 18:00:05 -04:00
(cl-loop for package in (mapcar #'car package-alist)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
when (and (or (not (eval (doom-package-prop package :freeze)))
Make doom-get-outdated-packages synchronous Concurrency doesn't speed this up enough to justify its problems. It swallows errors emitted from the child processes and a child process can block indefinitely.
2019-04-24 18:00:05 -04:00
include-frozen-p)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(not (eval (doom-package-prop package :ignore)))
Make doom-get-outdated-packages synchronous Concurrency doesn't speed this up enough to justify its problems. It swallows errors emitted from the child processes and a child process can block indefinitely.
2019-04-24 18:00:05 -04:00
(not (doom-package-different-backend-p package))
(doom-package-outdated-p package))
collect it))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Move package commands to core/autoload/packages.el
2017-02-02 19:15:58 -05:00
;;;###autoload
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
(defun doom-get-orphaned-packages ()
Update/improve documentation for core defuns
2017-02-09 04:25:32 -05:00
"Return a list of symbols representing packages that are no longer needed or
depended on.
Remove doom//x naming convention This naming convention was meant to be for batch commands, but it grew to include "commands that were helpful with managing Doom", but many of these commands shouldn't be interactive in the first place!
2018-06-17 21:35:58 +02:00
Used by `doom-packages-autoremove'."
Polish package management system
2017-02-19 06:59:55 -05:00
(let ((package-selected-packages
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
(mapcar #'car (doom-find-packages :ignored nil :disabled nil))))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(append (cl-remove-if #'doom-package-registered-p (package--removable-packages))
Fix packages with changed backend #222 Doom can't tell what backend a package was installed with, only whether it is installed or not. This means if a package was installed with, say, ELPA, then was changed to QUELPA, Doom wouldn't know. Package management would fail. ELPA/QUELPA can't manage a package that it didn't install. This fix gives Doom that capability.
2017-11-05 16:04:31 +01:00
(cl-loop for pkg in package-selected-packages
Fix 'not installed' errors for built-in packages #288 Caused by doom-package-backend not taking into account that a package could be built-in. Derp!
2017-12-22 04:02:47 -05:00
if (and (doom-package-different-backend-p pkg)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(not (doom-package-built-in-p pkg)))
Fix packages with changed backend #222 Doom can't tell what backend a package was installed with, only whether it is installed or not. This means if a package was installed with, say, ELPA, then was changed to QUELPA, Doom wouldn't know. Package management would fail. ELPA/QUELPA can't manage a package that it didn't install. This fix gives Doom that capability.
2017-11-05 16:04:31 +01:00
collect pkg))))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;;###autoload
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
(defun doom-get-missing-packages ()
doom-get-missing-packages: update comment string
2017-04-04 22:17:42 -04:00
"Return a list of requested packages that aren't installed or built-in, but
are enabled (with a `package!' directive). Each element is a list whose CAR is
the package symbol, and whose CDR is a plist taken from that package's
`package!' declaration.
Update/improve documentation for core defuns
2017-02-09 04:25:32 -05:00
Remove doom//x naming convention This naming convention was meant to be for batch commands, but it grew to include "commands that were helpful with managing Doom", but many of these commands shouldn't be interactive in the first place!
2018-06-17 21:35:58 +02:00
Used by `doom-packages-install'."
Major refactor of package management API Fixes issues where: + package!'s :disable property was ignored and def-package! wouldn't ignore disabled packages. + Certain quelpa packages were being removed/reinstalled infinitely + Improved flexibility of doom-get-packages (its docstring needs to be updated!)
2018-06-11 23:21:56 +02:00
(cl-loop for (name . plist)
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
in (doom-find-packages :ignored nil
:disabled nil
:deps t)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
if (and (equal (plist-get plist :pin)
(ignore-errors
(package-desc-archive
(cadr (assq name package-alist)))))
Add :deps property to doom-get-packages Also fixes an issue where doom install wouldn't catch missing dependnecies of desired packages. If :dep is non-nil, doom-get-packages will include package dependencies in the resulting package list.
2018-09-07 21:52:11 -04:00
(or (not (doom-package-installed-p name))
And changed-quelpa-recipe detection These packages are now reinstalled on make install.
2018-02-20 17:55:53 -05:00
(doom-package-different-backend-p name)
(doom-package-different-recipe-p name)))
Major refactor of package management API Fixes issues where: + package!'s :disable property was ignored and def-package! wouldn't ignore disabled packages. + Certain quelpa packages were being removed/reinstalled infinitely + Improved flexibility of doom-get-packages (its docstring needs to be updated!)
2018-06-11 23:21:56 +02:00
collect (cons name plist)))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;
;; Main functions
Improve error-handling for quelpa packages
2018-06-08 01:42:08 +02:00
(defun doom--delete-package-files (name-or-desc)
(let ((pkg-build-dir
(if (package-desc-p name-or-desc)
(package-desc-dir name-or-desc)
(expand-file-name (symbol-name name-or-desc) quelpa-build-dir))))
(when (file-directory-p pkg-build-dir)
(delete-directory pkg-build-dir t))))
Autoload doom-*-package functions
2018-05-20 12:05:17 +02:00
;;;###autoload
Heavy refactor of package management; new parsing doom-read-packages
2017-02-04 21:07:54 -05:00
(defun doom-install-package (name &optional plist)
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
"Installs package NAME with optional quelpa RECIPE (see `quelpa-recipe' for an
example; the package name can be omitted)."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(when (and (doom-package-installed-p name)
(not (doom-package-built-in-p name)))
And changed-quelpa-recipe detection These packages are now reinstalled on make install.
2018-02-20 17:55:53 -05:00
(if (or (doom-package-different-backend-p name)
(doom-package-different-recipe-p name))
doom-install-package: don't try to uninstall built-in packages
2018-01-04 16:09:40 -05:00
(doom-delete-package name t)
(user-error "%s is already installed" name)))
doom-install-package: let -> let*
2017-11-13 18:00:46 +01:00
(let* ((inhibit-message (not doom-debug-mode))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(plist (or plist (doom-package-plist name))))
(if-let (recipe (plist-get plist :recipe))
Improve error-handling for quelpa packages
2018-06-08 01:42:08 +02:00
(condition-case e
(let (quelpa-upgrade-p)
(quelpa recipe))
Minor error handler refactor in package management Allow debugger to produce better backtraces.
2018-06-20 02:23:55 +02:00
((debug error)
(doom--delete-package-files name)
(signal (car e) (cdr e))))
doom-install-package: let -> let*
2017-11-13 18:00:46 +01:00
(package-install name))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(if (not (doom-package-installed-p name))
Improve error-handling for quelpa packages
2018-06-08 01:42:08 +02:00
(doom--delete-package-files name)
Ensure explicitly installed pkgs are user-selected
2019-03-04 04:51:49 -05:00
(add-to-list 'package-selected-packages name nil 'eq)
Fix void-variable error when installing packages Caused by a haphazardly refactor in f6dc6ac7.
2018-06-23 20:11:43 +02:00
(setf (alist-get name doom-packages) plist)
Minor refactor of package management api
2018-05-18 01:11:20 +02:00
name)))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Autoload doom-*-package functions
2018-05-20 12:05:17 +02:00
;;;###autoload
Major optimization refactor, across the board + 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.
2017-06-08 11:47:56 +02:00
(defun doom-update-package (name &optional force-p)
Rewrite docstrings for package functions/macros
2017-07-02 16:47:02 +02:00
"Updates package NAME (a symbol) if it is out of date, using quelpa or
package.el as appropriate."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(unless (doom-package-installed-p name)
General reformatting & minor refactors
2019-02-19 15:03:14 -05:00
(error "%s isn't installed" name))
doom-update-package: error if package's backend has changed
2017-11-13 18:01:38 +01:00
(when (doom-package-different-backend-p name)
(user-error "%s's backend has changed and must be uninstalled first" name))
Major optimization refactor, across the board + 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.
2017-06-08 11:47:56 +02:00
(when (or force-p (doom-package-outdated-p name))
Fix wrong-type-argument on quelpa package update
2017-06-03 21:30:41 +02:00
(let ((inhibit-message (not doom-debug-mode))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(desc (doom-package-desc name)))
Heavy refactor of package management; new parsing doom-read-packages
2017-02-04 21:07:54 -05:00
(pcase (doom-package-backend name)
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(`quelpa
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(let ((name (doom-package-true-name name)))
(condition-case e
(let ((quelpa-upgrade-p t))
(quelpa (assq name quelpa-cache)))
((debug error)
(doom--delete-package-files name)
(signal (car e) (cdr e))))))
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(`elpa
Fix wrong-type-argument on quelpa package update
2017-06-03 21:30:41 +02:00
(let* ((archive (cadr (assq name package-archive-contents)))
Rewrite how doom-update-package updates from ELPA This is an attempt to make package updating atomic. Previously, if a package failed to update, it would've been deleted.
2017-06-03 21:01:32 +02:00
(packages
(if (package-desc-p archive)
(package-compute-transaction (list archive) (package-desc-reqs archive))
(package-compute-transaction () (list (list archive))))))
Fix package update not deleting old folder
2017-06-05 03:15:52 +02:00
(package-download-transaction packages))))
Major optimization refactor, across the board + 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.
2017-06-08 11:47:56 +02:00
(unless (doom-package-outdated-p name)
Improve error-handling for quelpa packages
2018-06-08 01:42:08 +02:00
(doom--delete-package-files desc)
Major optimization refactor, across the board + 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.
2017-06-08 11:47:56 +02:00
t))))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
Autoload doom-*-package functions
2018-05-20 12:05:17 +02:00
;;;###autoload
Turn off nosave-p flag on package-delete Prevents false positives when updating packages
2017-05-15 22:35:57 +02:00
(defun doom-delete-package (name &optional force-p)
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
"Uninstalls package NAME if it exists, and clears it from `quelpa-cache'."
Refactor error handling in package management API I am hoping this will improve the ambiguous errors that originate from package.el or quelpa.el.
2018-06-07 17:59:23 +02:00
(cl-check-type name symbol)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(unless (doom-package-installed-p name)
autoload/packages: refactor + improve output consistency
2017-04-18 05:45:24 -04:00
(user-error "%s isn't installed" name))
Clean up quelpa build repos on package deletion
2017-06-10 23:32:59 +02:00
(let ((inhibit-message (not doom-debug-mode))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(name (doom-package-true-name name)))
(when-let (spec (assq name quelpa-cache))
(delq! spec quelpa-cache)
(quelpa-save-cache))
(package-delete (doom-package-desc name) force-p)
Improve error-handling for quelpa packages
2018-06-08 01:42:08 +02:00
(doom--delete-package-files name)
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(not (doom-package-installed-p name))))
Rewrite package management to be less hackish (untested)
2017-02-03 07:58:16 -05:00
;;
Fix package autoremove/install/update batch commands
2018-05-24 19:10:29 +02:00
;; Interactive commands
Move package commands to core/autoload/packages.el
2017-02-02 19:15:58 -05:00
Refactor doom-initialize-packages & package API - Packages are initialized once, when package.el is first loaded, and must be updated manually via doom/reload-packages. - Package->module association is now stored in the package's PLIST under :modules. This is an internal property and cannot be explicitly set through `package!' - Add doom-package-list function - Rename doom-get-packages to doom-find-packages - Updated doom-find-packages' docstring - Added the :core filter to doom-find-packages - Simplified doom-initialize-packages - doom/reload calls doom/reload-packages if necessary. - Fix redundant properties in doom-packages - Remove tracking of after!, def-package! and def-package-hook! blocks. Replaced with doom-package-list being able to see all packages, even in disabled modules. - Add :built-in property to package! for dummy packages. This is important so that doom/describe-package can see built-in packages.
2019-03-06 00:26:33 -05:00
;;;###autoload
(defun doom/reload-packages ()
"Reload `doom-packages', `package' and `quelpa'."
(interactive)
(message "Reloading packages")
(doom-initialize-packages t)
(message "Reloading packages...DONE"))
Move package commands to core/autoload/packages.el
2017-02-02 19:15:58 -05:00
;;;###autoload
Fix package autoremove/install/update batch commands
2018-05-24 19:10:29 +02:00
(defun doom/update-package (pkg)
"Prompts the user with a list of outdated packages and updates the selected
package. Use this interactively. Use `doom-update-package' for direct
calls."
(declare (interactive-only t))
(interactive
(let* ((packages (doom-get-outdated-packages))
Improve error-handling in doom/update-package
2019-01-21 03:48:10 -05:00
(selection (if packages
(completing-read "Update package: "
(mapcar #'car packages)
nil t)
(user-error "All packages are up to date")))
Fix doom/update-package
2019-01-24 02:13:16 -05:00
(name (car (assoc (intern selection) package-alist))))
Improve error-handling in doom/update-package
2019-01-21 03:48:10 -05:00
(unless name
(user-error "'%s' is already up-to-date" selection))
Fix doom/update-package
2019-01-24 02:13:16 -05:00
(list (assq name packages))))
Fix package autoremove/install/update batch commands
2018-05-24 19:10:29 +02:00
(cl-destructuring-bind (package old-version new-version) pkg
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(if-let (desc (doom-package-outdated-p package))
Fix package autoremove/install/update batch commands
2018-05-24 19:10:29 +02:00
(let ((old-v-str (package-version-join old-version))
(new-v-str (package-version-join new-version)))
(if (y-or-n-p (format "%s will be updated from %s to %s. Update?"
package old-v-str new-v-str))
(message "%s %s (%s => %s)"
(if (doom-update-package package t) "Updated" "Failed to update")
package old-v-str new-v-str)
(message "Aborted")))
(message "%s is up-to-date" package))))
;;
;; Advice
;;;###autoload
(defun doom*package-delete (desc &rest _)
"Update `quelpa-cache' upon a successful `package-delete'."
(let ((name (package-desc-name desc)))
Refactor package management API Sets out to solve a number of issues with the package management process. Namely: - To-be-removed packages that are simply being removed are no longer incorrectly labeled "quelpa->elpa", but "removed" instead. - A backend (elpa vs quelpa) column was added to the package listing confirmation when running `doom update`. - Doom now correctly recognizes that packages installed with a psuedonym are installed, and will not endlessly attempt to uninstall and reinstall them on every `doom refresh`. - Packages declared with :built-in will no longer lose their built-in marking if said package is not actually present in Emacs' site load paths. i.e. if you say it's built in, Doom won't question it. - package!'s :ignore property is now treated as a form whose evaluated result will be used as its value.
2019-06-11 08:01:42 +02:00
(unless (doom-package-installed-p name)
(when-let (spec (assq name quelpa-cache))
Refactor out map.el usage After some profiling, it turns out map-put and map-delete are 5-7x slower (more on Emacs 25) than delq, setf/alist-get and add-to-list for small lists (under 250 items), which is exactly how I've been using them. The only caveat is alist-get's signature is different on Emacs 25, thus a polyfill is necessary in core-lib.
2018-06-23 16:48:58 +02:00
(setq quelpa-cache (delq spec quelpa-cache))
(quelpa-save-cache)
(doom--delete-package-files name)))))
Fix package autoremove/install/update batch commands
2018-05-24 19:10:29 +02:00
Split core-packages into two (packages & modules) + Move doom-initialize et co into core.el + Lazy load core-packages + load! has been moved into core-lib + Added FILE! and DIR! macros + Fix package! not returning correct value when package is disabled + Remove :disabled support for def-package-hook! officially
2018-06-11 23:18:15 +02:00
;;
;; Make package.el cooperate with Doom
;; Updates QUELPA after deleting a package
;;;###autoload
(advice-add #'package-delete :after #'doom*package-delete)
;; Replace with Doom variants
;;;###autoload
Fix package.el command substitutions doom//autoremove and doom//install are more appropriate replacements for package-autoremove and package-install-selected-packages, respectively.
2019-03-14 14:27:33 -04:00
(advice-add #'package-autoremove :override #'doom//autoremove)
Remove doom//x naming convention This naming convention was meant to be for batch commands, but it grew to include "commands that were helpful with managing Doom", but many of these commands shouldn't be interactive in the first place!
2018-06-17 21:35:58 +02:00
Split core-packages into two (packages & modules) + Move doom-initialize et co into core.el + Lazy load core-packages + load! has been moved into core-lib + Added FILE! and DIR! macros + Fix package! not returning correct value when package is disabled + Remove :disabled support for def-package-hook! officially
2018-06-11 23:18:15 +02:00
;;;###autoload
Fix package.el command substitutions doom//autoremove and doom//install are more appropriate replacements for package-autoremove and package-install-selected-packages, respectively.
2019-03-14 14:27:33 -04:00
(advice-add #'package-install-selected-packages :override #'doom//install)
Reference in a new issue Copy permalink