├── .github ├── CONTRIBUTING.md ├── README.md └── workflows │ └── test.yml ├── .gitignore ├── Cask ├── LICENSE ├── features ├── c-commands.feature ├── digit-arguments.feature ├── execute-with-current-bindings.feature ├── insertion-mode.feature ├── last-command-event.feature ├── predicates-disable.feature ├── prefix-arguments.feature ├── prefix-help.feature ├── regions.feature ├── repeat.feature ├── step-definitions │ └── god-mode-steps.el └── support │ └── env.el ├── god-mode-isearch.el └── god-mode.el /.github/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Please write a failing test before submitting pull requests. All new features should be accompanied by new tests. 4 | 5 | Tests are written in [Ecukes](https://github.com/ecukes/ecukes), an integration testing framework for Emacs. 6 | 7 | ## Setup 8 | 9 | To fetch the test dependencies, install [cask](https://github.com/cask/cask): 10 | 11 | ```bash 12 | curl -fsSkL https://raw.github.com/cask/cask/master/go | python 13 | ``` 14 | 15 | then: 16 | 17 | ```bash 18 | cd /path/to/god-mode 19 | cask 20 | ``` 21 | 22 | Run the tests with: 23 | 24 | ```bash 25 | cask exec ecukes 26 | ``` 27 | -------------------------------------------------------------------------------- /.github/README.md: -------------------------------------------------------------------------------- 1 | # God Mode — no more RSI 2 | 3 | [![melpa-badge][melpa-badge]][melpa-link] 4 | [![melpa-stable-badge][melpa-stable-badge]][melpa-stable-link] 5 | [![gh-actions-badge][gh-actions-badge]][gh-actions-link] 6 | 7 | _NOTE_: This package requires Emacs 26.3 to work well. 8 | 9 | This is a global minor mode for entering Emacs commands without 10 | modifier keys. It's similar to Vim's separation of command mode and 11 | insert mode. 12 | 13 | All existing key bindings will work in God mode. It's only there to reduce your 14 | usage of modifier keys. 15 | 16 | ## Example 17 | 18 | In the example below, you can see how much effort is reduced: 19 | 20 | ``` 21 | Before: C-p C-k C-n M-^ ) C-j C-y M-r C-x z z M-2 M-f C-x C-s 22 | After: p k n g ^ ) j y g r . . 2 g f x s 23 | ``` 24 | 25 | (Regarding ., see the [useful key bindings section][useful-key-bindings].) 26 | 27 | You'll find this mode surprisingly natural, as you would already know how to use 28 | your existing Emacs commands. Whenever you feel like it, you can explicitly use 29 | modifier keys too. 30 | 31 | See the [key mapping section][key-mapping] for a complete walk-through of key 32 | translations. 33 | 34 | ## Setup 35 | 36 | You can load and activate God mode as follows: 37 | 38 | ```emacs-lisp 39 | (require 'god-mode) 40 | (god-mode) 41 | ``` 42 | 43 | This will activate God mode in all future buffers. However, activation of God 44 | mode itself is buffer-local. 45 | 46 | God mode can be toggled through `god-local-mode` using the escape key 47 | (ESC) as follows: 48 | 49 | ```emacs-lisp 50 | (global-set-key (kbd "") #'god-local-mode) 51 | ``` 52 | 53 | If you want to toggle God mode on _all active and future buffers_, use 54 | `god-mode-all` as follows: 55 | 56 | ```emacs-lisp 57 | (global-set-key (kbd "") #'god-mode-all) 58 | ``` 59 | 60 | If God mode is activated through `god-mode` or `god-mode-all`, you might want to 61 | ensure that no buffers are skipped, as follows: 62 | 63 | ```emacs-lisp 64 | (setq god-exempt-major-modes nil) 65 | (setq god-exempt-predicates nil) 66 | ``` 67 | 68 | This means that `magit-mode` or `dired-mode`, for example, will also enter God 69 | mode when you activate it in all buffers. This means you can always reliably use 70 | God mode commands in any buffer. 71 | 72 | When God mode is enabled, entering function keys will be translated to use 73 | appropriate key modifiers. For example, entering <f5> is 74 | translated to C-<f5>. To disable this translation, you can set the 75 | `god-mode-enable-function-key-translation` variable to `nil` before loading God 76 | mode, as follows: 77 | 78 | ``` emacs-lisp 79 | (setq god-mode-enable-function-key-translation nil) 80 | (require 'god-mode) 81 | ``` 82 | 83 | Also, you can add this to your `.xmodmap` to rebind the caps lock key to the 84 | escape key: 85 | 86 | ``` 87 | remove Lock = Caps_Lock 88 | keysym Caps_Lock = Escape 89 | ``` 90 | 91 | And run `xmodmap .xmodmap` for the changes to take effect immediately. 92 | 93 | Or use `dconf`: 94 | 95 | ``` sh 96 | dconf write /org/gnome/desktop/input-sources/xkb-options "['caps:escape']" 97 | ``` 98 | 99 | See [this link][switch-caps-lock-and-esc] for more details. 100 | 101 | ## Key mapping 102 | 103 | This package defines the following key mappings: 104 | 105 | * All commands are assumed to use the control modifier (C-) unless 106 | otherwise indicated. Here are some examples: 107 | 108 | * x → C-x 109 | * f → C-f 110 | * x s → C-x C-s 111 | * x SPC s → C-x s 112 | 113 | Note the use of the space key (SPC) 114 | to produce C-x s. 115 | 116 | * The literal key (SPC) is sticky. This means you don't have to enter 117 | SPC repeatedly for key bindings such as C-x r t. 118 | Entering the literal key again toggles its state. 119 | The literal key can be changed through `god-literal-key`. Here are some examples: 120 | 121 | * x SPC r t → C-x r t 122 | * x SPC r SPC g w → C-x r M-w 123 | 124 | * g is used to indicate the meta modifier (M-). This means 125 | that there is no way to enter C-g in God mode, and you must 126 | therefore type in C-g directly. This key can be changed through 127 | `god-mode-alist`. Here are some examples: 128 | 129 | * g x → M-x 130 | * g f → M-f 131 | 132 | * G is used to indicate both the control and meta modifiers 133 | (C-M-). This key can also be changed through `god-mode-alist`. Here 134 | are some examples: 135 | 136 | * G x → C-M-x 137 | * G f → C-M-f 138 | 139 | * Digit arguments can also be used: 140 | 141 | * 1 2 f → M-12 C-f 142 | 143 | * If you use some of the [useful key bindings][useful-key-bindings], 144 | z or . can repeat the previous command: 145 | 146 | * g f . . → M-f 147 | M-f M-f 148 | 149 | * Universal arguments can also be specified using u: 150 | 151 | * u c o → C-u C-c 152 | C-o 153 | 154 | ## Lookup a key sequence 155 | You can use `god-mode-describe-key` to check what command would be triggered by particular keys. This function works similarly to `describe-key`: it prompts for a key combination, translates it into a command, and display its information in the Help buffer. 156 | 157 | By default, `god-mode-describe-key` is bound to `C-h k` in `god-local-mode-map`. 158 | 159 | Note that `god-mode-describe-key` is only able to interpret key-bindings that are specific to `god-mode`. For other key-bindings, mouse-clicks, and menu items, it's better to use `describe-key`. 160 | 161 | ## Visual indicators for God mode 162 | 163 | God mode allows you to customize its minor mode lighter by customizing the `god-mode-lighter-string` variable and the `god-mode-lighter` face. 164 | For example, if you don't want any lighter, you can set the string to nil. 165 | On the other hand, if you want the lighter to stand out, you can change the face, e.g. by making it inherit from `error`. 166 | You can do this using `M-x customize-face RET god-mode-lighter` or as follows: 167 | 168 | ```emacs-lisp 169 | (custom-set-faces 170 | '(god-mode-lighter ((t (:inherit error))))) 171 | ``` 172 | 173 | Additionally, you can change the cursor style to visually indicate whether God mode is active 174 | as follows: 175 | 176 | ```emacs-lisp 177 | (defun my-god-mode-update-cursor-type () 178 | (setq cursor-type (if (or god-local-mode buffer-read-only) 'box 'bar))) 179 | 180 | (add-hook 'post-command-hook #'my-god-mode-update-cursor-type) 181 | ``` 182 | 183 | You can also change the foreground and background of the mode line to indicate 184 | whether God mode is active as follows: 185 | 186 | ```emacs-lisp 187 | (defun my-god-mode-update-mode-line () 188 | (cond 189 | (god-local-mode 190 | (set-face-attribute 'mode-line nil 191 | :foreground "#604000" 192 | :background "#fff29a") 193 | (set-face-attribute 'mode-line-inactive nil 194 | :foreground "#3f3000" 195 | :background "#fff3da")) 196 | (t 197 | (set-face-attribute 'mode-line nil 198 | :foreground "#0a0a0a" 199 | :background "#d7d7d7") 200 | (set-face-attribute 'mode-line-inactive nil 201 | :foreground "#404148" 202 | :background "#efefef")))) 203 | 204 | (add-hook 'post-command-hook #'my-god-mode-update-mode-line) 205 | ``` 206 | 207 | Note that using `post-command-hook` here should not be an issue for performance. 208 | If you are concerned about performance for any reason, you can use 209 | `god-mode-enabled-hook` and `god-mode-disabled-hook`. 210 | With Emacs 27.1+, you can also use [window hooks][window-hooks]. 211 | 212 | 213 | ## `overwrite-mode` 214 | 215 | You can pause or resume God mode depending on whether `overwrite-mode` is 216 | activated as follows: 217 | 218 | ```emacs-lisp 219 | (defun my-god-mode-toggle-on-overwrite () 220 | "Toggle god-mode on overwrite-mode." 221 | (if (bound-and-true-p overwrite-mode) 222 | (god-local-mode-pause) 223 | (god-local-mode-resume))) 224 | 225 | (add-hook 'overwrite-mode-hook #'my-god-mode-toggle-on-overwrite) 226 | ``` 227 | 228 | ## `isearch` integration 229 | 230 | There is an optional feature for providing God mode behaviour in `isearch`. It 231 | allows you to hit ESC, for example, while in `isearch` to enable God 232 | mode. Here's a more complete example: 233 | 234 | s h e y ESC 235 | s s s RET → C-s 236 | h e y C-s C-s 237 | C-s RET 238 | 239 | You can load and activate this feature as follows: 240 | 241 | ```emacs-lisp 242 | (require 'god-mode-isearch) 243 | (define-key isearch-mode-map (kbd "") #'god-mode-isearch-activate) 244 | (define-key god-mode-isearch-map (kbd "") #'god-mode-isearch-disable) 245 | ``` 246 | 247 | You can also configure `god-mode-isearch-map` for additional keybindings. 248 | 249 | ## Rebinding `self-insert-command` 250 | 251 | You can rebind `self-insert-command` as you prefer. For example, here's a 252 | mapping that calls `org-self-insert-command` in `org-mode`: 253 | 254 | ```emacs-lisp 255 | (defun my-god-mode-self-insert () 256 | (interactive) 257 | (if (and (bolp) 258 | (eq major-mode 'org-mode)) 259 | (call-interactively 'org-self-insert-command) 260 | (call-interactively 'god-mode-self-insert))) 261 | 262 | (define-key god-local-mode-map [remap self-insert-command] #'my-god-mode-self-insert) 263 | ``` 264 | 265 | ## Useful key bindings 266 | 267 | For vim refugees, consider using `i` and `` to toggle god-mode off and 268 | on: 269 | 270 | ```emacs-lisp 271 | (define-key god-local-mode-map (kbd "i") #'god-local-mode) 272 | (global-set-key (kbd "") #'(lambda () (interactive) (god-local-mode 1))) 273 | ``` 274 | 275 | The following key binding is also popular: 276 | 277 | ```emacs-lisp 278 | (define-key god-local-mode-map (kbd "z") #'repeat) 279 | ``` 280 | 281 | Although I personally prefer: 282 | 283 | ```emacs-lisp 284 | (define-key god-local-mode-map (kbd ".") #'repeat) 285 | ``` 286 | 287 | These are also handy: 288 | 289 | ```emacs-lisp 290 | (global-set-key (kbd "C-x C-1") #'delete-other-windows) 291 | (global-set-key (kbd "C-x C-2") #'split-window-below) 292 | (global-set-key (kbd "C-x C-3") #'split-window-right) 293 | (global-set-key (kbd "C-x C-0") #'delete-window) 294 | 295 | (define-key god-local-mode-map (kbd "[") #'backward-paragraph) 296 | (define-key god-local-mode-map (kbd "]") #'forward-paragraph) 297 | ``` 298 | 299 | So that you can run x 1, x 300 | 2, x 3, and x 0 in God mode. 301 | 302 | ## Exempt major modes 303 | 304 | _NOTE_: This is less necessary in recent versions of God mode, as 305 | it overrides all printable single byte keys and bindings in 306 | most major modes. 307 | 308 | Sometimes, God mode is enabled in buffers where it makes no sense. In 309 | such cases, you can add the major mode to `god-exempt-major-modes`: 310 | 311 | ```emacs-lisp 312 | (add-to-list 'god-exempt-major-modes 'dired-mode) 313 | ``` 314 | 315 | Since `dired-mode` is already in the list, that's a no-op, but you get 316 | the idea. Consider opening an issue or pull request if you find a 317 | major mode that should be on the official list. 318 | 319 | Another option to control the behavior of God mode in new buffers is to provide 320 | a function with no arguments that must return non-nil if God mode should be 321 | disabled in the current buffer. See the `god-exempt-predicates` variable and its 322 | default members `god-exempt-mode-p`, `god-comint-mode-p`, `god-view-mode-p` and 323 | `god-special-mode-p` for further details. 324 | 325 | ## Usage with Evil 326 | 327 | [Evil][evil] is a popular Emacs package that provides modal editing in the style 328 | of Vi. While Evil doesn't always work well with God mode, there are a few simple 329 | customizations that enable them to be used together smoothly. 330 | 331 | * For running occasional and single commands in God mode, the built-in 332 | `god-execute-with-current-bindings` command works well with Evil without 333 | additional customization. This is quite similar to Evil's 334 | `evil-execute-in-emacs-state` command. All Evil bindings remain available when 335 | using `god-execute-with-current-bindings`. For example, executing 336 | `god-execute-with-current-bindings` and entering v will execute 337 | `evil-visual-block`, which is bound to C-v in Evil's Normal state. 338 | 339 | * For sustained usage of God mode, it's a bit trickier as keybindings in Evil 340 | states generally override God mode. For example, if God mode is activated in 341 | Normal state, entering v executes `evil-visual-char`, which is 342 | bound to v in Normal state, instead of executing 343 | `evil-visual-block`. A good option to use Evil's state-specific keybindings 344 | through God mode is to create an intercept keymap using 345 | `evil-make-intercept-map` and `god-local-mode-map`. For example, you can 346 | enable use of God mode in Normal state as follows: 347 | 348 | ```emacs-lisp 349 | (with-eval-after-load 'god-mode 350 | (evil-make-intercept-map god-local-mode-map 'normal) 351 | (add-hook 'god-local-mode-hook #'evil-normalize-keymaps)) 352 | ``` 353 | 354 | * Another option to use God mode with Evil is to use the 355 | [`evil-god-state`][evil-god-state] package, which provides a dedicated Evil 356 | state for using God mode. For running occasional, single commands through God 357 | mode, use the `evil-execute-in-god-state` command. This works similar to 358 | `god-execute-with-current-bindings`. For sustained use of God mode, use the 359 | `evil-god-state` command. `evil-god-state` is also useful for accessing 360 | default Emacs keybindings through God mode. However, a disadvantage of 361 | `evil-god-state` is that Evil's state-specific keybindings will not be 362 | available in God mode. 363 | 364 | * [`evil-god-toggle`][evil-god-toggle] is an expanded version of 365 | `evil-god-state` with features like persistence of visual selections 366 | to corresponding active regions, global `god-mode` scope, and a 367 | `god-off` which is like `emacs-state` but more easy to toggle in and 368 | out of. The ability to use a persistent `god-state` is also better 369 | documented. 370 | 371 | [useful-key-bindings]: #useful-key-bindings 372 | [key-mapping]: #key-mapping 373 | [switch-caps-lock-and-esc]: https://askubuntu.com/questions/363346/how-to-permanently-switch-caps-lock-and-esc 374 | [melpa-link]: https://melpa.org/#/god-mode 375 | [melpa-stable-link]: https://stable.melpa.org/#/god-mode 376 | [melpa-badge]: https://melpa.org/packages/god-mode-badge.svg 377 | [melpa-stable-badge]: https://stable.melpa.org/packages/god-mode-badge.svg 378 | [gh-actions-link]: https://github.com/emacsorphanage/god-mode/actions?query=workflow%3ACI+branch%3Amaster 379 | [gh-actions-badge]: https://github.com/emacsorphanage/god-mode/actions/workflows/test.yml/badge.svg?branch=master 380 | [evil]: https://github.com/emacs-evil/evil 381 | [evil-god-state]: https://github.com/gridaphobe/evil-god-state 382 | [evil-god-toggle]: https://github.com/jam1015/evil-god-toggle 383 | [window-hooks]: https://www.gnu.org/software/emacs/manual/html_node/elisp/Window-Hooks.html 384 | -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | build: 7 | runs-on: ubuntu-latest 8 | strategy: 9 | matrix: 10 | emacs_version: 11 | - 26.3 12 | - 27.2 13 | - 28.1 14 | - 28.2 15 | - 29.1 16 | - 29.2 17 | - 29.3 18 | - 29.4 19 | - snapshot 20 | include: 21 | - emacs_version: snapshot 22 | allow_failure: true 23 | steps: 24 | - uses: purcell/setup-emacs@master 25 | with: 26 | version: ${{ matrix.emacs_version }} 27 | - uses: actions/checkout@v1 28 | - uses: conao3/setup-cask@master 29 | if: steps.cache-cask-executable.outputs.cache-hit != 'true' 30 | with: 31 | version: snapshot 32 | - name: Install dependencies 33 | run: 'cask install' 34 | - name: Run tests 35 | if: matrix.allow_failure != true 36 | run: 'cask exec ecukes' 37 | - name: Run tests (allow failure) 38 | if: matrix.allow_failure == true 39 | run: 'cask exec ecukes || true' 40 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .cask 2 | .ecukes-failing-scenarios 3 | *.elc 4 | -------------------------------------------------------------------------------- /Cask: -------------------------------------------------------------------------------- 1 | (source gnu) 2 | (source melpa) 3 | 4 | (package "god-mode" "2.18.0" "God-like command entering minor mode.") 5 | 6 | (development 7 | (depends-on "ecukes") 8 | (depends-on "ansi")) 9 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /features/c-commands.feature: -------------------------------------------------------------------------------- 1 | Feature: C- commands 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert: 6 | """ 7 | laziness 8 | impatience 9 | hubris 10 | """ 11 | Then I have god-mode on 12 | 13 | Scenario: map k into kill-line 14 | Given I go to line "1" 15 | When I send the key sequence "kk" 16 | Then the buffer's contents should be: 17 | """ 18 | impatience 19 | hubris 20 | """ 21 | 22 | Scenario: map / into undo 23 | Given I go to line "1" 24 | And I send the key sequence "kk" 25 | When I send the key sequence "//" 26 | Then the buffer's contents should be: 27 | """ 28 | laziness 29 | impatience 30 | hubris 31 | """ 32 | 33 | Scenario: execute named keyboard macro 34 | Given I go to line "1" 35 | And I bind a named keyboard macro which kills line to C-c C-r 36 | When I send the key sequence "cr" 37 | Then the buffer's contents should be: 38 | """ 39 | impatience 40 | hubris 41 | """ 42 | 43 | Scenario: execute C-[god-literal-key] 44 | Given I bind "C-SPC" to "set-mark-command" 45 | And I go to beginning of buffer 46 | And I send the key sequence "SPC" 47 | And I go to end of buffer 48 | When I send the key sequence "u SPC" 49 | Then the cursor should be at point "1" 50 | 51 | Scenario: execute long sequence of literals 52 | Given I bind "C-c b e g" to "beginning-of-buffer" 53 | And I go to end of buffer 54 | When I send the key sequence "c SPC b e g" 55 | Then the cursor should be at point "1" 56 | 57 | Scenario: toggle god-literal-key 58 | Given I bind "C-c k M-l" to "beginning-of-buffer" 59 | And I go to end of buffer 60 | When I send the key sequence "c SPC k SPC g l" 61 | Then the cursor should be at point "1" 62 | 63 | Scenario: execute commands with C-arrow 64 | Given I bind "C-x C-" to "backward-word" 65 | And I go to line "1" 66 | And I go to end of line 67 | When I send the key sequence "x " 68 | Then the cursor should be at point "1" 69 | 70 | Scenario: execute commands with uppercase letters (control) 71 | Given I bind "C-S-A" to "beginning-of-buffer" 72 | And I go to end of buffer 73 | When I send the key sequence "A" 74 | Then the cursor should be at point "1" 75 | 76 | Scenario: execute commands with uppercase letters (control+meta) 77 | Given I bind "C-M-S-A" to "beginning-of-buffer" 78 | And I go to end of buffer 79 | When I send the key sequence "GA" 80 | Then the cursor should be at point "1" 81 | 82 | Scenario: execute commands with uppercase letters (meta) 83 | Given I bind "M-A" to "beginning-of-buffer" 84 | And I go to end of buffer 85 | When I send the key sequence "g A" 86 | Then the cursor should be at point "1" 87 | 88 | Scenario: execute commands with uppercase letters (combination) 89 | Given I bind "C-x C-S-A" to "beginning-of-buffer" 90 | And I go to end of buffer 91 | When I send the key sequence "xA" 92 | Then the cursor should be at point "1" 93 | 94 | Scenario: execute commands with uppercase letters (literal) 95 | Given I bind "C-c L" to "beginning-of-buffer" 96 | And I go to end of buffer 97 | When I send the key sequence "c SPC L" 98 | Then the cursor should be at point "1" 99 | 100 | Scenario: execute commands with delete (control) 101 | Given I bind "C-c C-" to "beginning-of-buffer" 102 | And I go to end of buffer 103 | When I send the key sequence "c " 104 | Then the cursor should be at point "1" 105 | 106 | Scenario: execute commands with shifted arrows (control) 107 | Given I bind "C-x C-S-" to "beginning-of-buffer" 108 | And I go to end of buffer 109 | When I send the key sequence "x S-" 110 | Then the cursor should be at point "1" 111 | 112 | Scenario: execute commands with shifted arrows (meta) 113 | Given I bind "M-S-" to "beginning-of-buffer" 114 | And I go to end of buffer 115 | When I send the key sequence "g S-" 116 | Then the cursor should be at point "1" 117 | 118 | Scenario: execute commands with shifted arrows (shift) 119 | Given I bind "C-c C-S-" to "beginning-of-buffer" 120 | And I go to end of buffer 121 | When I send the key sequence "c S-" 122 | Then the cursor should be at point "1" 123 | 124 | Scenario: execute commands with numbered function keys (literal) 125 | Given I bind "C-c " to "beginning-of-buffer" 126 | And I go to end of buffer 127 | When I send the key sequence "c SPC " 128 | Then the cursor should be at point "1" 129 | 130 | Scenario: execute commands with numbered function keys (control) 131 | Given I bind "C-c C-" to "beginning-of-buffer" 132 | And I go to end of buffer 133 | When I send the key sequence "c " 134 | Then the cursor should be at point "1" 135 | 136 | Scenario: execute commands with numbered function keys (meta) 137 | Given I bind "C-c M-" to "beginning-of-buffer" 138 | And I go to end of buffer 139 | When I send the key sequence "c g " 140 | Then the cursor should be at point "1" 141 | 142 | Scenario: execute commands with numbered function keys (control+shift) 143 | Given I bind "C-c C-S-" to "beginning-of-buffer" 144 | And I go to end of buffer 145 | When I send the key sequence "c S-" 146 | Then the cursor should be at point "1" 147 | 148 | Scenario: execute commands with shift and space (control+shift) 149 | Given I bind "C-c C-S-SPC" to "beginning-of-buffer" 150 | And I go to end of buffer 151 | When I send the key sequence "c S-SPC" 152 | Then the cursor should be at point "1" 153 | 154 | Scenario: execute commands with shift and return (control+shift) 155 | Given I bind "C-c C-S-" to "beginning-of-buffer" 156 | And I go to end of buffer 157 | When I send the key sequence "c " 158 | Then the cursor should be at point "1" 159 | 160 | Scenario: execute commands with shift and tab (control+shift) 161 | Given I bind "C-c C-S-" to "beginning-of-buffer" 162 | And I go to end of buffer 163 | When I send the key sequence "c " 164 | Then the cursor should be at point "1" 165 | 166 | Scenario: execute commands with shift and backspace (control+shift) 167 | Given I bind "C-c C-S-" to "beginning-of-buffer" 168 | And I go to end of buffer 169 | When I send the key sequence "c " 170 | Then the cursor should be at point "1" 171 | 172 | Scenario: execute commands with shift and delete (control+shift) 173 | Given I bind "C-c C-S-" to "beginning-of-buffer" 174 | And I go to end of buffer 175 | When I send the key sequence "c " 176 | Then the cursor should be at point "1" 177 | 178 | Scenario: execute commands with shift and space (meta+shift) 179 | Given I bind "M-S-SPC" to "beginning-of-buffer" 180 | And I go to end of buffer 181 | When I send the key sequence "g S-SPC" 182 | Then the cursor should be at point "1" 183 | 184 | Scenario: execute commands with shift and return (meta+shift) 185 | Given I bind "M-S-" to "beginning-of-buffer" 186 | And I go to end of buffer 187 | When I send the key sequence "g S-" 188 | Then the cursor should be at point "1" 189 | 190 | Scenario: execute commands with shift and tab (meta+shift) 191 | Given I bind "M-S-" to "beginning-of-buffer" 192 | And I go to end of buffer 193 | When I send the key sequence "g " 194 | Then the cursor should be at point "1" 195 | 196 | Scenario: execute commands with shift and backspace (meta+shift) 197 | Given I bind "M-S-" to "beginning-of-buffer" 198 | And I go to end of buffer 199 | When I send the key sequence "g S-" 200 | Then the cursor should be at point "1" 201 | 202 | Scenario: execute commands with shift and backspace (meta+shift) 203 | Given I bind "M-S-" to "beginning-of-buffer" 204 | And I go to end of buffer 205 | When I send the key sequence "g S-" 206 | Then the cursor should be at point "1" 207 | -------------------------------------------------------------------------------- /features/digit-arguments.feature: -------------------------------------------------------------------------------- 1 | Feature: Digit arguments 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert "abcdefghijklmnopqrstuvwxyz" 6 | And I have god-mode on 7 | And I go to line "1" 8 | 9 | Scenario: M-5 C-d does delete 5 times 10 | When I send the key sequence "M-5 C-d" 11 | Then the buffer's contents should be "fghijklmnopqrstuvwxyz" 12 | 13 | Scenario: 5d does delete 5 times 14 | When I send the key sequence "5d" 15 | Then the buffer's contents should be "fghijklmnopqrstuvwxyz" 16 | -------------------------------------------------------------------------------- /features/execute-with-current-bindings.feature: -------------------------------------------------------------------------------- 1 | Feature: Execute with current bindings 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And I bind "C-e" to "god-execute-with-current-bindings" 5 | And the buffer is empty 6 | And I insert "abcdefghijkl" 7 | And I go to beginning of buffer 8 | 9 | Scenario: no effect when already in God mode 10 | Given I have god-mode on 11 | When I send the key sequence "C-e q Z" 12 | Then the buffer's contents should be "Zabcdefghijkl" 13 | And god-mode is enabled 14 | 15 | Scenario: runs one command in God mode 16 | Given I am in insertion mode 17 | When I send the key sequence "C-e q Z" 18 | Then the buffer's contents should be "Zabcdefghijkl" 19 | And god-mode is disabled 20 | 21 | Scenario: handles prefix arguments 22 | Given I am in insertion mode 23 | When I send the key sequence "C-u 1 C-e 0 f" 24 | Then the cursor should be at point "11" 25 | -------------------------------------------------------------------------------- /features/insertion-mode.feature: -------------------------------------------------------------------------------- 1 | Feature: Insertion mode 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I am in insertion mode 6 | 7 | Scenario: C-u u inserts u 4 times 8 | When I send the key sequence "C-u u" 9 | Then the buffer's contents should be "uuuu" 10 | 11 | Scenario: C-u C-u u inserts u 16 times 12 | When I send the key sequence "C-u C-u u" 13 | Then the buffer's contents should be "uuuuuuuuuuuuuuuu" 14 | -------------------------------------------------------------------------------- /features/last-command-event.feature: -------------------------------------------------------------------------------- 1 | Feature: Prefix arguments 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert "abcdefghijklmnopqrstuvwxyz" 6 | And I have god-mode on 7 | And I go to line "1" 8 | 9 | Scenario: M-4 C-d does delete 4 times 10 | When I send the key sequence "M-4 C-d" 11 | Then the buffer's contents should be "efghijklmnopqrstuvwxyz" 12 | 13 | Scenario: g4d does delete 4 times 14 | When I send the key sequence "g4d" 15 | Then the buffer's contents should be "efghijklmnopqrstuvwxyz" 16 | -------------------------------------------------------------------------------- /features/predicates-disable.feature: -------------------------------------------------------------------------------- 1 | Feature: Predicate based disable 2 | Background: 3 | Given god-mode is enabled for all buffers 4 | And I am in buffer "god-mode-test" 5 | And I describe function "god-mode" 6 | And I grep current directory 7 | And I start ielm 8 | 9 | Scenario: God mode is automatically enabled for fundamental-mode 10 | When I switch to buffer "god-mode-test" 11 | Then god-mode is enabled 12 | 13 | Scenario: God mode is disabled for help-mode (a special derived mode) 14 | When I switch to buffer "*Help*" 15 | Then god-mode is disabled 16 | 17 | Scenario: God mode is disabled for grep-mode (an explicitly disabled mode) 18 | When I switch to buffer "*grep*" 19 | Then god-mode is disabled 20 | 21 | Scenario: God mode is disabled in buffers with view-mode 22 | When I open a view-mode buffer 23 | Then god-mode is disabled 24 | 25 | Scenario: God mode is disabled in comint derived buffers 26 | When I switch to buffer "*ielm*" 27 | Then god-mode is disabled 28 | 29 | Scenario: God mode is disabled in mode-class special buffers 30 | When I open a test-special-mode buffer 31 | Then god-mode is disabled 32 | -------------------------------------------------------------------------------- /features/prefix-arguments.feature: -------------------------------------------------------------------------------- 1 | Feature: Prefix arguments 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert "abcdefghijklmnopqrstuvwxyz" 6 | And I have god-mode on 7 | And I go to line "1" 8 | 9 | Scenario: C-u C-d does delete 4 times 10 | When I send the key sequence "C-u C-d" 11 | Then the buffer's contents should be "efghijklmnopqrstuvwxyz" 12 | 13 | Scenario: ud does delete 4 times 14 | When I send the key sequence "ud" 15 | Then the buffer's contents should be "efghijklmnopqrstuvwxyz" 16 | 17 | Scenario: C-u C-u C-d does delete 16 times 18 | When I send the key sequence "C-u C-u C-d" 19 | Then the buffer's contents should be "qrstuvwxyz" 20 | 21 | Scenario: uud does delete 16 times 22 | When I send the key sequence "uud" 23 | Then the buffer's contents should be "qrstuvwxyz" 24 | -------------------------------------------------------------------------------- /features/prefix-help.feature: -------------------------------------------------------------------------------- 1 | Feature: Prefix help 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I have god-mode on 6 | And I bind "C-c C-e" to "end-of-line" 7 | And I bind "M-s C-e" to "end-of-line" 8 | 9 | Scenario: shows help on entering C-h (control) 10 | When I send the key sequence "C-c C-h" 11 | Then there is a "*Help*" buffer 12 | 13 | Scenario: help buffer shows relevant bindings (control) 14 | Given I send the key sequence "C-c C-h" 15 | When I switch to buffer "*Help*" 16 | Then the buffer's contents should contain "Major Mode Bindings Starting With C-c:" 17 | And the buffer's contents should contain "Global Bindings Starting With C-c:" 18 | 19 | Scenario: shows help on entering C-h (meta) 20 | When I send the key sequence "M-s C-h" 21 | Then there is a "*Help*" buffer 22 | 23 | Scenario: help buffer shows relevant bindings (meta) 24 | Given I send the key sequence "M-s C-h" 25 | When I switch to buffer "*Help*" 26 | Then the buffer's contents should contain "Major Mode Bindings Starting With M-s:" 27 | And the buffer's contents should contain "Global Bindings Starting With M-s:" 28 | -------------------------------------------------------------------------------- /features/regions.feature: -------------------------------------------------------------------------------- 1 | Feature: Regions 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert "Here we go" 6 | And I have god-mode on 7 | And I go to beginning of buffer 8 | And I set the mark 9 | 10 | Scenario: mark is preserved (control) 11 | When I send the key sequence "f" 12 | Then the region should be "H" 13 | 14 | Scenario: mark is preserved (meta) 15 | When I send the key sequence "gf" 16 | Then the region should be "Here" 17 | 18 | Scenario: mark is preserved (control+meta) 19 | When I send the key sequence "gfGf" 20 | Then the region should be "Here we" 21 | -------------------------------------------------------------------------------- /features/repeat.feature: -------------------------------------------------------------------------------- 1 | Feature: Repeat 2 | Background: 3 | Given I am in buffer "god-mode-test" 4 | And the buffer is empty 5 | And I insert "abcdefghijklmnopqrstuvwxyz one two three" 6 | And I have god-mode on 7 | And I go to line "1" 8 | 9 | Scenario: M-5 C-d C-x z does delete 5 times then 5 more times 10 | When I send the key sequence "M-5 C-d C-x z" 11 | Then the buffer's contents should be "klmnopqrstuvwxyz one two three" 12 | 13 | Scenario: 5dx z does delete 5 times then 5 more times 14 | When I send the key sequence "5dx SPC z" 15 | Then the buffer's contents should be "klmnopqrstuvwxyz one two three" 16 | 17 | Scenario: M-f C-x z M-d deletes the second word 18 | When I send the key sequence "M-f C-x z M-d" 19 | Then the buffer's contents should be "abcdefghijklmnopqrstuvwxyz one three" 20 | 21 | Scenario: gfx zgd deletes the second word 22 | When I send the key sequence "gfx SPC zgd" 23 | Then the buffer's contents should be "abcdefghijklmnopqrstuvwxyz one three" 24 | -------------------------------------------------------------------------------- /features/step-definitions/god-mode-steps.el: -------------------------------------------------------------------------------- 1 | ;; This file contains your project specific step definitions. All 2 | ;; files in this directory whose names end with "-steps.el" will be 3 | ;; loaded automatically by Ecukes. 4 | 5 | (require 'seq) 6 | 7 | (Given "^I bind a named keyboard macro which kills line to C-c C-r$" 8 | (lambda () 9 | (fset 'god-mode-test-keyboard-macro 10 | "\C-a\C-k\C-k") 11 | (global-set-key (kbd "C-c C-r") 'god-mode-test-keyboard-macro))) 12 | 13 | (Given "^I bind \"\\([^\"]+\\)\" to \"\\([^\"]+\\)\"" 14 | (lambda (key cmd) 15 | (local-set-key (kbd key) (intern cmd)))) 16 | 17 | (Given "^god-mode is enabled for all buffers$" 18 | (lambda () 19 | (when (not god-global-mode) 20 | (god-mode)))) 21 | 22 | (Given "^I describe function \"\\(.+\\)\"$" 23 | (lambda (fn) 24 | (describe-function (intern fn)))) 25 | 26 | (Given "^I grep current directory" 27 | (lambda () 28 | (set-process-query-on-exit-flag 29 | (get-buffer-process (grep "grep -Rin god .")) 30 | nil))) 31 | 32 | (Given "^I open a view-mode buffer" 33 | (lambda () 34 | (set-buffer (get-buffer-create "*view-mode-buffer*")) 35 | (view-mode) 36 | (god-local-mode 0) 37 | (god-mode-maybe-activate))) 38 | 39 | (Given "^I open a test-special-mode buffer" 40 | (lambda () 41 | (set-buffer (get-buffer-create "*test-special-mode*")) 42 | (test-special-mode))) 43 | 44 | (Given "^I start ielm$" 45 | (lambda () 46 | (require 'ielm) 47 | (ielm))) 48 | 49 | (When "I send the key sequence \"\\(.+\\)\"" 50 | (lambda (keys) 51 | (execute-kbd-macro (kbd keys)))) 52 | 53 | (Then "^god-mode is enabled$" 54 | (lambda () 55 | (cl-assert (not (null god-local-mode))))) 56 | 57 | (Then "^god-mode is disabled$" 58 | (lambda () 59 | (cl-assert (null god-local-mode)))) 60 | 61 | (Then "^I have god-mode on$" 62 | "Turn god-mode on." 63 | (lambda () 64 | (god-local-mode 1))) 65 | 66 | (Then "^I am in insertion mode$" 67 | "Turn god-mode off." 68 | (lambda () 69 | (god-local-mode -1))) 70 | 71 | (Then "^there is a \"\\([^\"]+\\)\" buffer$" 72 | (lambda (name) 73 | (cl-assert 74 | (seq-filter (lambda (b) (string-prefix-p name (buffer-name b))) 75 | (buffer-list))))) 76 | 77 | (Then "^the buffer's contents should be\\(?: \"\\(.+\\)\"\\|:\\)$" 78 | "Asserts that the current buffer includes some text. 79 | 80 | Examples: 81 | - Then the buffer's contents should be \"CONTENTS\" 82 | - Then the buffer's contents should be: 83 | \"\"\" 84 | CONTENTS 85 | \"\"\"" 86 | (lambda (expected) 87 | (let ((actual (buffer-string)) 88 | (message "Expected buffer's contents to be '%s', but was '%s'")) 89 | (cl-assert (s-equals? expected actual) nil message expected actual)))) 90 | 91 | (Then "^the buffer's contents should contain\\(?: \"\\(.+\\)\"\\|:\\)$" 92 | "Asserts that the current buffer contains some text. 93 | 94 | Examples: 95 | - Then the buffer's contents should contain \"CONTENTS\" 96 | - Then the buffer's contents should contain: 97 | \"\"\" 98 | CONTENTS 99 | \"\"\"" 100 | (lambda (expected) 101 | (let ((actual (buffer-string)) 102 | (message "Expected buffer's contents to contain '%s', but was '%s'")) 103 | (cl-assert (s-contains? expected actual) nil message expected actual)))) 104 | -------------------------------------------------------------------------------- /features/support/env.el: -------------------------------------------------------------------------------- 1 | (require 'f) 2 | (require 'cl-lib) 3 | 4 | (defvar god-mode-support-path 5 | (f-dirname load-file-name)) 6 | 7 | (defvar god-mode-features-path 8 | (f-parent god-mode-support-path)) 9 | 10 | (defvar god-mode-root-path 11 | (f-parent god-mode-features-path)) 12 | 13 | (add-to-list 'load-path god-mode-root-path) 14 | 15 | (define-derived-mode test-special-mode fundamental-mode "Test" 16 | "This mode is marked special via its mode class rather than 17 | through inheritance.") 18 | 19 | (put 'test-special-mode 'mode-class 'special) 20 | 21 | (require 'god-mode) 22 | (require 'espuds) 23 | 24 | (Setup 25 | ;; Before anything has run 26 | ) 27 | 28 | (Before 29 | ;; Before each scenario is run 30 | ) 31 | 32 | (After 33 | ;; After each scenario is run 34 | ) 35 | 36 | (Teardown 37 | ;; After when everything has been run 38 | ) 39 | -------------------------------------------------------------------------------- /god-mode-isearch.el: -------------------------------------------------------------------------------- 1 | ;;; god-mode-isearch.el --- God mode behaviour for isearch -*- lexical-binding: t; -*- 2 | 3 | ;; Copyright (C) 2014 Chris Done 4 | ;; Copyright (C) 2020 Akhil Wali 5 | 6 | ;; Author: Chris Done 7 | ;; URL: https://github.com/emacsorphanage/god-mode 8 | ;; Version: 2.18.0 9 | ;; Package-Requires: ((emacs "26.3")) 10 | 11 | ;; This file is free software; you can redistribute it and/or modify 12 | ;; it under the terms of the GNU General Public License as published by 13 | ;; the Free Software Foundation; either version 3, or (at your option) 14 | ;; any later version. 15 | 16 | ;; This file is distributed in the hope that it will be useful, 17 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of 18 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 | ;; GNU General Public License for more details. 20 | 21 | ;; You should have received a copy of the GNU General Public License 22 | ;; along with this program. If not, see . 23 | 24 | ;;; Commentary: 25 | 26 | ;; Global minor mode for entering Emacs commands without modifier keys. 27 | 28 | ;;; Code: 29 | 30 | ;; Recommended use: 31 | 32 | ;; (define-key isearch-mode-map (kbd "") 'god-mode-isearch-activate) 33 | ;; (define-key god-mode-isearch-map (kbd "") 'god-mode-isearch-disable) 34 | 35 | (defvar god-mode-isearch-map 36 | (let ((map (copy-keymap isearch-mode-map))) 37 | (define-key map (kbd "s") 'isearch-repeat-forward) 38 | (define-key map (kbd "r") 'isearch-repeat-backward) 39 | (define-key map (kbd "w") 'isearch-yank-word-or-char) 40 | map) 41 | "Keymap for modal isearch.") 42 | 43 | (defun god-mode-isearch-activate () 44 | "Activate God mode in the isearch buffer." 45 | (interactive) 46 | (setq overriding-terminal-local-map god-mode-isearch-map)) 47 | 48 | (defun god-mode-isearch-disable () 49 | "Deactivate God mode in the isearch buffer." 50 | (interactive) 51 | (setq overriding-terminal-local-map isearch-mode-map)) 52 | 53 | (provide 'god-mode-isearch) 54 | 55 | ;;; god-mode-isearch.el ends here 56 | -------------------------------------------------------------------------------- /god-mode.el: -------------------------------------------------------------------------------- 1 | ;;; god-mode.el --- Minor mode for God-like command entering -*- lexical-binding: t; -*- 2 | 3 | ;; Copyright (C) 2013 Chris Done 4 | ;; Copyright (C) 2013 Magnar Sveen 5 | ;; Copyright (C) 2013 Rüdiger Sonderfeld 6 | ;; Copyright (C) 2013 Dillon Kearns 7 | ;; Copyright (C) 2013 Fabián Ezequiel Gallina 8 | ;; Copyright (C) 2020 Akhil Wali 9 | 10 | ;; Author: Chris Done 11 | ;; URL: https://github.com/emacsorphanage/god-mode 12 | ;; Version: 2.18.0 13 | ;; Package-Requires: ((emacs "26.3")) 14 | 15 | ;; This file is not part of GNU Emacs. 16 | 17 | ;; This file is free software; you can redistribute it and/or modify 18 | ;; it under the terms of the GNU General Public License as published by 19 | ;; the Free Software Foundation; either version 3, or (at your option) 20 | ;; any later version. 21 | 22 | ;; This file is distributed in the hope that it will be useful, 23 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of 24 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 | ;; GNU General Public License for more details. 26 | 27 | ;; You should have received a copy of the GNU General Public License 28 | ;; along with GNU Emacs; see the file COPYING. If not, write to 29 | ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 30 | ;; Boston, MA 02110-1301, USA. 31 | 32 | ;;; Commentary: 33 | 34 | ;; Global minor mode for entering Emacs commands without modifier keys. 35 | 36 | ;;; Code: 37 | 38 | (require 'cl-lib) 39 | 40 | (add-hook 'after-change-major-mode-hook 'god-mode-maybe-activate) 41 | 42 | (defvar god-local-mode-paused nil) 43 | (make-variable-buffer-local 'god-local-mode-paused) 44 | 45 | ;; DEPRECATED 46 | (defvaralias 'god-mod-alist 'god-mode-alist 47 | "Alias of `god-mode-alist' for backward compatibility. 48 | Use `god-mode-alist' instead.") 49 | (make-obsolete 'god-mod-alist 'god-mode-alist "2.16.1") 50 | 51 | (defcustom god-mode-alist 52 | '((nil . "C-") 53 | ("g" . "M-") 54 | ("G" . "C-M-")) 55 | "List of keys and their associated modifer." 56 | :group 'god 57 | :type '(alist)) 58 | 59 | (defcustom god-literal-key 60 | "SPC" 61 | "The key used for literal interpretation." 62 | :group 'god 63 | :type 'string) 64 | 65 | (defcustom god-exempt-major-modes 66 | '(Custom-mode 67 | Info-mode 68 | ag-mode 69 | calculator-mode 70 | calendar-mode 71 | cider-test-report-mode 72 | compilation-mode 73 | debugger-mode 74 | dired-mode 75 | edebug-mode 76 | ediff-mode 77 | eww-mode 78 | geben-breakpoint-list-mode 79 | git-commit-mode ; For versions prior to Magit 2.1.0 80 | grep-mode 81 | ibuffer-mode 82 | magit-popup-mode 83 | org-agenda-mode 84 | pdf-outline-buffer-mode 85 | recentf-dialog-mode 86 | sldb-mode 87 | sly-db-mode 88 | vc-annotate-mode 89 | wdired-mode) 90 | "List of major modes that should not start with `god-local-mode' enabled." 91 | :group 'god 92 | :type '(repeat symbol)) 93 | 94 | (defcustom god-exempt-predicates 95 | (list #'god-exempt-mode-p 96 | #'god-comint-mode-p 97 | #'god-git-commit-mode-p 98 | #'god-view-mode-p 99 | #'god-special-mode-p) 100 | "List of predicates checked before enabling `god-local-mode'. 101 | All predicates must return nil for `god-local-mode' to start." 102 | :group 'god 103 | :type '(repeat function)) 104 | 105 | (defcustom god-mode-enable-function-key-translation t 106 | "Enables translation of function keys to use modifier keys. 107 | For example, if this variable is non-nil, then entering `' 108 | in God mode will be translated to `C-'." 109 | :group 'god 110 | :type 'boolean) 111 | 112 | (defcustom god-mode-lighter-string 113 | "God" 114 | "String displayed on the mode line when God mode is active. 115 | Set it to nil if you don't want a mode line indicator." 116 | :group 'god 117 | :type '(choice string (const :tag "None" nil))) 118 | 119 | (defface god-mode-lighter 120 | '((t)) 121 | "Face for God mode's lighter." 122 | :group 'god) 123 | 124 | (defun god-mode-make-f-key (n &optional shift) 125 | "Get the event for numbered function key N, with shift status SHIFT. 126 | For example, calling with arguments 5 and t yields the symbol `S-f5'." 127 | (intern (format "%sf%d" (if shift "S-" "") n))) 128 | 129 | (defvar god-local-mode-map 130 | (let ((map (make-sparse-keymap))) 131 | (suppress-keymap map t) 132 | (define-key map [remap self-insert-command] 'god-mode-self-insert) 133 | (let ((i ?\s)) 134 | (while (< i 256) 135 | (define-key map (vector i) 'god-mode-self-insert) 136 | (setq i (1+ i)))) 137 | (when god-mode-enable-function-key-translation 138 | (dotimes (i 35) 139 | (define-key map (vector (god-mode-make-f-key (1+ i))) 'god-mode-self-insert) 140 | (define-key map (vector (god-mode-make-f-key (1+ i) t)) 'god-mode-self-insert))) 141 | (define-key map (kbd "DEL") nil) 142 | (define-key map (kbd "C-h k") #'god-mode-describe-key) 143 | map)) 144 | 145 | ;;;###autoload 146 | (define-minor-mode god-local-mode 147 | "Minor mode for running commands." 148 | :init-value nil 149 | :lighter (god-mode-lighter-string 150 | ((" " 151 | (:propertize god-mode-lighter-string face god-mode-lighter)))) 152 | :keymap god-local-mode-map 153 | (if god-local-mode 154 | (run-hooks 'god-mode-enabled-hook) 155 | (run-hooks 'god-mode-disabled-hook))) 156 | 157 | (defun god-local-mode-pause () 158 | "Pause `god-local-mode' if it is enabled. 159 | See also `god-local-mode-resume'." 160 | (when god-local-mode 161 | (god-local-mode -1) 162 | (setq god-local-mode-paused t))) 163 | 164 | (defun god-local-mode-resume () 165 | "Re-enable `god-local-mode'. 166 | If it was not active when `god-local-mode-pause' was called, nothing happens." 167 | (when (bound-and-true-p god-local-mode-paused) 168 | (setq god-local-mode-paused nil) 169 | (god-local-mode 1))) 170 | 171 | (defvar god-global-mode nil 172 | "Enable `god-local-mode' on all buffers.") 173 | 174 | (defvar god-literal-sequence nil 175 | "Toggled when `god-literal-key' is pressed in a command sequence.") 176 | 177 | ;;;###autoload 178 | (defun god-mode () 179 | "Toggle global `god-local-mode'." 180 | (interactive) 181 | (setq god-global-mode (not god-global-mode)) 182 | (if god-global-mode 183 | (god-local-mode 1) 184 | (god-local-mode -1))) 185 | 186 | ;;;###autoload 187 | (defun god-mode-all (&optional arg) 188 | "Toggle `god-local-mode' in all buffers. 189 | 190 | Toggle the mode if ARG is nil. If ARG is non-nil, enable the mode 191 | if ARG is zero or a positive number, or disable the mode if ARG 192 | is a negative number." 193 | (interactive) 194 | (let ((new-status 195 | (cond 196 | ((null arg) (if (bound-and-true-p god-local-mode) -1 1)) 197 | ((> 0 arg) -1) 198 | (t 1)))) 199 | (setq god-global-mode t) 200 | (mapc (lambda (buffer) 201 | (with-current-buffer buffer 202 | (god-mode-activate new-status))) 203 | (buffer-list)) 204 | (setq god-global-mode (= new-status 1)))) 205 | 206 | (defun god-mode-maybe-universal-argument-more () 207 | "If `god-local-mode' is enabled, call `universal-argument-more'." 208 | (interactive) 209 | (if god-local-mode 210 | (call-interactively #'universal-argument-more) 211 | (let ((binding (god-mode-lookup-command "u"))) 212 | (if (commandp binding t) 213 | (call-interactively binding) 214 | (execute-kbd-macro binding))))) 215 | 216 | (define-key universal-argument-map (kbd "u") 217 | #'god-mode-maybe-universal-argument-more) 218 | 219 | (defun god-mode-self-insert () 220 | "Handle self-insert keys." 221 | (interactive) 222 | (let* ((initial-key (aref (this-command-keys-vector) 223 | (- (length (this-command-keys-vector)) 1))) 224 | (binding (god-mode-lookup-key-sequence initial-key))) 225 | (when binding 226 | ;; For now, set the shift-translation status only for alphabetic keys. 227 | (when (god-mode-upper-p initial-key) 228 | (setq this-command-keys-shift-translated t)) 229 | (setq this-original-command binding) 230 | (setq this-command binding) 231 | ;; `real-this-command' is used by emacs to populate 232 | ;; `last-repeatable-command', which is used by `repeat'. 233 | (setq real-this-command binding) 234 | (setq god-literal-sequence nil) 235 | (if (commandp binding t) 236 | (call-interactively binding) 237 | (execute-kbd-macro binding))))) 238 | 239 | (defun god-mode-upper-p (key) 240 | "Check if KEY is an upper case character not present in `god-mode-alist'." 241 | (and (characterp key) 242 | (not (member (char-to-string key) (mapcar #'car god-mode-alist))) 243 | (>= key ?A) 244 | (<= key ?Z))) 245 | 246 | (defun god-mode-lookup-key-sequence (&optional key key-string-so-far) 247 | "Lookup the command for the given KEY (or the next keypress, if KEY is nil). 248 | This function sometimes recurses. 249 | KEY-STRING-SO-FAR should be nil for the first call in the sequence." 250 | (interactive) 251 | (let ((sanitized-key 252 | (god-mode-sanitized-key-string 253 | (or key (read-event key-string-so-far))))) 254 | (god-mode-lookup-command 255 | (god-key-string-after-consuming-key sanitized-key key-string-so-far)))) 256 | 257 | (defvar god-mode-sanitized-key-alist 258 | (append 259 | '((tab . "TAB") 260 | (?\ . "SPC") 261 | (left . "") 262 | (right . "") 263 | (up . "") 264 | (down . "") 265 | (prior . "") 266 | (next . "") 267 | (backspace . "DEL") 268 | ;; FIXME delete key is not picked up `god-mode-self-insert'. 269 | (delete . "") 270 | (return . "RET") 271 | (S-iso-lefttab . "") 272 | ;; Use key code for S-SPC 273 | (33554464 . "S-SPC") 274 | (S-left . "S-") 275 | (S-right . "S-") 276 | (S-up . "S-") 277 | (S-down . "S-") 278 | (S-backspace . "") 279 | (S-delete . "") 280 | (S-return . "")) 281 | ;; f1..f35 and S-f1..S-f35 282 | (cl-mapcan (lambda (i) 283 | (list (cons (god-mode-make-f-key i) (format "" i)) 284 | (cons (god-mode-make-f-key i t) (format "S-" i)))) 285 | (number-sequence 1 35))) 286 | "Association list mapping special events to their textual representations.") 287 | 288 | (defun god-mode-sanitized-key-string (key) 289 | "Convert any special events in KEY to textual representation." 290 | (or (cdr (assq key god-mode-sanitized-key-alist)) 291 | (char-to-string key))) 292 | 293 | (defun god-mode-help-char-dispatch (_help-key key-string-so-far) 294 | "Invokes `prefix-help-command' by entering the key sequence KEY-STRING-SO-FAR 295 | followed by the `help-char' key. 296 | HELP-KEY contains the key that caused `god-mode-help-char-dispatch' to be called 297 | from the command loop." 298 | ;; Adding an element (t . key) to `unread-command-events' will add key to 299 | ;; the current command's key sequence. 300 | (setq unread-command-events 301 | (cl-loop for key in (append (read-kbd-macro key-string-so-far t) 302 | (list help-char)) 303 | collect (cons t key))) 304 | ;; Return nil so that `god-mode-lookup-command' doesn't perform any action. 305 | nil) 306 | 307 | (defun god-key-string-after-consuming-key (key key-string-so-far) 308 | "Interpret god-mode special keys for KEY. 309 | Consumes more keys if appropriate. 310 | Appends to key sequence KEY-STRING-SO-FAR." 311 | (let ((modifier "") 312 | (next-key (lambda () (god-mode-sanitized-key-string (read-event key-string-so-far))))) 313 | (message key-string-so-far) 314 | (when key-string-so-far ; Don't check for `god-literal-key' with the first key. 315 | (while (string= key god-literal-key) 316 | (setq god-literal-sequence (not god-literal-sequence) 317 | key (funcall next-key)))) 318 | (unless god-literal-sequence 319 | (let ((modifier-lookup (and (stringp key) (assoc key god-mode-alist)))) 320 | (if modifier-lookup 321 | (setq modifier (cdr modifier-lookup) 322 | key (funcall next-key)) 323 | (setq modifier (cdr (assoc nil god-mode-alist)))))) 324 | (if (and key-string-so-far (string= key (format "%c" help-char))) 325 | (god-mode-help-char-dispatch key key-string-so-far) 326 | (when (and (= (length key) 1) 327 | (string= (get-char-code-property (aref key 0) 'general-category) "Lu") 328 | ;; If C- is part of the modifier, S- needs to be given 329 | ;; in order to distinguish the uppercase from the 330 | ;; lowercase bindings. If C- is not in the modifier, 331 | ;; then emacs natively treats uppercase differently 332 | ;; from lowercase, and the S- modifier should not be 333 | ;; supplied. 334 | (string-prefix-p "C-" modifier)) 335 | (setq modifier (concat modifier "S-"))) 336 | (if key-string-so-far 337 | (concat key-string-so-far " " modifier key) 338 | (concat modifier key))))) 339 | 340 | (defun god-mode-lookup-command (key-string) 341 | "Execute extended keymaps in KEY-STRING, or call it if it is a command." 342 | (when key-string 343 | (let* ((key-vector (read-kbd-macro key-string t)) 344 | (binding (key-binding key-vector))) 345 | (cond ((commandp binding) 346 | (setq last-command-event (aref key-vector (- (length key-vector) 1))) 347 | binding) 348 | ((keymapp binding) 349 | (god-mode-lookup-key-sequence nil key-string)) 350 | (:else 351 | (error "God: Unknown key binding for `%s`" key-string)))))) 352 | 353 | ;;;###autoload 354 | (defun god-mode-maybe-activate (&optional status) 355 | "Activate `god-local-mode' on individual buffers when appropriate. 356 | STATUS is passed as an argument to `god-mode-activate'." 357 | (when (not (minibufferp)) 358 | (god-mode-activate status))) 359 | 360 | (defun god-mode-activate (&optional status) 361 | "Activate `god-local-mode' on individual buffers when appropriate. 362 | STATUS is passed as an argument to `god-local-mode'." 363 | (when (and god-global-mode 364 | (god-passes-predicates-p)) 365 | (god-local-mode (if status status 1)))) 366 | 367 | (defun god-exempt-mode-p () 368 | "Return non-nil if `major-mode' is exempt. 369 | Members of the `god-exempt-major-modes' list are exempt." 370 | (memq major-mode god-exempt-major-modes)) 371 | 372 | (defun god-mode-child-of-p (mode parent-mode) 373 | "Return non-nil if MODE is derived from PARENT-MODE." 374 | (let ((parent (get mode 'derived-mode-parent))) 375 | (cond ((eq parent parent-mode)) 376 | ((not (null parent)) 377 | (god-mode-child-of-p parent parent-mode)) 378 | (t nil)))) 379 | 380 | (defun god-comint-mode-p () 381 | "Return non-nil if `major-mode' is derived from `comint-mode'." 382 | (god-mode-child-of-p major-mode 'comint-mode)) 383 | 384 | (defun god-special-mode-p () 385 | "Return non-nil if `major-mode' is special or derived from `special-mode'." 386 | (eq (get major-mode 'mode-class) 'special)) 387 | 388 | (defun god-view-mode-p () 389 | "Return non-nil if variable `view-mode' is non-nil in current buffer." 390 | view-mode) 391 | 392 | (defun god-git-commit-mode-p () 393 | "Return non-nil if a `git-commit-mode' will be enabled in this buffer." 394 | (and (bound-and-true-p global-git-commit-mode) 395 | ;; `git-commit-filename-regexp' defined in the same library as 396 | ;; `global-git-commit-mode'. Expression above maybe evaluated 397 | ;; to true because of autoload cookie. So we perform 398 | ;; additional check. 399 | (boundp 'git-commit-filename-regexp) 400 | buffer-file-name 401 | (string-match-p git-commit-filename-regexp buffer-file-name))) 402 | 403 | (defun god-passes-predicates-p () 404 | "Return non-nil if all `god-exempt-predicates' return nil." 405 | (not 406 | (catch 'disable 407 | (let ((preds god-exempt-predicates)) 408 | (while preds 409 | (when (funcall (car preds)) 410 | (throw 'disable t)) 411 | (setq preds (cdr preds))))))) 412 | 413 | ;;;###autoload 414 | (defun god-execute-with-current-bindings (&optional called-interactively) 415 | "Execute a single command from God mode, preserving current keybindings. 416 | 417 | This command activates God mode temporarily, and deactivates God 418 | mode as soon as the next command is run. Prefix arguments do not 419 | count as commands for this purpose, and do not cause God mode to 420 | exit. Moreover, any prefix argument that exists at the time of 421 | this command's invocation is passed along to the next command. 422 | 423 | Unlike normal use of God mode, this command makes available all 424 | keybindings that were active at the time of its invocation, 425 | including keybindings that are normally invisible to God mode, 426 | such as those in `emulation-mode-map-alists' or text overlay 427 | properties. This makes it suitable for use with packages like 428 | Evil that utilize such higher-priority keymaps. (See Info 429 | node `(elisp)Active Keymaps' for technical details on keymap 430 | precedence. For an alternative to this command, check out the 431 | evil-god-state package, available on MELPA.) 432 | 433 | This command has no effect when called from within God mode. 434 | 435 | For interactive use only. CALLED-INTERACTIVELY is a dummy 436 | parameter to help enforce this restriction." 437 | (interactive "d") 438 | (if called-interactively 439 | (unless god-local-mode 440 | (message "Switched to God mode for the next command ...") 441 | (letrec ((caller this-command) 442 | (buffer (current-buffer)) 443 | (cleanup 444 | (lambda () 445 | ;; Perform cleanup in original buffer even if the command 446 | ;; switched buffers. 447 | (if (buffer-live-p buffer) 448 | (with-current-buffer buffer 449 | (unwind-protect (god-local-mode 0) 450 | (remove-hook 'post-command-hook post-hook))) 451 | (remove-hook 'post-command-hook post-hook)))) 452 | (kill-transient-map 453 | (set-transient-map 454 | god-local-mode-map 'god-prefix-command-p cleanup)) 455 | (post-hook 456 | (lambda () 457 | (unless (and 458 | (eq this-command caller) 459 | ;; If we've entered the minibuffer, this implies 460 | ;; a non-prefix command was run, even if 461 | ;; `this-command' has not changed. For example, 462 | ;; `execute-extended-command' behaves this way. 463 | (not (window-minibuffer-p))) 464 | (funcall kill-transient-map))))) 465 | (add-hook 'post-command-hook post-hook) 466 | ;; Pass the current prefix argument along to the next command. 467 | (setq prefix-arg current-prefix-arg) 468 | ;; Technically we don't need to activate God mode since the 469 | ;; transient keymap is already in place, but it's useful to provide 470 | ;; a mode line lighter and run any hook functions the user has set 471 | ;; up. This could be made configurable in the future. 472 | (god-local-mode 1))) 473 | (error "This function should only be called interactively"))) 474 | 475 | (defun god-prefix-command-p () 476 | "Return non-nil if the current command is a \"prefix\" command. 477 | This includes prefix arguments and any other command that should 478 | be ignored by `god-execute-with-current-bindings'." 479 | (memq this-command '(god-mode-self-insert 480 | digit-argument 481 | negative-argument 482 | universal-argument 483 | universal-argument-more))) 484 | 485 | 486 | (defvar god-latest-described-command nil 487 | "The latest command recorded by `god-mode-describe-key'.") 488 | 489 | (defun god-mode--help-fn-describe-function (_arg) 490 | "Insert information about `god-mode' key-bindings for the described function. 491 | The argument _ARG is ignored: it's only needed because all hooks in 492 | `help-fns-describe-function-functions' take the function-name as argument. 493 | But in our case it's redundant" 494 | (insert 495 | (format-message "\n %s\n %s%s\n %s%s%s\n\n" 496 | "(`god-local-mode' is enabled. " 497 | " The given key-sequence: " 498 | (god-mode-get-described-key-seq) 499 | " corresponds to this key-binding: " 500 | (if (> emacs-major-version 27) 501 | (help--key-description-fontified 502 | god-latest-described-command) 503 | god-latest-described-command) 504 | ")"))) 505 | 506 | (defun god-mode-get-described-key-seq () 507 | "Return the keys that were pressed after `god-mode-describe-key' was called." 508 | (let* ((latest-keys (recent-keys 'include-cmds)) 509 | (latest-describe-key-index 510 | (cl-position '(nil . god-mode-self-insert) 511 | latest-keys :from-end t :test #'equal)) 512 | (start-index (+ 3 latest-describe-key-index)) 513 | (key-sequence (key-description (seq-subseq latest-keys start-index)))) 514 | (if (> emacs-major-version 27) 515 | (propertize key-sequence 516 | 'font-lock-face 'help-key-binding 517 | 'face 'help-key-binding) 518 | key-sequence))) 519 | 520 | (defun god-mode-describe-key () 521 | "Describe a key-sequence as interpreted by `god-mode'. 522 | Prompt for a key sequence, use `god-mode-lookup-key-sequence' to translate it 523 | into the appropriate command, and use `describe-function' to describe it" 524 | (interactive) 525 | (message "Describe the following god-mode key: ") 526 | (advice-add #'god-mode-lookup-command :filter-args 527 | (lambda (key-string) 528 | (setq god-latest-described-command key-string))) 529 | ;; use unwind-protect, and remove the advice / hook in the unwind forms 530 | (unwind-protect 531 | (let ((command 532 | ;; if the key is not recognized by god-mode, 533 | ;; we will pass it to the regular `describe-key' 534 | (condition-case err 535 | (god-mode-lookup-key-sequence) 536 | (wrong-type-argument 537 | ;; due to how errors are passed, 538 | ;; we do not have enough information 539 | ;; to pass menu items 540 | (if (not (equal (cddr err) '((menu-bar)))) 541 | (describe-key (vector (caddr err)))))))) 542 | (if command 543 | (progn 544 | (add-hook 'help-fns-describe-function-functions 545 | #'god-mode--help-fn-describe-function) 546 | (describe-function command)))) 547 | ;; unwind forms: 548 | (advice-remove #'god-mode-lookup-command 549 | (lambda (key-string) 550 | (setq god-latest-described-command key-string))) 551 | (remove-hook 'help-fns-describe-function-functions 552 | #'god-mode--help-fn-describe-function))) 553 | 554 | (provide 'god-mode) 555 | 556 | ;;; god-mode.el ends here 557 | --------------------------------------------------------------------------------