Debian Codegraph @

aggressive-indent.el

raw
1 ;;; aggressive-indent.el --- Minor mode to aggressively keep your code always indented -*- lexical-binding:t -*-
2
3 ;; Copyright (C) 2014-2021 Free Software Foundation, Inc
4
5 ;; Author: Artur Malabarba <[email protected]>
6 ;; URL: https://github.com/Malabarba/aggressive-indent-mode
7 ;; Version: 1.10.0
8 ;; Package-Requires: ((emacs "24.3"))
9 ;; Keywords: indent lisp maint tools
10 ;; Prefix: aggressive-indent
11 ;; Separator: -
12
13 ;;; Commentary:
14 ;;
15 ;; `electric-indent-mode' is enough to keep your code nicely aligned when
16 ;; all you do is type. However, once you start shifting blocks around,
17 ;; transposing lines, or slurping and barfing sexps, indentation is bound
18 ;; to go wrong.
19 ;;
20 ;; `aggressive-indent-mode' is a minor mode that keeps your code always
21 ;; indented. It reindents after every change, making it more reliable
22 ;; than `electric-indent-mode'.
23 ;;
24 ;; ### Instructions ###
25 ;;
26 ;; This package is available fom Melpa, you may install it by calling
27 ;;
28 ;; M-x package-install RET aggressive-indent
29 ;;
30 ;; Then activate it with
31 ;;
32 ;; (add-hook 'emacs-lisp-mode-hook #'aggressive-indent-mode)
33 ;; (add-hook 'css-mode-hook #'aggressive-indent-mode)
34 ;;
35 ;; You can use this hook on any mode you want, `aggressive-indent' is not
36 ;; exclusive to emacs-lisp code. In fact, if you want to turn it on for
37 ;; every programming mode, you can do something like:
38 ;;
39 ;; (global-aggressive-indent-mode 1)
40 ;; (add-to-list 'aggressive-indent-excluded-modes 'html-mode)
41 ;;
42 ;; ### Manual Installation ###
43 ;;
44 ;; If you don't want to install from Melpa, you can download it manually,
45 ;; place it in your `load-path' and require it with
46 ;;
47 ;; (require 'aggressive-indent)
48
49 ;;; Instructions:
50 ;;
51 ;; INSTALLATION
52 ;;
53 ;; This package is available fom Melpa, you may install it by calling
54 ;; M-x package-install RET aggressive-indent.
55 ;;
56 ;; Then activate it with
57 ;; (add-hook 'emacs-lisp-mode-hook #'aggressive-indent-mode)
58 ;;
59 ;; You can also use an equivalent hook for another mode,
60 ;; `aggressive-indent' is not exclusive to emacs-lisp code.
61 ;;
62 ;; Alternatively, you can download it manually, place it in your
63 ;; `load-path' and require it with
64 ;;
65 ;; (require 'aggressive-indent)
66
67 ;;; License:
68 ;;
69 ;; This file is NOT part of GNU Emacs.
70 ;;
71 ;; This program is free software; you can redistribute it and/or
72 ;; modify it under the terms of the GNU General Public License
73 ;; as published by the Free Software Foundation; either version 3
74 ;; of the License, or (at your option) any later version.
75 ;;
76 ;; This program is distributed in the hope that it will be useful,
77 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
78 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
79 ;; GNU General Public License for more details.
80 ;;
81
82 ;;; Code:
83
84 (require 'cl-lib)
85
86 (defgroup aggressive-indent nil
87 "Customization group for aggressive-indent."
88 :prefix "aggressive-indent-"
89 :group 'electricity
90 :group 'indent)
91
92 (defun aggressive-indent-bug-report ()
93 "Opens github issues page in a web browser. Please send any bugs you find.
94 Please include your Emacs and `aggressive-indent' versions."
95 (interactive)
96 (message "Your `aggressive-indent-version' is: %s, and your emacs version is: %s.
97 Please include this in your report!"
98 (eval-when-compile
99 (ignore-errors
100 (require 'lisp-mnt)
101 (lm-version)))
102 emacs-version)
103 (browse-url "https://github.com/Malabarba/aggressive-indent-mode/issues/new"))
104
105 (defvar aggressive-indent-mode)
106
107 ;;; Configuring indentation
108 (defcustom aggressive-indent-dont-electric-modes nil
109 "List of major-modes where `electric-indent' should be disabled."
110 :type '(choice
111 (const :tag "Never use `electric-indent-mode'." t)
112 (repeat :tag "List of major-modes to avoid `electric-indent-mode'." symbol))
113 :package-version '(aggressive-indent . "0.3.1"))
114
115 (defcustom aggressive-indent-excluded-modes
116 '(elm-mode
117 haskell-mode
118 inf-ruby-mode
119 makefile-mode
120 makefile-gmake-mode
121 python-mode
122 sql-interactive-mode
123 text-mode
124 yaml-mode)
125 "Modes in which `aggressive-indent-mode' should not be activated.
126 This variable is only used if `global-aggressive-indent-mode' is
127 active. If the minor mode is turned on with the local command,
128 `aggressive-indent-mode', this variable is ignored."
129 :type '(repeat symbol)
130 :package-version '(aggressive-indent . "1.8.4"))
131
132 (defcustom aggressive-indent-protected-commands '(undo undo-tree-undo undo-tree-redo undo-tree-visualize undo-tree-visualize-undo undo-tree-visualize-redo whitespace-cleanup)
133 "Commands after which indentation will NOT be performed.
134 Aggressive indentation could break things like `undo' by locking
135 the user in a loop, so this variable is used to control which
136 commands will NOT be followed by a re-indent."
137 :type '(repeat symbol)
138 :package-version '(aggressive-indent . "0.1"))
139
140 (defcustom aggressive-indent-protected-current-commands
141 '(query-replace-regexp query-replace exit-minibuffer)
142 "Like `aggressive-indent-protected-commands', but for the current command.
143 For instance, with the default value, this variable prevents
144 indentation during `query-replace' (but not after)."
145 :type '(repeat symbol)
146 :package-version '(aggressive-indent . "1.8.4"))
147
148 (defcustom aggressive-indent-comments-too nil
149 "If non-nil, aggressively indent in comments as well."
150 :type 'boolean
151 :package-version '(aggressive-indent . "0.3"))
152
153 (defcustom aggressive-indent-modes-to-prefer-defun
154 '(emacs-lisp-mode lisp-mode scheme-mode clojure-mode)
155 "List of major-modes in which indenting defun is preferred.
156 Add here any major modes with very good definitions of
157 `end-of-defun' and `beginning-of-defun', or modes which bug out
158 if you have `after-change-functions' (such as paredit).
159
160 If current major mode is derived from one of these,
161 `aggressive-indent' will call `aggressive-indent-indent-defun'
162 after every command. Otherwise, it will call
163 `aggressive-indent-indent-region-and-on' after every buffer
164 change."
165 :type '(repeat symbol)
166 :package-version '(aggressive-indent . "0.3"))
167
168 ;;; Preventing indentation
169 (defconst aggressive-indent--internal-dont-indent-if
170 '((memq last-command aggressive-indent-protected-commands)
171 (memq this-command aggressive-indent-protected-current-commands)
172 (region-active-p)
173 buffer-read-only
174 undo-in-progress
175 (null (buffer-modified-p))
176 (and (boundp 'smerge-mode) smerge-mode)
177 (equal (buffer-name) "*ediff-merge*")
178 (let ((line (thing-at-point 'line)))
179 (and (stringp line)
180 ;; If the user is starting to type a comment.
181 (stringp comment-start)
182 (string-match (concat "\\`[[:blank:]]*"
183 (substring comment-start 0 1)
184 "[[:blank:]]*$")
185 line)))
186 (let ((sp (syntax-ppss)))
187 ;; Comments.
188 (or (and (not aggressive-indent-comments-too) (elt sp 4))
189 ;; Strings.
190 (elt sp 3))))
191 "List of forms which prevent indentation when they evaluate to non-nil.
192 This is for internal use only. For user customization, use
193 `aggressive-indent-dont-indent-if' instead.")
194
195 (eval-after-load 'yasnippet
196 '(when (boundp 'yas--active-field-overlay)
197 (add-to-list 'aggressive-indent--internal-dont-indent-if
198 '(and
199 (overlayp yas--active-field-overlay)
200 (overlay-end yas--active-field-overlay))
201 'append)))
202 (eval-after-load 'company
203 '(when (boundp 'company-candidates)
204 (add-to-list 'aggressive-indent--internal-dont-indent-if
205 'company-candidates)))
206 (eval-after-load 'auto-complete
207 '(when (boundp 'ac-completing)
208 (add-to-list 'aggressive-indent--internal-dont-indent-if
209 'ac-completing)))
210 (eval-after-load 'multiple-cursors-core
211 '(when (boundp 'multiple-cursors-mode)
212 (add-to-list 'aggressive-indent--internal-dont-indent-if
213 'multiple-cursors-mode)))
214 (eval-after-load 'iedit
215 '(when (boundp 'iedit-mode)
216 (add-to-list 'aggressive-indent--internal-dont-indent-if
217 'iedit-mode)))
218 (eval-after-load 'evil
219 '(when (boundp 'iedit-mode)
220 (add-to-list 'aggressive-indent--internal-dont-indent-if
221 'iedit-mode)))
222 (eval-after-load 'coq
223 '(add-to-list 'aggressive-indent--internal-dont-indent-if
224 '(and (derived-mode-p 'coq-mode)
225 (not (string-match "\\.[[:space:]]*$"
226 (thing-at-point 'line))))))
227 (eval-after-load 'ruby-mode
228 '(add-to-list 'aggressive-indent--internal-dont-indent-if
229 '(when (derived-mode-p 'ruby-mode)
230 (let ((line (thing-at-point 'line)))
231 (and (stringp line)
232 (string-match "\\b\\(begin\\|case\\|d\\(?:ef\\|o\\)\\|if\\) *$" line))))))
233
234 (defcustom aggressive-indent-dont-indent-if '()
235 "List of variables and functions to prevent aggressive indenting.
236 This variable is a list where each element is a Lisp form.
237 As long as any one of these forms returns non-nil,
238 aggressive-indent will not perform any indentation.
239
240 See `aggressive-indent--internal-dont-indent-if' for usage examples.
241
242 Note that this is only used once, and only on the line where the
243 point is when we're about to start indenting. In order to
244 prevent indentation of further lines, see
245 `aggressive-indent-stop-here-hook'."
246 :type '(repeat sexp)
247 :package-version '(aggressive-indent . "0.2"))
248
249 (defcustom aggressive-indent-stop-here-hook nil
250 "A hook that runs on each line before it is indented.
251 If any function on this hook returns non-nil, it immediately
252 prevents indentation of the current line and any further
253 lines.
254
255 Note that aggressive-indent does indentation in two stages. The
256 first stage indents the entire edited region, while the second
257 stage keeps indenting further lines until its own logic decide to
258 stop. This hook only affects the second stage. That is, it
259 effectly lets you add your own predicates to the logic that
260 decides when to stop.
261
262 In order to prevent indentation before the first stage, see
263 `aggressive-indent-dont-indent-if' instead."
264 :type 'hook)
265
266 (defvar aggressive-indent--error-message "One of the forms in `aggressive-indent-dont-indent-if' had the following error, I've disabled it until you fix it: %S"
267 "Error message thrown by `aggressive-indent-dont-indent-if'.")
268
269 (defvar aggressive-indent--has-errored nil
270 "Keep track of whether `aggressive-indent-dont-indent-if' is throwing.
271 This is used to prevent an infinite error loop on the user.")
272
273 (defun aggressive-indent--run-user-hooks ()
274 "Safely run forms in `aggressive-indent-dont-indent-if'.
275 If any of them errors out, we only report it once until it stops
276 erroring again."
277 (and aggressive-indent-dont-indent-if
278 (condition-case er
279 (prog1 (eval (cons 'or aggressive-indent-dont-indent-if))
280 (setq aggressive-indent--has-errored nil))
281 (error (unless aggressive-indent--has-errored
282 (setq aggressive-indent--has-errored t)
283 (message aggressive-indent--error-message er))))))
284
285 ;;; Indenting defun
286 (defcustom aggressive-indent-region-function #'indent-region
287 "Function called to indent a region.
288 It is called with two arguments, the region beginning and end."
289 :risky t
290 :type 'function)
291
292 ;;;###autoload
293 (defun aggressive-indent-indent-defun (&optional l r)
294 "Indent current defun.
295 Throw an error if parentheses are unbalanced.
296 If L and R are provided, use them for finding the start and end of defun."
297 (interactive)
298 (let ((p (point-marker)))
299 (set-marker-insertion-type p t)
300 (funcall aggressive-indent-region-function
301 (save-excursion
302 (when l (goto-char l))
303 (beginning-of-defun 1) (point))
304 (save-excursion
305 (when r (goto-char r))
306 (end-of-defun 1) (point)))
307 (goto-char p)))
308
309 (defun aggressive-indent--softly-indent-defun (&optional l r)
310 "Indent current defun unobstrusively.
311 Like `aggressive-indent-indent-defun', but without errors or
312 messages. L and R passed to `aggressive-indent-indent-defun'."
313 (cl-letf (((symbol-function 'message) #'ignore))
314 (ignore-errors (aggressive-indent-indent-defun l r))))
315
316 ;;; Indenting region
317 (defun aggressive-indent--indent-current-balanced-line (column)
318 "Indent current balanced line, if it starts at COLUMN.
319 Balanced line means anything contained in a sexp that starts at
320 the current line, or starts at the same line that one of these
321 sexps ends.
322
323 Return non-nil only if the line's indentation actually changed."
324 (when (= (current-column) column)
325 (unless (= (point)
326 (progn (indent-according-to-mode)
327 (point)))
328 (let ((line-end (line-end-position)))
329 (forward-sexp 1)
330 (comment-forward (point-max))
331 ;; We know previous sexp finished on a previous line when
332 ;; there's only be whitespace behind point.
333 (while (progn
334 (skip-chars-backward "[:blank:]")
335 (not (looking-at "^")))
336 (forward-sexp 1)
337 (comment-forward (point-max)))
338 (when (looking-at "^")
339 (funcall aggressive-indent-region-function line-end (1- (point))))
340 (skip-chars-forward "[:blank:]")))))
341
342 (defun aggressive-indent--extend-end-to-whole-sexps (beg end)
343 "Return a point >= END, so that it covers whole sexps from BEG."
344 (save-excursion
345 (goto-char beg)
346 (while (and (< (point) end)
347 (not (eobp)))
348 (forward-sexp 1))
349 (point)))
350
351 ;;;###autoload
352 (defun aggressive-indent-indent-region-and-on (l r)
353 "Indent region between L and R, and then some.
354 Call `aggressive-indent-region-function' between L and R, and
355 then keep indenting until nothing more happens."
356 (interactive "r")
357 (let ((p (point-marker)))
358 (set-marker-insertion-type p t)
359 (unwind-protect
360 (progn
361 (unless (= l r)
362 (when (= (char-before r) ?\n)
363 (cl-decf r)))
364 ;; If L is at the end of a line, skip that line.
365 (unless (= l r)
366 (when (= (char-after l) ?\n)
367 (cl-incf l)))
368 ;; Indent the affected region.
369 (goto-char r)
370 (unless (= l r) (funcall aggressive-indent-region-function l r))
371 ;; And then we indent each following line until nothing happens.
372 (forward-line 1)
373 (skip-chars-forward "[:blank:]\n\r\xc")
374 (let ((base-column (current-column)))
375 (while (and (not (eobp))
376 (not (run-hook-with-args-until-success 'aggressive-indent-stop-here-hook))
377 (aggressive-indent--indent-current-balanced-line base-column)))))
378 (goto-char p))))
379
380 (defun aggressive-indent--softly-indent-region-and-on (l r &rest _)
381 "Indent region between L and R, and a bit more.
382 Like `aggressive-indent-indent-region-and-on', but without errors
383 or messages."
384 (cl-letf (((symbol-function 'message) #'ignore))
385 (ignore-errors (aggressive-indent-indent-region-and-on l r))))
386
387 ;;; Tracking changes
388 (defvar aggressive-indent--changed-list nil
389 "List of (left right) limit of regions changed in the last command loop.")
390 (make-variable-buffer-local 'aggressive-indent--changed-list)
391
392 (defun aggressive-indent--process-changed-list-and-indent ()
393 "Indent the regions in `aggressive-indent--changed-list'."
394 (unless (or (run-hook-wrapped 'aggressive-indent--internal-dont-indent-if #'eval)
395 (aggressive-indent--run-user-hooks))
396 (let ((after-change-functions (remove 'aggressive-indent--keep-track-of-changes after-change-functions))
397 (inhibit-point-motion-hooks t)
398 (indent-function
399 (if (cl-member-if #'derived-mode-p aggressive-indent-modes-to-prefer-defun)
400 #'aggressive-indent--softly-indent-defun #'aggressive-indent--softly-indent-region-and-on)))
401 ;; Take the 10 most recent changes.
402 (let ((cell (nthcdr 10 aggressive-indent--changed-list)))
403 (when cell (setcdr cell nil)))
404 ;; (message "----------")
405 (while aggressive-indent--changed-list
406 ;; (message "%S" (car aggressive-indent--changed-list))
407 (apply indent-function (car aggressive-indent--changed-list))
408 (setq aggressive-indent--changed-list
409 (cdr aggressive-indent--changed-list))))))
410
411 (defun aggressive-indent--clear-change-list ()
412 "Clear cache of all changed regions. "
413 (setq aggressive-indent--changed-list nil))
414
415 (defcustom aggressive-indent-sit-for-time 0.05
416 "Time, in seconds, to wait before indenting.
417 If you feel aggressive-indent is causing Emacs to hang while
418 typing, try tweaking this number."
419 :type 'float)
420
421 (defvar-local aggressive-indent--idle-timer nil
422 "Idle timer used for indentation")
423
424 ;; Ripped from Emacs 27.0 subr.el.
425 ;; See Github Issue#111 and Emacs bug#31692.
426 (defmacro aggressive-indent--while-no-input (&rest body)
427 "Execute BODY only as long as there's no pending input.
428 If input arrives, that ends the execution of BODY,
429 and `while-no-input' returns t. Quitting makes it return nil.
430 If BODY finishes, `while-no-input' returns whatever value BODY produced."
431 (declare (debug t) (indent 0))
432 (let ((catch-sym (make-symbol "input")))
433 `(with-local-quit
434 (catch ',catch-sym
435 (let ((throw-on-input ',catch-sym)
436 val)
437 (setq val (or (input-pending-p)
438 (progn ,@body)))
439 (cond
440 ;; When input arrives while throw-on-input is non-nil,
441 ;; kbd_buffer_store_buffered_event sets quit-flag to the
442 ;; value of throw-on-input. If, when BODY finishes,
443 ;; quit-flag still has the same value as throw-on-input, it
444 ;; means BODY never tested quit-flag, and therefore ran to
445 ;; completion even though input did arrive before it
446 ;; finished. In that case, we must manually simulate what
447 ;; 'throw' in process_quit_flag would do, and we must
448 ;; reset quit-flag, because leaving it set will cause us
449 ;; quit to top-level, which has undesirable consequences,
450 ;; such as discarding input etc. We return t in that case
451 ;; because input did arrive during execution of BODY.
452 ((eq quit-flag throw-on-input)
453 (setq quit-flag nil)
454 t)
455 ;; This is for when the user actually QUITs during
456 ;; execution of BODY.
457 (quit-flag
458 nil)
459 (t val)))))))
460
461 (defun aggressive-indent--maybe-cancel-timer ()
462 "Cancel and remove the timer if it is set."
463 (when (timerp aggressive-indent--idle-timer)
464 (cancel-timer aggressive-indent--idle-timer)
465 (setq aggressive-indent--idle-timer nil)))
466
467 (defun aggressive-indent--indent-if-changed (buffer)
468 "Indent any region that changed in BUFFER in the last command loop."
469 (if (not (buffer-live-p buffer))
470 (aggressive-indent--maybe-cancel-timer)
471 (with-current-buffer buffer
472 (when (and aggressive-indent-mode aggressive-indent--changed-list)
473 (save-excursion
474 (save-selected-window
475 (aggressive-indent--while-no-input
476 (aggressive-indent--process-changed-list-and-indent))))
477 (aggressive-indent--maybe-cancel-timer)))))
478
479 (defun aggressive-indent--keep-track-of-changes (l r &rest _)
480 "Store the limits (L and R) of each change in the buffer."
481 (when aggressive-indent-mode
482 (push (list l r) aggressive-indent--changed-list)
483 (aggressive-indent--maybe-cancel-timer)
484 (setq aggressive-indent--idle-timer
485 (run-with-idle-timer aggressive-indent-sit-for-time t #'aggressive-indent--indent-if-changed (current-buffer)))))
486
487 ;;; Minor modes
488 ;;;###autoload
489 (define-minor-mode aggressive-indent-mode
490 "Minor mode to keep your code always indented."
491 :lighter " =>"
492 :keymap `((,(kbd "C-c C-q") . aggressive-indent-indent-defun)
493 ([backspace]
494 menu-item "maybe-delete-indentation" ignore :filter
495 (lambda (&optional _)
496 (when (and (looking-back "^[[:blank:]]+")
497 ;; Wherever we don't want to indent, we probably also
498 ;; want the default backspace behavior.
499 (not (run-hook-wrapped 'aggressive-indent--internal-dont-indent-if #'eval))
500 (not (aggressive-indent--run-user-hooks)))
501 #'delete-indentation))))
502 (if aggressive-indent-mode
503 (if (and (bound-and-true-p global-aggressive-indent-mode)
504 (or (cl-member-if #'derived-mode-p aggressive-indent-excluded-modes)
505 (equal indent-line-function #'indent-relative)
506 (derived-mode-p 'text-mode)
507 (eq major-mode 'fundamental-mode)
508 buffer-read-only))
509 (aggressive-indent-mode -1)
510 ;; Should electric indent be ON or OFF?
511 (if (or (eq aggressive-indent-dont-electric-modes t)
512 (cl-member-if #'derived-mode-p aggressive-indent-dont-electric-modes))
513 (aggressive-indent--local-electric nil)
514 (aggressive-indent--local-electric t))
515 (add-hook 'after-change-functions #'aggressive-indent--keep-track-of-changes nil 'local)
516 (add-hook 'after-revert-hook #'aggressive-indent--clear-change-list nil 'local)
517 (add-hook 'before-save-hook #'aggressive-indent--process-changed-list-and-indent nil 'local)
518 (add-hook 'kill-buffer-hook #'aggressive-indent--maybe-cancel-timer nil 'local))
519 ;; Clean the hooks
520 (aggressive-indent--maybe-cancel-timer)
521 (remove-hook 'after-change-functions #'aggressive-indent--keep-track-of-changes 'local)
522 (remove-hook 'after-revert-hook #'aggressive-indent--clear-change-list 'local)
523 (remove-hook 'before-save-hook #'aggressive-indent--process-changed-list-and-indent 'local)
524 (remove-hook 'post-command-hook #'aggressive-indent--softly-indent-defun 'local)
525 (remove-hook 'kill-buffer-hook #'aggressive-indent--maybe-cancel-timer 'local)))
526
527 (defun aggressive-indent--local-electric (on)
528 "Turn variable `electric-indent-mode' on or off locally, as per boolean ON."
529 (if (fboundp 'electric-indent-local-mode)
530 (electric-indent-local-mode (if on 1 -1))
531 (set (make-local-variable 'electric-indent-mode) on)))
532
533 ;;;###autoload
534 (define-globalized-minor-mode global-aggressive-indent-mode
535 aggressive-indent-mode aggressive-indent-mode)
536
537 ;;;###autoload
538 (defalias 'aggressive-indent-global-mode
539 #'global-aggressive-indent-mode)
540
541 (provide 'aggressive-indent)
542 ;;; aggressive-indent.el ends here