Allow multiple keymaps in :map argument

This updates the bind-keys functions to accept either a symbol or a
list as argument for the `:map' keyword, with additional related
fixes:

    (1) Handle the keymap name `nil' as a synonym for `global-map';

    (2) Fail if an invalid argument is specified for `:prefix-map' or
    `:repeat-map' keywords.

Author: fishyfriend

README.md

@@ -246,6 +246,14 @@ The effect of this statement is to wait until `helm` has loaded, and then to
 bind the key `C-c h` to `helm-execute-persistent-action` within Helm's local
 keymap, `helm-command-map`.
 
+Multiple keymaps can be specified as a list:
+
+``` elisp
+(use-package helm
+  :bind (:map (lisp-mode-map emacs-lisp-mode-map)
+         ("C-c x" . eval-print-last-sexp)))
+```
+
 Multiple uses of `:map` may be specified. Any binding occurring before the
 first use of `:map` are applied to the global keymap:
 

bind-key.el

@@ -262,12 +262,13 @@ In contrast to `define-key', this function removes the binding from the keymap."
   "Similar to `bind-key', but overrides any mode-specific bindings."
   `(bind-key ,key-name ,command override-global-map ,predicate))
 
-(defun bind-keys-form (args keymap)
+(defun bind-keys-form (args keymaps)
   "Bind multiple keys at once.
 
 Accepts keyword arguments:
-:map MAP               - a keymap into which the keybindings should be
-                         added
+:map MAPS              - a keymap into which the keybindings should be
+                         added, or a list of such keymaps, where `nil'
+                         stands for `global-map'
 :prefix KEY            - prefix key for these bindings
 :prefix-map MAP        - name of the prefix map that should be created
                          for these bindings
@@ -290,7 +291,7 @@ Accepts keyword arguments:
 
 The rest of the arguments are conses of keybinding string and a
 function symbol (unquoted)."
-  (let (map
+  (let (maps
         prefix-doc
         prefix-map
         prefix
@@ -307,20 +308,18 @@ function symbol (unquoted)."
       (while (and cont args)
         (if (cond ((and (eq :map (car args))
                         (not prefix-map))
-                   (setq map (cadr args)))
+                   (setq maps
+                         (let ((arg (cadr args)))
+                           (if (consp arg) arg (list arg)))))
                   ((eq :prefix-docstring (car args))
                    (setq prefix-doc (cadr args)))
-                  ((and (eq :prefix-map (car args))
-                        (not (memq map '(global-map
-                                         override-global-map))))
-                   (setq prefix-map (cadr args)))
+                  ((eq :prefix-map (car args))
+                   (setq prefix-map (or (cadr args) 'global-map)))
                   ((eq :repeat-docstring (car args))
                    (setq repeat-doc (cadr args)))
-                  ((and (eq :repeat-map (car args))
-                        (not (memq map '(global-map
-                                         override-global-map))))
-                   (setq repeat-map (cadr args))
-                   (setq map repeat-map))
+                  ((eq :repeat-map (car args))
+                   (setq repeat-map (or (cadr args) 'global-map))
+                   (setq maps (list repeat-map)))
                   ((eq :continue (car args))
                    (setq repeat-type :continue
                          arg-change-func 'cdr))
@@ -342,14 +341,20 @@ function symbol (unquoted)."
               (and prefix (not prefix-map)))
       (error "Both :prefix-map and :prefix must be supplied"))
 
+    (when (memq prefix-map '(global-map override-global-map))
+      (error "Invalid :prefix-map"))
+
+    (when (memq repeat-map '(global-map override-global-map))
+      (error "Invalid :repeat-map"))
+
     (when repeat-type
       (unless repeat-map
         (error ":continue and :exit require specifying :repeat-map")))
 
     (when (and menu-name (not prefix))
       (error "If :menu-name is supplied, :prefix must be too"))
 
-    (unless map (setq map keymap))
+    (setq maps (or maps keymaps (list nil)))
 
     ;; Process key binding arguments
     (let (first next)
@@ -381,40 +386,40 @@ function symbol (unquoted)."
              ,@(if menu-name
                    `((define-prefix-command ',prefix-map nil ,menu-name))
                  `((define-prefix-command ',prefix-map)))
-             ,@(if (and map (not (eq map 'global-map)))
-                   (wrap map `((bind-key ,prefix ',prefix-map ,map ,filter)))
-                 `((bind-key ,prefix ',prefix-map nil ,filter)))))
+             ,@(cl-mapcan
+                (lambda (map)
+                  (wrap map `((bind-key ,prefix ',prefix-map ,map ,filter))))
+                maps)))
          (when repeat-map
            `((defvar ,repeat-map (make-sparse-keymap)
                ,@(when repeat-doc `(,repeat-doc)))))
-         (wrap map
-               (cl-mapcan
-                (lambda (form)
-                  (let ((fun (and (cdr form) (list 'function (cdr form)))))
-                    (if prefix-map
-                        `((bind-key ,(car form) ,fun ,prefix-map ,filter))
-                      (if (and map (not (eq map 'global-map)))
-                          ;; Only needed in this branch, since when
-                          ;; repeat-map is non-nil, map is always
-                          ;; non-nil
-                          `(,@(when (and repeat-map (not (eq repeat-type :exit)))
-                                `((put ,fun 'repeat-map ',repeat-map)))
-                            (bind-key ,(car form) ,fun ,map ,filter))
-                        `((bind-key ,(car form) ,fun nil ,filter))))))
-                first))
+         (cl-mapcan
+          (lambda (map)
+            (wrap map
+                  (cl-mapcan
+                   (lambda (form)
+                     (let ((fun (and (cdr form) (list 'function (cdr form)))))
+                       (if prefix-map
+                           `((bind-key ,(car form) ,fun ,prefix-map ,filter))
+                         `(,@(when (and repeat-map (not (eq repeat-type :exit)))
+                               `((put ,fun 'repeat-map ',repeat-map)))
+                           (bind-key ,(car form) ,fun ,map ,filter)))))
+                   first)))
+          maps)
          (when next
            (bind-keys-form `(,@(when repeat-map `(:repeat-map ,repeat-map))
                              ,@(if pkg
                                    (cons :package (cons pkg next))
-                                 next)) map)))))))
+                                 next))
+                           maps)))))))
 
 ;;;###autoload
 (defmacro bind-keys (&rest args)
   "Bind multiple keys at once.
 
 Accepts keyword arguments:
 :map MAP               - a keymap into which the keybindings should be
-                         added
+                         added, or a list of such keymaps
 :prefix KEY            - prefix key for these bindings
 :prefix-map MAP        - name of the prefix map that should be created
                          for these bindings
@@ -446,7 +451,7 @@ Accepts the same keyword arguments as `bind-keys' (which see).
 
 This binds keys in such a way that bindings are not overridden by
 other modes.  See `override-global-mode'."
-  (macroexp-progn (bind-keys-form args 'override-global-map)))
+  (macroexp-progn (bind-keys-form args '(override-global-map))))
 
 (defun get-binding-description (elem)
   (cond

use-package-bind-key.el

@@ -92,19 +92,20 @@ deferred until the prefix key sequence is pressed."
          ;;   :prefix-docstring STRING
          ;;   :prefix-map SYMBOL
          ;;   :prefix STRING
-	 ;;   :repeat-docstring STRING
+         ;;   :repeat-docstring STRING
          ;;   :repeat-map SYMBOL
          ;;   :filter SEXP
          ;;   :menu-name STRING
          ;;   :package SYMBOL
-	 ;;   :continue and :exit are used within :repeat-map
-         ((or (and (eq x :map) (symbolp (cadr arg)))
+         ;;   :continue and :exit are used within :repeat-map
+         ((or (and (eq x :map) (or (symbolp (cadr arg))
+                                   (listp (cadr arg))))
               (and (eq x :prefix) (stringp (cadr arg)))
               (and (eq x :prefix-map) (symbolp (cadr arg)))
               (and (eq x :prefix-docstring) (stringp (cadr arg)))
-	      (and (eq x :repeat-map) (symbolp (cadr arg)))
-	      (eq x :continue)
-	      (eq x :exit)
+              (and (eq x :repeat-map) (symbolp (cadr arg)))
+              (eq x :continue)
+              (eq x :exit)
               (and (eq x :repeat-docstring) (stringp (cadr arg)))
               (eq x :filter)
               (and (eq x :menu-name) (stringp (cadr arg)))

use-package-tests.el

@@ -1930,17 +1930,139 @@
           (autoload #'nonexistent "nonexistent" nil t))
         (add-hook 'lisp-mode-hook #'nonexistent)))))
 
-(ert-deftest bind-key/:prefix-map ()
+(ert-deftest bind-key-test/:map-1 ()
+  (match-expansion
+   (bind-keys
+    ("C-1" . command-1)
+    ("C-2" . command-2)
+    :map keymap-1
+    ("C-3" . command-3)
+    ("C-4" . command-4)
+    :map (keymap-2 keymap-3)
+    ("C-5" . command-5)
+    ("C-6" . command-6))
+   `(progn (bind-key "C-1" #'command-1 nil nil)
+           (bind-key "C-2" #'command-2 nil nil)
+           (bind-key "C-3" #'command-3 keymap-1 nil)
+           (bind-key "C-4" #'command-4 keymap-1 nil)
+           (bind-key "C-5" #'command-5 keymap-2 nil)
+           (bind-key "C-6" #'command-6 keymap-2 nil)
+           (bind-key "C-5" #'command-5 keymap-3 nil)
+           (bind-key "C-6" #'command-6 keymap-3 nil))))
+
+(ert-deftest bind-key-test/:map-2 ()
+  (match-expansion
+   (bind-keys :package p
+    ("C-1" . c1)
+    :map m1 ("C-2" . c2)
+    :map (m2 m3) ("C-3" . c3)
+    :map (nil m4) ("C-4" . c4)
+    :map (global-map m5) ("C-5" . c5))
+   `(progn (bind-key "C-1" #'c1 nil nil)
+           (if (boundp 'm1)
+               (bind-key "C-2" #'c2 m1 nil)
+             (eval-after-load 'p '(bind-key "C-2" #'c2 m1 nil)))
+           (if (boundp 'm2)
+               (bind-key "C-3" #'c3 m2 nil)
+             (eval-after-load 'p '(bind-key "C-3" #'c3 m2 nil)))
+           (if (boundp 'm3)
+               (bind-key "C-3" #'c3 m3 nil)
+             (eval-after-load 'p '(bind-key "C-3" #'c3 m3 nil)))
+           (bind-key "C-4" #'c4 nil nil)
+           (if (boundp 'm4)
+               (bind-key "C-4" #'c4 m4 nil)
+             (eval-after-load 'p '(bind-key "C-4" #'c4 m4 nil)))
+           (bind-key "C-5" #'c5 global-map nil)
+           (if (boundp 'm5)
+               (bind-key "C-5" #'c5 m5 nil)
+             (eval-after-load 'p '(bind-key "C-5" #'c5 m5 nil))))))
+
+(ert-deftest bind-key-test/:map-3 ()
+  (should-error
+   (expand-minimally
+    (bind-keys :prefix "x" :prefix-map nil ("y" . x))))
+  (should-error
+   (expand-minimally
+    (bind-keys :prefix "x" :prefix-map global-map ("y" . x))))
+  (should-error
+   (expand-minimally
+    (bind-keys :prefix "x" :prefix-map override-global-map ("y" . x))))
+  (should-error
+   (expand-minimally (bind-keys :repeat-map nil ("y" . x))))
+  (should-error
+   (expand-minimally (bind-keys :repeat-map global-map ("y" . x))))
+  (should-error
+   (expand-minimally
+    (bind-keys :repeat-map override-global-map ("y" . x)))))
+
+(ert-deftest bind-key-test/:prefix-map ()
   (match-expansion
-   (bind-keys :prefix "<f1>"
-              :prefix-map my/map)
+   (bind-keys ("C-1" . command-1)
+              :prefix "<f1>"
+              :prefix-map my/map
+              ("C-2" . command-2)
+              ("C-3" . command-3))
    `(progn
+      (bind-key "C-1" #'command-1 nil nil)
       (defvar my/map)
       (define-prefix-command 'my/map)
-      (bind-key "<f1>" 'my/map nil nil))))
-
-
-(ert-deftest bind-key/845 ()
+      (bind-key "<f1>" 'my/map nil nil)
+      (bind-key "C-2" #'command-2 my/map nil)
+      (bind-key "C-3" #'command-3 my/map nil))))
+
+(ert-deftest bind-key-test/:repeat-map-1 ()
+  ;; NOTE: This test is pulled from the discussion in issue #964,
+  ;; adjusting for the final syntax that was implemented.
+  (match-expansion
+   (bind-keys
+    ("C-c n" . git-gutter+-next-hunk)
+    ("C-c p" . git-gutter+-previous-hunk)
+    ("C-c s" . git-gutter+-stage-hunks)
+    ("C-c r" . git-gutter+-revert-hunk)
+    :repeat-map my/git-gutter+-repeat-map
+                 ("n" . git-gutter+-next-hunk)
+                 ("p" . git-gutter+-previous-hunk)
+                 ("s" . git-gutter+-stage-hunks)
+                 ("r" . git-gutter+-revert-hunk)
+                 :repeat-docstring
+                 "Keymap to repeat git-gutter+-* commands.")
+   `(progn
+     (bind-key "C-c n" #'git-gutter+-next-hunk nil nil)
+     (bind-key "C-c p" #'git-gutter+-previous-hunk nil nil)
+     (bind-key "C-c s" #'git-gutter+-stage-hunks nil nil)
+     (bind-key "C-c r" #'git-gutter+-revert-hunk nil nil)
+     (defvar my/git-gutter+-repeat-map (make-sparse-keymap))
+     (put #'git-gutter+-next-hunk 'repeat-map 'my/git-gutter+-repeat-map)
+     (bind-key "n" #'git-gutter+-next-hunk my/git-gutter+-repeat-map nil)
+     (put #'git-gutter+-previous-hunk 'repeat-map 'my/git-gutter+-repeat-map)
+     (bind-key "p" #'git-gutter+-previous-hunk my/git-gutter+-repeat-map nil)
+     (put #'git-gutter+-stage-hunks 'repeat-map 'my/git-gutter+-repeat-map)
+     (bind-key "s" #'git-gutter+-stage-hunks my/git-gutter+-repeat-map nil)
+     (put #'git-gutter+-revert-hunk 'repeat-map 'my/git-gutter+-repeat-map)
+     (bind-key "r" #'git-gutter+-revert-hunk my/git-gutter+-repeat-map nil)
+     (defvar my/git-gutter+-repeat-map (make-sparse-keymap) "Keymap to repeat git-gutter+-* commands."))))
+
+(ert-deftest bind-key-test/:repeat-map-2 ()
+  (match-expansion
+   (bind-keys :map m ("x" . cmd1) :repeat-map rm ("y" . cmd2))
+   `(progn
+      (bind-key "x" #'cmd1 m nil)
+      (defvar rm (make-sparse-keymap))
+      (put #'cmd2 'repeat-map 'rm)
+      (bind-key "y" #'cmd2 rm nil))))
+
+(ert-deftest bind-key-test/:repeat-map-3 ()
+  (match-expansion
+   (bind-keys :repeat-map rm ("y" . cmd2) :map m ("x" . cmd1))
+   `(progn
+      (defvar rm (make-sparse-keymap))
+      (put #'cmd2 'repeat-map 'rm)
+      (bind-key "y" #'cmd2 rm nil)
+      (defvar rm (make-sparse-keymap))
+      (put #'cmd1 'repeat-map 'rm)
+      (bind-key "x" #'cmd1 m nil))))
+
+(ert-deftest bind-key-test/845 ()
   (defvar test-map (make-keymap))
   (bind-key "<f1>" 'ignore 'test-map)
   (should (eq (lookup-key test-map (kbd "<f1>")) 'ignore))