masscollaborationlabs/emacs
2
0
Fork 0
mirror of https://github.com/masscollaborationlabs/emacs.git synced 2025-07-06 20:29:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Allow :bind ("C-c C-c" . (lambda () (ding))) and #'(lambda ...)

Browse source 
Fixes https://github.com/jwiegley/use-package/issues/333
Fixes https://github.com/jwiegley/use-package/issues/461
This commit is contained in:
John Wiegley 2017-11-29 14:41:12 -08:00
parent f256943f9b
commit bff472ea80
3 changed files with 193 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

8
lisp/use-package/bind-key.el
View file

@ -267,10 +267,10 @@ function symbol (unquoted)."
(cl-mapcan (cl-mapcan
(lambda (form) (lambda (form)
(if prefix-map (if prefix-map
`((bind-key ,(car form) ',(cdr form) ,prefix-map ,filter)) `((bind-key ,(car form) #',(cdr form) ,prefix-map ,filter))
(if (and map (not (eq map 'global-map))) (if (and map (not (eq map 'global-map)))
`((bind-key ,(car form) ',(cdr form) ,map ,filter)) `((bind-key ,(car form) #',(cdr form) ,map ,filter))
`((bind-key ,(car form) ',(cdr form) nil ,filter))))) `((bind-key ,(car form) #',(cdr form) nil ,filter)))))
first)) first))
(when next (when next
(bind-keys-form (bind-keys-form
@ -305,7 +305,7 @@ function symbol (unquoted)."
(cond (cond
((listp elem) ((listp elem)
(cond (cond
((eq 'lambda (car elem)) ((memq (car elem) '(lambda function))
(if (and bind-key-describe-special-forms (if (and bind-key-describe-special-forms
(stringp (nth 2 elem))) (stringp (nth 2 elem)))
(nth 2 elem) (nth 2 elem)

298
lisp/use-package/use-package.el
View file

@ -472,6 +472,9 @@ This is in contrast to merely setting it to 0."
"Delete all empty lists from ELEMS (nil or (list nil)), and append them." "Delete all empty lists from ELEMS (nil or (list nil)), and append them."
(apply #'nconc (delete nil (delete (list nil) elems)))) (apply #'nconc (delete nil (delete (list nil) elems))))
(defsubst use-package--non-nil-symbolp (sym)
(and sym (symbolp sym)))
(defconst use-package-font-lock-keywords (defconst use-package-font-lock-keywords
'(("(\\(use-package\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?" '(("(\\(use-package\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
(1 font-lock-keyword-face) (1 font-lock-keyword-face)
@ -489,16 +492,11 @@ This is in contrast to merely setting it to 0."
;;; Normalization functions ;;; Normalization functions
;; ;;
(defun use-package-regex-p (re) (defsubst use-package-regex-p (re)
"Return t if RE is some regexp-like thing." "Return t if RE is some regexp-like thing."
(cond (or (and (listp re)
((and (listp re) (eq (car re) 'rx))
(eq (car re) 'rx)) (stringp re)))
t)
((stringp re)
t)
(t
nil)))
(defun use-package-normalize-regex (re) (defun use-package-normalize-regex (re)
"Given some regexp-like thing, resolve it down to a regular expression." "Given some regexp-like thing, resolve it down to a regular expression."
@ -590,7 +588,7 @@ next value for the STATE."
(lambda (label arg) (lambda (label arg)
(cond (cond
((stringp arg) arg) ((stringp arg) arg)
((symbolp arg) (symbol-name arg)) ((use-package--non-nil-symbolp arg) (symbol-name arg))
(t (t
(use-package-error (use-package-error
":pin wants an archive name (a string)")))))) ":pin wants an archive name (a string)"))))))
@ -724,7 +722,7 @@ If the package is installed, its entry is removed from
t t
(use-package-only-one (symbol-name keyword) args (use-package-only-one (symbol-name keyword) args
(lambda (label arg) (lambda (label arg)
(if (symbolp arg) (if (use-package--non-nil-symbolp arg)
arg arg
(use-package-error (use-package-error
(concat ":ensure wants an optional package name " (concat ":ensure wants an optional package name "
@ -798,7 +796,7 @@ If the package is installed, its entry is removed from
(defsubst use-package-normalize-value (label arg) (defsubst use-package-normalize-value (label arg)
"Normalize a value." "Normalize a value."
(cond ((null arg) nil) (cond ((null arg) nil)
((symbolp arg) ((use-package--non-nil-symbolp arg)
`(symbol-value ',arg)) `(symbol-value ',arg))
((functionp arg) ((functionp arg)
`(funcall #',arg)) `(funcall #',arg))
@ -831,8 +829,9 @@ If the package is installed, its entry is removed from
"Call F on the first element of ARGS if it has one element, or all of ARGS. "Call F on the first element of ARGS if it has one element, or all of ARGS.
If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list." If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list."
(declare (indent 1)) (declare (indent 1))
(if (or (and (not (null args)) (listp args) (listp (cdr args))) (if (if args
(and allow-empty (null args))) (listp args) (listp (cdr args))
allow-empty)
(if (= (length args) 1) (if (= (length args) 1)
(funcall f label (car args)) (funcall f label (car args))
(funcall f label args)) (funcall f label args))
@ -844,7 +843,7 @@ If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list."
(defun use-package-normalize-symbols (label arg &optional recursed) (defun use-package-normalize-symbols (label arg &optional recursed)
"Normalize a list of symbols." "Normalize a list of symbols."
(cond (cond
((symbolp arg) ((use-package--non-nil-symbolp arg)
(list arg)) (list arg))
((and (not recursed) (listp arg) (listp (cdr arg))) ((and (not recursed) (listp arg) (listp (cdr arg)))
(mapcar #'(lambda (x) (car (use-package-normalize-symbols label x t))) arg)) (mapcar #'(lambda (x) (car (use-package-normalize-symbols label x t))) arg))
@ -859,7 +858,7 @@ If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list."
(defun use-package-normalize-recursive-symbols (label arg) (defun use-package-normalize-recursive-symbols (label arg)
"Normalize a list of symbols." "Normalize a list of symbols."
(cond (cond
((symbolp arg) ((use-package--non-nil-symbolp arg)
arg) arg)
((and (listp arg) (listp (cdr arg))) ((and (listp arg) (listp (cdr arg)))
(mapcar #'(lambda (x) (use-package-normalize-recursive-symbols label x)) (mapcar #'(lambda (x) (use-package-normalize-recursive-symbols label x))
@ -891,7 +890,7 @@ If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list."
(defun use-package-normalize-paths (label arg &optional recursed) (defun use-package-normalize-paths (label arg &optional recursed)
"Normalize a list of filesystem paths." "Normalize a list of filesystem paths."
(cond (cond
((and arg (or (symbolp arg) (functionp arg))) ((and arg (or (use-package--non-nil-symbolp arg) (functionp arg)))
(let ((value (use-package-normalize-value label arg))) (let ((value (use-package-normalize-value label arg)))
(use-package-normalize-paths label (eval value)))) (use-package-normalize-paths label (eval value))))
((stringp arg) ((stringp arg)
@ -986,56 +985,105 @@ If RECURSED is non-nil, recurse into sublists."
((use-package-is-pair arg key-pred val-pred) ((use-package-is-pair arg key-pred val-pred)
(list arg)) (list arg))
((and (not recursed) (listp arg) (listp (cdr arg))) ((and (not recursed) (listp arg) (listp (cdr arg)))
(let ((last-item nil)) (let (last-item)
(mapcar #'(lambda (x) (mapcar
(prog1 #'(lambda (x)
(let ((ret (use-package-normalize-pairs (prog1
key-pred val-pred name label x t))) (let ((ret (use-package-normalize-pairs
;; Currently, the handling of keyword key-pred val-pred name label x t)))
;; arguments by `use-package' and `bind-key' ;; Currently, the handling of keyword arguments by
;; is non-uniform and undocumented. As a ;; `use-package' and `bind-key' is non-uniform and
;; result, `use-package-normalize-pairs' (as ;; undocumented. As a result, `use-package-normalize-pairs'
;; it is currently implemented) does not ;; (as it is currently implemented) does not correctly handle
;; correctly handle the keyword-argument ;; the keyword-argument syntax of `bind-keys'. A permanent
;; syntax of `bind-keys'. A permanent solution ;; solution to this problem will require a careful
;; to this problem will require a careful ;; consideration of the desired keyword-argument interface
;; consideration of the desired ;; for `use-package' and `bind-key'. However, in the
;; keyword-argument interface for ;; meantime, we have a quick patch to fix a serious bug in
;; `use-package' and `bind-key'. However, in ;; the handling of keyword arguments. Namely, the code below
;; the meantime, we have a quick patch to fix ;; would normally unwrap lists that were passed as keyword
;; a serious bug in the handling of keyword ;; arguments (for example, the `:filter' argument in `:bind')
;; arguments. Namely, the code below would ;; without the (not (keywordp last-item)) clause. See #447
;; normally unwrap lists that were passed as ;; for further discussion.
;; keyword arguments (for example, the (if (and (listp ret)
;; `:filter' argument in `:bind') without (not (keywordp last-item)))
;; the (not (keywordp last-item)) clause. See (car ret)
;; #447 for further discussion. ret))
(if (and (listp ret) (not (keywordp last-item))) (setq last-item x))) arg)))
(car ret)
ret))
(setq last-item x))) arg)))
(t arg))) (t arg)))
(defun use-package--recognize-function (v &optional additional-pred)
"A predicate that recognizes functional constructions:
sym
'sym
(quote sym)
#'sym
(function sym)
(lambda () ...)
'(lambda () ...)
(quote (lambda () ...))
#'(lambda () ...)
(function (lambda () ...))"
(pcase v
((pred use-package--non-nil-symbolp) t)
(`(,(or 'quote 'function)
,(pred use-package--non-nil-symbolp)) t)
((pred functionp) t)
(`(function (lambda . ,_)) t)
(_ (and additional-pred
(funcall additional-pred v)))))
(defun use-package--normalize-function (v)
"Reduce functional constructions to one of two normal forms:
sym
#'(lambda () ...)"
(pcase v
((pred use-package--non-nil-symbolp) v)
(`(,(or 'quote 'function)
,(and sym (pred use-package--non-nil-symbolp))) sym)
(`(lambda . ,_) v)
(`(quote ,(and lam `(lambda . ,_))) lam)
(`(function ,(and lam `(lambda . ,_))) lam)
(_ v)))
(defun use-package--normalize-commands (args)
"Map over ARGS of the form ((_ . F) ...).
Normalizing functional F's and returning a list of F's
representing symbols (that may need to be autloaded)."
(let ((nargs (mapcar
#'(lambda (x)
(if (consp x)
(cons (car x)
(use-package--normalize-function (cdr x)))
x)) args)))
(cons nargs
(delete nil (mapcar #'(lambda (x)
(and (consp x)
(use-package--non-nil-symbolp (cdr x))
(cdr x))) nargs)))))
(defun use-package-normalize-binder (name keyword args) (defun use-package-normalize-binder (name keyword args)
(use-package-as-one (symbol-name keyword) args (use-package-as-one (symbol-name keyword) args
(lambda (label arg) (lambda (label arg)
(unless (consp arg) (unless (consp arg)
(use-package-error (use-package-error
(concat label " a (<string or vector> . <symbol or string>)" (concat label " a (<string or vector> . <symbol, string or function>)"
" or list of these"))) " or list of these")))
(use-package-normalize-pairs (lambda (k) (or (stringp k) (vectorp k))) (use-package-normalize-pairs
(lambda (b) (or (symbolp b) (stringp b))) #'(lambda (k)
name label arg)))) (pcase k
((pred stringp) t)
((pred vectorp) t)))
#'(lambda (v) (use-package--recognize-function v #'stringp))
name label arg))))
(defalias 'use-package-normalize/:bind 'use-package-normalize-binder) (defalias 'use-package-normalize/:bind 'use-package-normalize-binder)
(defalias 'use-package-normalize/:bind* 'use-package-normalize-binder) (defalias 'use-package-normalize/:bind* 'use-package-normalize-binder)
(defun use-package-handler/:bind (defun use-package-handler/:bind
(name keyword arg rest state &optional bind-macro) (name keyword args rest state &optional bind-macro)
(let ((commands (remq nil (mapcar #'(lambda (arg) (cl-destructuring-bind (nargs . commands)
(if (listp arg) (use-package--normalize-commands args)
(cdr arg)
nil)) arg))))
(use-package-concat (use-package-concat
(use-package-process-keywords name (use-package-process-keywords name
(use-package-sort-keywords (use-package-sort-keywords
@ -1044,7 +1092,7 @@ If RECURSED is non-nil, recurse into sublists."
`((ignore `((ignore
,(macroexpand ,(macroexpand
`(,(if bind-macro bind-macro 'bind-keys) `(,(if bind-macro bind-macro 'bind-keys)
:package ,name ,@arg))))))) :package ,name ,@nargs)))))))
(defun use-package-handler/:bind* (name keyword arg rest state) (defun use-package-handler/:bind* (name keyword arg rest state)
(use-package-handler/:bind name keyword arg rest state 'bind-keys*)) (use-package-handler/:bind name keyword arg rest state 'bind-keys*))
@ -1060,15 +1108,15 @@ If RECURSED is non-nil, recurse into sublists."
;;;###autoload ;;;###autoload
(defun use-package-autoload-keymap (keymap-symbol package override) (defun use-package-autoload-keymap (keymap-symbol package override)
"Loads PACKAGE and then binds the key sequence used to invoke "Loads PACKAGE and then binds the key sequence used to invoke
this function to KEYMAP-SYMBOL. It then simulates pressing the this function to KEYMAP-SYMBOL. It then simulates pressing the
same key sequence a again, so that the next key pressed is routed same key sequence a again, so that the next key pressed is routed
to the newly loaded keymap. to the newly loaded keymap.
This function supports use-package's :bind-keymap keyword. It This function supports use-package's :bind-keymap keyword. It
works by binding the given key sequence to an invocation of this works by binding the given key sequence to an invocation of this
function for a particular keymap. The keymap is expected to be function for a particular keymap. The keymap is expected to be
defined by the package. In this way, loading the package is defined by the package. In this way, loading the package is
deferred until the prefix key sequence is pressed." deferred until the prefix key sequence is pressed."
(if (not (require package nil t)) (if (not (require package nil t))
(use-package-error (format "Cannot load package.el: %s" package)) (use-package-error (format "Cannot load package.el: %s" package))
(if (and (boundp keymap-symbol) (if (and (boundp keymap-symbol)
@ -1096,7 +1144,8 @@ deferred until the prefix key sequence is pressed."
#'(lambda () #'(lambda ()
(interactive) (interactive)
(use-package-autoload-keymap (use-package-autoload-keymap
',(cdr binding) ',(use-package-as-symbol name) ,override)))) arg))) ',(cdr binding) ',(use-package-as-symbol name)
,override)))) arg)))
(use-package-concat (use-package-concat
(use-package-process-keywords name (use-package-process-keywords name
(use-package-sort-keywords (use-package-sort-keywords
@ -1117,23 +1166,27 @@ deferred until the prefix key sequence is pressed."
(use-package-as-one (symbol-name keyword) args (use-package-as-one (symbol-name keyword) args
(apply-partially #'use-package-normalize-pairs (apply-partially #'use-package-normalize-pairs
#'use-package-regex-p #'use-package-regex-p
(lambda (m) (and (not (null m)) (symbolp m))) #'(lambda (v) (use-package--recognize-function v #'null))
name))) name)))
(defun use-package-handle-mode (name alist arg rest state) (defun use-package-handle-mode (name alist args rest state)
"Handle keywords which add regexp/mode pairs to an alist." "Handle keywords which add regexp/mode pairs to an alist."
(let* (commands (cl-destructuring-bind (nargs . commands)
(form (mapcar #'(lambda (thing) (use-package--normalize-commands args)
(push (cdr thing) commands) (let ((form
(setcar thing (mapcar
(use-package-normalize-regex (car thing))) #'(lambda (thing)
`(add-to-list ',alist ',thing)) arg))) `(add-to-list
(use-package-concat ',alist
(use-package-process-keywords name ',(cons (use-package-normalize-regex (car thing))
(use-package-sort-keywords (cdr thing))))
(use-package-plist-maybe-put rest :defer t)) nargs)))
(use-package-plist-append state :commands commands)) (use-package-concat
`((ignore ,@form))))) (use-package-process-keywords name
(use-package-sort-keywords
(use-package-plist-maybe-put rest :defer t))
(use-package-plist-append state :commands commands))
`((ignore ,@form))))))
(defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode) (defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode)
@ -1229,7 +1282,7 @@ deferred until the prefix key sequence is pressed."
(defun ,command (&rest args) (defun ,command (&rest args)
"[Arg list not available until function definition is loaded.] "[Arg list not available until function definition is loaded.]
\(fn ...)" \(fn ...)"
(interactive) (interactive)
(if (bound-and-true-p use-package--recursive-autoload) (if (bound-and-true-p use-package--recursive-autoload)
(use-package-error (use-package-error
@ -1258,30 +1311,26 @@ deferred until the prefix key sequence is pressed."
;; Load the package after a set amount of idle time, if the argument to ;; Load the package after a set amount of idle time, if the argument to
;; `:defer' was a number. ;; `:defer' was a number.
(when (numberp arg) (when (numberp arg)
`((run-with-idle-timer ,arg nil #'require ',(use-package-as-symbol name) nil t))) `((run-with-idle-timer ,arg nil #'require
',(use-package-as-symbol name) nil t)))
;; Since we deferring load, establish any necessary autoloads, and also ;; Since we deferring load, establish any necessary autoloads, and also
;; keep the byte-compiler happy. ;; keep the byte-compiler happy.
(apply (cl-mapcan
#'nconc #'(lambda (command)
(mapcar (when (symbolp command)
#'(lambda (command) (append
(when (not (stringp command)) `((unless (fboundp ',command)
(append ;; Here we are checking the marker value set in
`((unless (fboundp ',command) ;; `use-package-handler/:ensure' to see if deferred
;; Here we are checking the marker value set in ;; installation is actually happening. See
;; `use-package-handler/:ensure' to see if deferred ;; `use-package-handler/:defer-install' for more information.
;; installation is actually happening. See ,(if (eq (plist-get state :defer-install) :ensure)
;; `use-package-handler/:defer-install' for more (use-package--autoload-with-deferred-install command name)
;; information. `(autoload #',command ,name-string nil t))))
,(if (eq (plist-get state :defer-install) :ensure) (when (bound-and-true-p byte-compile-current-file)
(use-package--autoload-with-deferred-install `((eval-when-compile
command name) (declare-function ,command ,name-string)))))))
`(autoload #',command ,name-string nil t)))) (delete-dups (plist-get state :commands)))
(when (bound-and-true-p byte-compile-current-file)
`((eval-when-compile
(declare-function ,command ,name-string)))))))
(delete-dups (plist-get state :commands))))
body))) body)))
@ -1293,11 +1342,10 @@ deferred until the prefix key sequence is pressed."
(defalias 'use-package-normalize/:after 'use-package-normalize-recursive-symlist) (defalias 'use-package-normalize/:after 'use-package-normalize-recursive-symlist)
(defun use-package-require-after-load (defun use-package-require-after-load (features)
(features)
"Return form for after any of FEATURES require NAME." "Return form for after any of FEATURES require NAME."
(pcase features (pcase features
((and (pred symbolp) feat) ((and (pred use-package--non-nil-symbolp) feat)
`(lambda (body) `(lambda (body)
(list 'eval-after-load (list 'quote ',feat) (list 'eval-after-load (list 'quote ',feat)
(list 'quote body)))) (list 'quote body))))
@ -1418,27 +1466,27 @@ deferred until the prefix key sequence is pressed."
(defun use-package-normalize/:hook (name keyword args) (defun use-package-normalize/:hook (name keyword args)
(use-package-as-one (symbol-name keyword) args (use-package-as-one (symbol-name keyword) args
(lambda (label arg) (lambda (label arg)
(unless (or (symbolp arg) (consp arg)) (unless (or (use-package--non-nil-symbolp arg) (consp arg))
(use-package-error (use-package-error
(concat label " a <symbol> or (<symbol or list of symbols> . <symbol or function>)" (concat label " a <symbol> or (<symbol or list of symbols> . <symbol or function>)"
" or list of these"))) " or list of these")))
(use-package-normalize-pairs (use-package-normalize-pairs
#'(lambda (k) #'(lambda (k)
(or (symbolp k) (or (use-package--non-nil-symbolp k)
(and (listp k) (and k (let ((every t))
(listp (cdr k)) (while (and every k)
(cl-every #'symbolp k)))) (if (and (consp k)
#'(lambda (v) (use-package--non-nil-symbolp (car k)))
(or (symbolp v) (functionp v))) (setq k (cdr k))
(setq every nil)))
every))))
#'use-package--recognize-function
name label arg)))) name label arg))))
(defun use-package-handler/:hook (name keyword args rest state) (defun use-package-handler/:hook (name keyword args rest state)
"Generate use-package custom keyword code." "Generate use-package custom keyword code."
(let ((commands (let (funs) (cl-destructuring-bind (nargs . commands)
(dolist (def args) (use-package--normalize-commands args)
(if (symbolp (cdr def))
(setq funs (cons (cdr def) funs))))
(nreverse funs))))
(use-package-concat (use-package-concat
(use-package-process-keywords name (use-package-process-keywords name
(if commands (if commands
@ -1456,7 +1504,8 @@ deferred until the prefix key sequence is pressed."
#'(lambda (sym) #'(lambda (sym)
`(add-hook (quote ,(intern (format "%s-hook" sym))) `(add-hook (quote ,(intern (format "%s-hook" sym)))
(function ,fun))) (function ,fun)))
(if (symbolp syms) (list syms) syms)))) args)))) (if (use-package--non-nil-symbolp syms) (list syms) syms))))
nargs))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
@ -1471,7 +1520,7 @@ deferred until the prefix key sequence is pressed."
(use-package-error (use-package-error
(concat label " a (<symbol> <value> [comment])" (concat label " a (<symbol> <value> [comment])"
" or list of these"))) " or list of these")))
(if (symbolp (car arg)) (if (use-package--non-nil-symbolp (car arg))
(list arg) (list arg)
arg)))) arg))))
@ -1530,7 +1579,7 @@ deferred until the prefix key sequence is pressed."
(cond (cond
((not arg) ((not arg)
(list (use-package-as-mode name))) (list (use-package-as-mode name)))
((symbolp arg) ((use-package--non-nil-symbolp arg)
(list arg)) (list arg))
((stringp arg) ((stringp arg)
(list (cons (use-package-as-mode name) arg))) (list (cons (use-package-as-mode name) arg)))
@ -1538,7 +1587,7 @@ deferred until the prefix key sequence is pressed."
(list arg)) (list arg))
((and (not recursed) (listp arg) (listp (cdr arg))) ((and (not recursed) (listp arg) (listp (cdr arg)))
(mapcar #'(lambda (x) (car (use-package-normalize-diminish (mapcar #'(lambda (x) (car (use-package-normalize-diminish
name label x t))) arg)) name label x t))) arg))
(t (t
(use-package-error (use-package-error
(concat label " wants a string, symbol, " (concat label " wants a string, symbol, "
@ -1569,7 +1618,8 @@ deferred until the prefix key sequence is pressed."
(when (eq :eval (car args)) (when (eq :eval (car args))
;; Handle likely common mistake. ;; Handle likely common mistake.
(use-package-error ":delight mode line constructs must be quoted")) (use-package-error ":delight mode line constructs must be quoted"))
(cond ((and (= (length args) 1) (symbolp (car args))) (cond ((and (= (length args) 1)
(use-package--non-nil-symbolp (car args)))
`(,(nth 0 args) nil ,name)) `(,(nth 0 args) nil ,name))
((= (length args) 2) ((= (length args) 2)
`(,(nth 0 args) ,(nth 1 args) ,name)) `(,(nth 0 args) ,(nth 1 args) ,name))
@ -1584,7 +1634,7 @@ deferred until the prefix key sequence is pressed."
(cond ((null args) (cond ((null args)
`((,(use-package-as-mode name) nil ,name))) `((,(use-package-as-mode name) nil ,name)))
((and (= (length args) 1) ((and (= (length args) 1)
(symbolp (car args))) (use-package--non-nil-symbolp (car args)))
`((,(car args) nil ,name))) `((,(car args) nil ,name)))
((and (= (length args) 1) ((and (= (length args) 1)
(stringp (car args))) (stringp (car args)))
@ -1599,7 +1649,9 @@ deferred until the prefix key sequence is pressed."
`((,(car args) ,@(cdr (nth 1 args)) ,name))) `((,(car args) ,@(cdr (nth 1 args)) ,name)))
(t (mapcar (t (mapcar
(apply-partially #'use-package--normalize-delight-1 name) (apply-partially #'use-package--normalize-delight-1 name)
(if (symbolp (car args)) (list args) args))))) (if (use-package--non-nil-symbolp (car args))
(list args)
args)))))
(defun use-package-handler/:delight (name keyword args rest state) (defun use-package-handler/:delight (name keyword args rest state)
(let ((body (use-package-process-keywords name rest state))) (let ((body (use-package-process-keywords name rest state)))

14
test/lisp/use-package/use-package-tests.el
View file

@ -84,6 +84,20 @@
(should (equal (use-package-normalize-diminish 'foopkg :diminish '(foo . "bar")) (should (equal (use-package-normalize-diminish 'foopkg :diminish '(foo . "bar"))
'((foo . "bar"))))) '((foo . "bar")))))
(ert-deftest use-package--recognize-function-test ()
(should (use-package--recognize-function 'sym))
(should (use-package--recognize-function #'sym))
(should (use-package--recognize-function (lambda () ...)))
(should (use-package--recognize-function '(lambda () ...)))
(should (use-package--recognize-function #'(lambda () ...))))
(ert-deftest use-package--normalize-function-test ()
(should (equal (use-package--normalize-function 'sym) 'sym))
(should (equal (use-package--normalize-function #'sym) 'sym))
(should (equal (use-package--normalize-function (lambda () ...)) (lambda () ...)))
(should (equal (use-package--normalize-function '(lambda () ...)) (lambda () ...)))
(should (equal (use-package--normalize-function #'(lambda () ...)) (lambda () ...))))
;; Local Variables: ;; Local Variables:
;; indent-tabs-mode: nil ;; indent-tabs-mode: nil
;; no-byte-compile: t ;; no-byte-compile: t