mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-06 06:20:55 -08:00
Code Issues Projects Releases Wiki Activity

Drop key-chord.el support from use-package

Browse source 
* 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
This commit is contained in:
Stefan Kangas 2022-12-08 01:12:02 +01:00
parent 5899cac111
commit 4be96c9dcb
4 changed files with 0 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

27
doc/misc/use-package.texi
View file

@ -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

113
lisp/use-package/bind-chord.el
View file

@ -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

54
lisp/use-package/use-package-chords.el
View file

@ -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

169
test/lisp/use-package/use-package-chords-tests.el
View file

@ -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