feature/use-package 4be96c9dcbe 1/4: Drop key-chord.el support from use-package

[Stefan Kangas]

branch: feature/use-package
commit 4be96c9dcbe8405df5b29507388481c15884da1f
Author: Stefan Kangas <stefankangas@gmail.com>
Commit: Stefan Kangas <stefankangas@gmail.com>

    Drop key-chord.el support from use-package
    
    * lisp/use-package/bind-chord.el:
    * lisp/use-package/use-package-chords.el:
    * test/lisp/use-package/use-package-chords-tests.el: Delete files.
    * doc/misc/use-package.texi (use-package-chords): Delete section.
    Ref: https://lists.gnu.org/r/emacs-devel/2022-12/msg00052.html
---
 doc/misc/use-package.texi                         |  27 ----
 lisp/use-package/bind-chord.el                    | 113 ---------------
 lisp/use-package/use-package-chords.el            |  54 -------
 test/lisp/use-package/use-package-chords-tests.el | 169 ----------------------
 4 files changed, 363 deletions(-)

diff --git a/doc/misc/use-package.texi b/doc/misc/use-package.texi
index f69b3123f30..e7bddd628c9 100644
--- a/doc/misc/use-package.texi
+++ b/doc/misc/use-package.texi
@@ -1604,7 +1604,6 @@ be optionally enabled.
 
 @menu
 * use-package-ensure-system-package::
-* use-package-chords::
 * Creating an extension::
 @end menu
 
@@ -1710,32 +1709,6 @@ The user options @code{system-packages-package-manager} 
and
 commands.  Custom commands should include the call to sudo in the
 command if needed.
 
-@node use-package-chords
-@section @code{(use-package-chords)}
-
-The @code{:chords} keyword allows you to define
-@uref{https://www.emacswiki.org/emacs/key-chord.el,@code{key-chord}}
-bindings for @code{use-package} declarations in the same manner as the
-@code{:bind} keyword.
-
-To enable the extension:
-
-@lisp
-(use-package use-package-chords
-  :ensure t
-  :config (key-chord-mode 1))
-@end lisp
-
-Then you can define your chord bindings in the same manner as
-@code{:bind} using a cons or a list of conses:
-
-@lisp
-(use-package ace-jump-mode
-  :chords (("jj" . ace-jump-char-mode)
-           ("jk" . ace-jump-word-mode)
-           ("jl" . ace-jump-line-mode)))
-@end lisp
-
 @node Creating an extension
 @section How to create an extension keyword
 
diff --git a/lisp/use-package/bind-chord.el b/lisp/use-package/bind-chord.el
deleted file mode 100644
index ed736a4b966..00000000000
--- a/lisp/use-package/bind-chord.el
+++ /dev/null
@@ -1,113 +0,0 @@
-;;; bind-chord.el --- key-chord binding helper for use-package-chords  -*- 
lexical-binding: t; -*-
-
-;; Copyright (C) 2015-2022 Free Software Foundation, Inc.
-
-;; Author: Justin Talbott <justin@waymondo.com>
-;; Keywords: convenience, tools, extensions
-;; URL: https://github.com/jwiegley/use-package
-;; Version: 0.2.1
-;; Package-Requires: ((emacs "24.3") (bind-key "1.0") (key-chord "0.6"))
-;; Filename: bind-chord.el
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;; Code:
-
-(require 'bind-key)
-(require 'key-chord nil t)
-
-;;;###autoload
-(defmacro bind-chord (chord command &optional keymap)
-  "Bind CHORD to COMMAND in KEYMAP (`global-map' if not passed)."
-  (let ((key1 (logand 255 (aref chord 0)))
-        (key2 (logand 255 (aref chord 1))))
-    (if (eq key1 key2)
-        `(bind-key (vector 'key-chord ,key1 ,key2) ,command ,keymap)
-      `(progn
-         (bind-key (vector 'key-chord ,key1 ,key2) ,command ,keymap)
-         (bind-key (vector 'key-chord ,key2 ,key1) ,command ,keymap)))))
-
-(defun bind-chords-form (args keymap)
-  "Bind multiple chords at once.
-
-Accepts keyword arguments:
-:map MAP               - a keymap into which the keybindings should be
-                         added
-
-The rest of the arguments are conses of keybinding string and a
-function symbol (unquoted)."
-  (let (map pkg)
-    (let ((cont t))
-      (while (and cont args)
-        (if (cond ((eq :map (car args))
-                   (setq map (cadr args)))
-                  ((eq :package (car args))
-                   (setq pkg (cadr args))))
-            (setq args (cddr args))
-          (setq cont nil))))
-
-    (unless map (setq map keymap))
-
-    (let (first next)
-      (while args
-        (if (keywordp (car args))
-            (progn
-              (setq next args)
-              (setq args nil))
-          (if first
-              (nconc first (list (car args)))
-            (setq first (list (car args))))
-          (setq args (cdr args))))
-
-      (cl-flet
-          ((wrap (map bindings)
-                 (if (and map pkg (not (memq map '(global-map
-                                                   override-global-map))))
-                     `((if (boundp ',map)
-                           ,(macroexp-progn bindings)
-                         (eval-after-load
-                             ,(if (symbolp pkg) `',pkg pkg)
-                           ',(macroexp-progn bindings))))
-                   bindings)))
-
-        (append
-         (wrap map
-               (cl-mapcan
-                (lambda (form)
-                  (let ((fun (and (cdr form) (list 'function (cdr form)))))
-                    (if (and map (not (eq map 'global-map)))
-                        `((bind-chord ,(car form) ,fun ,map))
-                      `((bind-chord ,(car form) ,fun nil)))))
-                first))
-         (when next
-           (bind-chords-form (if pkg
-                            (cons :package (cons pkg next))
-                          next) map)))))))
-
-;;;###autoload
-(defmacro bind-chords (&rest args)
-  "Bind multiple chords at once.
-
-Accepts keyword argument:
-:map - a keymap into which the keybindings should be added
-
-The rest of the arguments are conses of keybinding string and a
-function symbol (unquoted)."
-  (macroexp-progn (bind-chords-form args nil)))
-
-(provide 'bind-chord)
-
-;;; bind-chord.el ends here
diff --git a/lisp/use-package/use-package-chords.el 
b/lisp/use-package/use-package-chords.el
deleted file mode 100644
index 479083b9296..00000000000
--- a/lisp/use-package/use-package-chords.el
+++ /dev/null
@@ -1,54 +0,0 @@
-;;; use-package-chords.el --- key-chord keyword for use-package  -*- 
lexical-binding: t; -*-
-
-;; Copyright (C) 2015-2022 Free Software Foundation, Inc.
-
-;; Author: Justin Talbott <justin@waymondo.com>
-;; Keywords: convenience, tools, extensions
-;; URL: https://github.com/jwiegley/use-package
-;; Version: 0.2.1
-;; Package-Requires: ((use-package "2.1") (bind-key "1.0") (bind-chord "0.2") 
(key-chord "0.6"))
-;; Filename: use-package-chords.el
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; The `:chords' keyword allows you to define `key-chord' bindings for
-;; `use-package' declarations in the same manner as the `:bind'
-;; keyword.
-
-;;; Code:
-
-(require 'use-package)
-(require 'bind-chord)
-
-;;;###autoload
-(defalias 'use-package-autoloads/:chords 'use-package-autoloads-mode)
-
-;;;###autoload
-(defalias 'use-package-normalize/:chords 'use-package-normalize-binder)
-
-;;;###autoload
-(defun use-package-handler/:chords (name _keyword arg rest state)
-  "Handler for `:chords' keyword in `use-package'."
-  (use-package-concat
-   (use-package-process-keywords name rest state)
-   `(,(macroexpand
-       `(bind-chords :package ,name ,@arg)))))
-
-(add-to-list 'use-package-keywords :chords)
-
-(provide 'use-package-chords)
-
-;;; use-package-chords.el ends here
diff --git a/test/lisp/use-package/use-package-chords-tests.el 
b/test/lisp/use-package/use-package-chords-tests.el
deleted file mode 100644
index 665784eaf46..00000000000
--- a/test/lisp/use-package/use-package-chords-tests.el
+++ /dev/null
@@ -1,169 +0,0 @@
-;;; use-package-chords-tests.el --- Tests for use-package-chords.el  -*- 
lexical-binding: t; -*-
-
-;; Copyright (C) 2019-2022 Free Software Foundation, Inc.
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-;;; Code:
-
-(require 'ert)
-(require 'use-package)
-(require 'use-package-chords)
-
-(setq use-package-always-ensure nil
-      use-package-verbose 'errors
-      use-package-expand-minimally t)
-
-(defmacro match-expansion (form &rest value)
-  `(should (pcase (expand-minimally ,form)
-             ,@(mapcar #'(lambda (x) (list x t)) value))))
-
-;; Copied from use-package-tests.el.
-(defmacro expand-minimally (form)
-  `(let ((use-package-verbose 'errors)
-         (use-package-expand-minimally t))
-     (macroexpand-1 ',form)))
-
-(defun use-package-test-normalize-chord (&rest args)
-  (apply #'use-package-normalize-binder 'foo :chords args))
-
-(ert-deftest use-package-test-normalize/:chords-1 ()
-  (should (equal (use-package-test-normalize-chord
-                  '(("C-a" . alpha)))
-                 '(("C-a" . alpha)))))
-
-(ert-deftest use-package-test-normalize/:chords-2 ()
-  (should (equal (use-package-test-normalize-chord
-                  '(("C-a" . alpha)
-                    :map foo-map
-                    ("C-b" . beta)))
-                 '(("C-a" . alpha)
-                   :map foo-map
-                   ("C-b" . beta)))))
-
-(ert-deftest use-package-test-normalize/:chords-3 ()
-  (should (equal (use-package-test-normalize-chord
-                  '(:map foo-map
-                         ("C-a" . alpha)
-                         ("C-b" . beta)))
-                 '(:map foo-map
-                        ("C-a" . alpha)
-                        ("C-b" . beta)))))
-
-(ert-deftest use-package-test/:chords-1 ()
-  ;; FIXME:
-  :tags '(:unstable)
-  (match-expansion
-   (use-package foo :chords ("C-k" . key1) ("C-u" . key2))
-   `(progn
-      (unless
-          (fboundp 'key1)
-        (autoload #'key1 "foo" nil t))
-      (unless
-          (fboundp 'key2)
-        (autoload #'key2 "foo" nil t))
-      (bind-chord "C-k" #'key1 nil)
-      (bind-chord "C-u" #'key2 nil))))
-
-(ert-deftest use-package-test/:chords-2 ()
-  ;; FIXME:
-  :tags '(:unstable)
-  (match-expansion
-   (use-package foo :chords (("C-k" . key1) ("C-u" . key2)))
-   `(progn
-      (unless (fboundp 'key1)
-        (autoload #'key1 "foo" nil t))
-      (unless (fboundp 'key2)
-        (autoload #'key2 "foo" nil t))
-      (bind-chord "C-k" #'key1 nil)
-      (bind-chord "C-u" #'key2 nil))))
-
-(ert-deftest use-package-test/:chords-3 ()
-  (match-expansion
-   (use-package foo :chords (:map my-map ("C-k" . key1) ("C-u" . key2)))
-   `(progn
-      (unless
-          (fboundp 'key1)
-        (autoload #'key1 "foo" nil t))
-      (unless
-          (fboundp 'key2)
-        (autoload #'key2 "foo" nil t))
-      (if
-          (boundp 'my-map)
-          (progn
-            (bind-chord "C-k" #'key1 my-map)
-            (bind-chord "C-u" #'key2 my-map))
-        (eval-after-load 'foo
-          '(progn
-             (bind-chord "C-k" #'key1 my-map)
-             (bind-chord "C-u" #'key2 my-map)))))))
-
-(ert-deftest use-package-test/:chords-4 ()
-  (should-error
-   (match-expansion
-    (use-package foo :chords :map my-map ("C-k" . key1) ("C-u" . key2))
-    `(bind-chords :package foo))))
-
-(ert-deftest use-package-test/:chords-5 ()
-  (match-expansion
-   (use-package foo :chords ("C-k" . key1) (:map my-map ("C-u" . key2)))
-   `(progn
-      (unless (fboundp 'key1)
-        (autoload #'key1 "foo" nil t))
-      (unless (fboundp 'key2)
-        (autoload #'key2 "foo" nil t))
-      (progn
-        (bind-chord "C-k" #'key1 nil)
-        (if
-            (boundp 'my-map)
-            (bind-chord "C-u" #'key2 my-map)
-          (eval-after-load 'foo
-            '(bind-chord "C-u" #'key2 my-map)))))))
-
-(ert-deftest use-package-test/:chords-6 ()
-  (match-expansion
-   (use-package foo
-     :chords
-     ("C-k" . key1)
-     (:map my-map ("C-u" . key2))
-     (:map my-map2 ("C-u" . key3)))
-   `(progn
-      (unless
-          (fboundp 'key1)
-        (autoload #'key1 "foo" nil t))
-      (unless
-          (fboundp 'key2)
-        (autoload #'key2 "foo" nil t))
-      (unless
-          (fboundp 'key3)
-        (autoload #'key3 "foo" nil t))
-      (progn
-        (bind-chord "C-k" #'key1 nil)
-        (if
-            (boundp 'my-map)
-            (bind-chord "C-u" #'key2 my-map)
-          (eval-after-load 'foo
-            '(bind-chord "C-u" #'key2 my-map)))
-        (if
-            (boundp 'my-map2)
-            (bind-chord "C-u" #'key3 my-map2)
-          (eval-after-load 'foo
-            '(bind-chord "C-u" #'key3 my-map2)))))))
-
-;; Local Variables:
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; End:
-
-;;; use-package-chords-tests.el ends here