[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] master 4acafa6 110/110: Merge commit '0e59474430cbfbe7caf2a41cf79
|
From: |
Oleh Krehel |
|
Subject: |
[elpa] master 4acafa6 110/110: Merge commit '0e59474430cbfbe7caf2a41cf7935fc613648c49' from avy |
|
Date: |
Sat, 11 May 2019 10:15:55 -0400 (EDT) |
branch: master
commit 4acafa68a78c84f4f21a2d2b823bfd16ff266f25
Merge: 1744d5a 0e59474
Author: Oleh Krehel <address@hidden>
Commit: Oleh Krehel <address@hidden>
Merge commit '0e59474430cbfbe7caf2a41cf7935fc613648c49' from avy
---
packages/avy/Makefile | 7 +-
packages/avy/README.md | 17 +-
packages/avy/avy-test.el | 4 +
packages/avy/avy.el | 1233 +++++++++++++++++++++++++++++++-------
packages/avy/doc/Changelog.org | 175 +++++-
packages/avy/targets/avy-init.el | 6 -
packages/avy/targets/checkdoc.el | 2 +
7 files changed, 1224 insertions(+), 220 deletions(-)
diff --git a/packages/avy/Makefile b/packages/avy/Makefile
index 9303c7c..430da88 100644
--- a/packages/avy/Makefile
+++ b/packages/avy/Makefile
@@ -3,13 +3,16 @@ emacs ?= emacs
LOAD = -l avy.el -l avy-test.el
-.PHONY: all test clean
+.PHONY: all test clean checkdoc
-all: compile test
+all: compile test checkdoc
test:
$(emacs) -batch $(LOAD) -f ert-run-tests-batch-and-exit
+checkdoc:
+ $(emacs) -batch -l targets/checkdoc.el
+
compile:
$(emacs) -batch -l targets/avy-init.el
diff --git a/packages/avy/README.md b/packages/avy/README.md
index 9df0ce2..76455de 100644
--- a/packages/avy/README.md
+++ b/packages/avy/README.md
@@ -1,3 +1,6 @@
+[](https://melpa.org/#/avy)
+[](https://stable.melpa.org/#/avy)
+
## Introduction
`avy` is a GNU Emacs package for jumping to visible text using a char-based
decision tree. See also
[ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and
[vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy` uses the
same idea.
@@ -34,6 +37,13 @@ After <kbd>C-' bu</kbd>:
+### `avy-goto-char-timer`
+
+> Input an arbitrary amount of consecutive chars, jump to the first one with a
tree.
+
+This is a more flexible version of `avy-goto-char-2`. First part works
similarly to `isearch`: you type a query and it's highlighted dynamically on
the screen. When you stop typing for `avy-timeout-seconds` (0.5s by default),
you'll be able to select one of the candidates with `avy`. As you're inputting
characters, you can use `C-h` (backspace) or `DEL` (delete) to
+forget the last typed character and `RET` to end the input sequence
immediately and select a candidate.
+
### `avy-goto-line`
> Input zero chars, jump to a line start with a tree.
@@ -74,6 +84,10 @@ After <kbd>M-g e</kbd>:
+### Org-mode commands
+
+ * `avy-org-goto-heading-timer`: Type part of an Org heading. When you stop
typing, if only one heading on the screen matches, it will be jumped to; if
more than one matches, you can jump to a heading with Avy. This is like
`avy-goto-char-timer` but for Org headings.
+ * `avy-org-refile-as-child`: With point in an entry you want to refile, run
this command, select a heading with Avy, and the entry will be refiled as its
first child heading. This makes it quick and easy to refile to headings that
are visible on-screen, even to other windows or buffers.
### Other commands
@@ -85,6 +99,7 @@ You add this to your config to bind some stuff:
```elisp
(avy-setup-default)
+(global-set-key (kbd "C-c C-j") 'avy-resume)
```
It will bind, for example, `avy-isearch` to <kbd>C-'</kbd> in
`isearch-mode-map`, so that you can select one of the currently visible
`isearch` candidates using `avy`.
@@ -107,6 +122,6 @@ The copyright assignment isn't a big deal, it just says
that the copyright for y
The basic code style guide is to use `(setq indent-tabs-mode nil)`. It is
provided for you in
[.dir-locals.el](https://github.com/abo-abo/avy/blob/master/.dir-locals.el),
please obey it.
-Before submitting the change, run `make compile` and `make test` to make sure
that it doesn't introduce new compile warnings or test failures. Also run
<kbd>M-x</kbd> `checkdoc` to see that your changes obey the documentation
guidelines.
+Before submitting the change, run `make compile` and `make test` to make sure
that it doesn't introduce new compile warnings or test failures. Also run `make
checkdoc` to see that your changes obey the documentation guidelines.
Use your own judgment for the commit messages, I recommend a verbose style
using `magit-commit-add-log`.
diff --git a/packages/avy/avy-test.el b/packages/avy/avy-test.el
index 339d8a0..bb03599 100644
--- a/packages/avy/avy-test.el
+++ b/packages/avy/avy-test.el
@@ -66,3 +66,7 @@
(108 (97 leaf . 8)
(115 leaf . 9)
(100 leaf . 10))))))
+
+(provide 'avy-test)
+
+;;; avy-test.el ends here
diff --git a/packages/avy/avy.el b/packages/avy/avy.el
index 593dbb0..8b258da 100644
--- a/packages/avy/avy.el
+++ b/packages/avy/avy.el
@@ -1,10 +1,10 @@
-;;; avy.el --- tree-based completion -*- lexical-binding: t -*-
+;;; avy.el --- Jump to arbitrary positions in visible text and select text
quickly. -*- lexical-binding: t -*-
-;; Copyright (C) 2015 Free Software Foundation, Inc.
+;; Copyright (C) 2015-2019 Free Software Foundation, Inc.
;; Author: Oleh Krehel <address@hidden>
;; URL: https://github.com/abo-abo/avy
-;; Version: 0.4.0
+;; Version: 0.5.0
;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
;; Keywords: point, location
@@ -25,15 +25,23 @@
;;; Commentary:
;;
-;; This package provides a generic completion method based on building
-;; a balanced decision tree with each candidate being a leaf. To
-;; traverse the tree from the root to a desired leaf, typically a
-;; sequence of `read-key' can be used.
+;; With Avy, you can move point to any position in Emacs – even in a
+;; different window – using very few keystrokes. For this, you look at
+;; the position where you want point to be, invoke Avy, and then enter
+;; the sequence of characters displayed at that position.
;;
-;; In order for `read-key' to make sense, the tree needs to be
-;; visualized appropriately, with a character at each branch node. So
-;; this completion method works only for things that you can see on
-;; your screen, all at once:
+;; If the position you want to jump to can be determined after only
+;; issuing a single keystroke, point is moved to the desired position
+;; immediately after that keystroke. In case this isn't possible, the
+;; sequence of keystrokes you need to enter is comprised of more than
+;; one character. Avy uses a decision tree where each candidate position
+;; is a leaf and each edge is described by a character which is distinct
+;; per level of the tree. By entering those characters, you navigate the
+;; tree, quickly arriving at the desired candidate position, such that
+;; Avy can move point to it.
+;;
+;; Note that this only makes sense for positions you are able to see
+;; when invoking Avy. These kinds of positions are supported:
;;
;; * character positions
;; * word or subword start positions
@@ -62,27 +70,80 @@ key (letters, digits, punctuation, etc.) or a symbol
denoting a
non-printing key like an arrow key (left, right, up, down). For
non-printing keys, a corresponding entry in
`avy-key-to-char-alist' must exist in order to visualize the key
-in the avy overlays."
- :type '(repeat :tag "Keys" (choice (character :tag "char")
+in the avy overlays.
+
+If `avy-style' is set to words, make sure there are at least three
+keys different than the following: a, e, i, o, u, y"
+ :type '(repeat :tag "Keys" (choice
+ (character :tag "char")
(symbol :tag "non-printing key"))))
+(defconst avy--key-type
+ '(choice :tag "Command"
+ (const avy-goto-char)
+ (const avy-goto-char-2)
+ (const avy-isearch)
+ (const avy-goto-line)
+ (const avy-goto-subword-0)
+ (const avy-goto-subword-1)
+ (const avy-goto-word-0)
+ (const avy-goto-word-1)
+ (const avy-copy-line)
+ (const avy-copy-region)
+ (const avy-move-line)
+ (const avy-move-region)
+ (const avy-kill-whole-line)
+ (const avy-kill-region)
+ (const avy-kill-ring-save-whole-line)
+ (const avy-kill-ring-save-region)
+ (function :tag "Other command")))
+
(defcustom avy-keys-alist nil
"Alist of avy-jump commands to `avy-keys' overriding the default `avy-keys'."
- :type '(alist
- :key-type (choice :tag "Command"
- (const avy-goto-char)
- (const avy-goto-char-2)
- (const avy-isearch)
- (const avy-goto-line)
- (const avy-goto-subword-0)
- (const avy-goto-subword-1)
- (const avy-goto-word-0)
- (const avy-goto-word-1)
- (const avy-copy-line)
- (const avy-copy-region)
- (const avy-move-line))
+ :type `(alist
+ :key-type ,avy--key-type
:value-type (repeat :tag "Keys" character)))
+(defcustom avy-orders-alist '((avy-goto-char . avy-order-closest))
+ "Alist of candidate ordering functions.
+Usually, candidates appear in their point position order."
+ :type `(alist
+ :key-type ,avy--key-type
+ :value-type function))
+
+(defcustom avy-words
+ '("am" "by" "if" "is" "it" "my" "ox" "up"
+ "ace" "act" "add" "age" "ago" "aim" "air" "ale" "all" "and" "ant" "any"
+ "ape" "apt" "arc" "are" "arm" "art" "ash" "ate" "awe" "axe" "bad" "bag"
+ "ban" "bar" "bat" "bay" "bed" "bee" "beg" "bet" "bid" "big" "bit" "bob"
+ "bot" "bow" "box" "boy" "but" "cab" "can" "cap" "car" "cat" "cog" "cop"
+ "cow" "cry" "cup" "cut" "day" "dew" "did" "die" "dig" "dim" "dip" "dog"
+ "dot" "dry" "dub" "dug" "dye" "ear" "eat" "eel" "egg" "ego" "elf" "eve"
+ "eye" "fan" "far" "fat" "fax" "fee" "few" "fin" "fit" "fix" "flu" "fly"
+ "foe" "fog" "for" "fox" "fry" "fun" "fur" "gag" "gap" "gas" "gel" "gem"
+ "get" "gig" "gin" "gnu" "god" "got" "gum" "gun" "gut" "guy" "gym" "had"
+ "hag" "ham" "has" "hat" "her" "hid" "him" "hip" "his" "hit" "hop" "hot"
+ "how" "hub" "hue" "hug" "hut" "ice" "icy" "imp" "ink" "inn" "ion" "ire"
+ "ivy" "jab" "jam" "jar" "jaw" "jet" "job" "jog" "joy" "key" "kid" "kit"
+ "lag" "lap" "lay" "let" "lid" "lie" "lip" "lit" "lob" "log" "lot" "low"
+ "mad" "man" "map" "mat" "may" "men" "met" "mix" "mob" "mop" "mud" "mug"
+ "nag" "nap" "new" "nil" "nod" "nor" "not" "now" "nun" "oak" "odd" "off"
+ "oil" "old" "one" "orb" "ore" "ork" "our" "out" "owl" "own" "pad" "pan"
+ "par" "pat" "paw" "pay" "pea" "pen" "pet" "pig" "pin" "pit" "pod" "pot"
+ "pry" "pub" "pun" "put" "rag" "ram" "ran" "rat" "raw" "ray" "red" "rib"
+ "rim" "rip" "rob" "rod" "rot" "row" "rub" "rug" "rum" "run" "sad" "sat"
+ "saw" "say" "sea" "see" "sew" "she" "shy" "sin" "sip" "sit" "six" "ski"
+ "sky" "sly" "sob" "son" "soy" "spy" "sum" "sun" "tab" "tad" "tag" "tan"
+ "tap" "tar" "tax" "tea" "the" "tie" "tin" "tip" "toe" "ton" "too" "top"
+ "toy" "try" "tub" "two" "urn" "use" "van" "war" "was" "wax" "way" "web"
+ "wed" "wet" "who" "why" "wig" "win" "wit" "woe" "won" "wry" "you" "zap"
+ "zip" "zoo")
+ "Words to use in case `avy-style' is set to `words'.
+Every word should contain at least one vowel i.e. one of the following
+characters: a, e, i, o, u, y
+They do not have to be sorted but no word should be a prefix of another one."
+ :type '(repeat string))
+
(defcustom avy-style 'at-full
"The default method of displaying the overlays.
Use `avy-styles-alist' to customize this per-command."
@@ -91,7 +152,8 @@ Use `avy-styles-alist' to customize this per-command."
(const :tag "At" at)
(const :tag "At Full" at-full)
(const :tag "Post" post)
- (const :tag "De Bruijn" de-bruijn)))
+ (const :tag "De Bruijn" de-bruijn)
+ (const :tag "Words" words)))
(defcustom avy-styles-alist nil
"Alist of avy-jump commands to the style for each command.
@@ -108,18 +170,30 @@ If the commands isn't on the list, `avy-style' is used."
(const avy-goto-word-1)
(const avy-copy-line)
(const avy-copy-region)
- (const avy-move-line))
+ (const avy-move-line)
+ (const avy-move-region)
+ (const avy-kill-whole-line)
+ (const avy-kill-region)
+ (const avy-kill-ring-save-whole-line)
+ (const avy-kill-ring-save-region)
+ (function :tag "Other command"))
:value-type (choice
(const :tag "Pre" pre)
(const :tag "At" at)
(const :tag "At Full" at-full)
(const :tag "Post" post)
- (const :tag "De Bruijn" de-bruijn))))
+ (const :tag "De Bruijn" de-bruijn)
+ (const :tag "Words" words))))
(defcustom avy-dispatch-alist
- '((?x . avy-action-kill)
+ '((?x . avy-action-kill-move)
+ (?X . avy-action-kill-stay)
+ (?t . avy-action-teleport)
(?m . avy-action-mark)
- (?n . avy-action-copy))
+ (?n . avy-action-copy)
+ (?y . avy-action-yank)
+ (?i . avy-action-ispell)
+ (?z . avy-action-zap-to-char))
"List of actions for `avy-handler-default'.
Each item is (KEY . ACTION). When KEY not on `avy-keys' is
@@ -131,7 +205,8 @@ pressed during the dispatch, ACTION is set to replace the
default
:value-type (choice
(const :tag "Mark" avy-action-mark)
(const :tag "Copy" avy-action-copy)
- (const :tag "Kill" avy-action-kill))))
+ (const :tag "Kill and move point" avy-action-kill-move)
+ (const :tag "Kill" avy-action-kill-stay))))
(defcustom avy-background nil
"When non-nil, a gray background will be added during the selection."
@@ -156,9 +231,31 @@ When nil, punctuation chars will not be matched.
\"[!-/:address@hidden" will match all printable punctuation chars."
:type 'regexp)
+(defcustom avy-goto-word-0-regexp "\\b\\sw"
+ "Regexp that determines positions for `avy-goto-word-0'."
+ :type '(choice
+ (const :tag "Default" "\\b\\sw")
+ (const :tag "Symbol" "\\_<\\(\\sw\\|\\s_\\)")
+ (const :tag "Not whitespace" "[^ \r\n\t]+")
+ (regexp :tag "Regex")))
+
(defcustom avy-ignored-modes '(image-mode doc-view-mode pdf-view-mode)
"List of modes to ignore when searching for candidates.
-Typically, these modes don't use the text representation.")
+Typically, these modes don't use the text representation."
+ :type 'list)
+
+(defcustom avy-single-candidate-jump t
+ "In case there is only one candidate jumps directly to it."
+ :type 'boolean)
+
+(defcustom avy-del-last-char-by '(8 127)
+ "List of event types, i.e. key presses, that delete the last
+character read. The default represents `C-h' and `DEL'. See
+`event-convert-list'."
+ :type 'list)
+
+(defvar avy-ring (make-ring 20)
+ "Hold the window and point history.")
(defvar avy-translate-char-function #'identity
"Function to translate user input key into another key.
@@ -225,16 +322,16 @@ self-inserting keys and thus aren't read as characters.")
(a (make-list (* n k) 0))
sequence)
(cl-labels ((db (T p)
- (if (> T n)
- (if (eq (% n p) 0)
- (setq sequence
- (append sequence
- (cl-subseq a 1 (1+ p)))))
- (setf (nth T a) (nth (- T p) a))
- (db (1+ T) p)
- (cl-loop for j from (1+ (nth (- T p) a)) to (1- k) do
- (setf (nth T a) j)
- (db (1+ T) T)))))
+ (if (> T n)
+ (if (eq (% n p) 0)
+ (setq sequence
+ (append sequence
+ (cl-subseq a 1 (1+ p)))))
+ (setf (nth T a) (nth (- T p) a))
+ (db (1+ T) p)
+ (cl-loop for j from (1+ (nth (- T p) a)) to (1- k) do
+ (setf (nth T a) j)
+ (db (1+ T) T)))))
(db 1 1)
(mapcar (lambda (n)
(nth n keys))
@@ -268,9 +365,10 @@ SEQ-LEN is how many elements of KEYS it takes to identify
a match."
(when (and (> diff 0) (< diff seq-len))
(while (and (nth (1- seq-len) db-seq)
(not
- (eq 0 (cl-search
- (cl-subseq prev-seq diff)
- (cl-subseq db-seq 0
seq-len)))))
+ (eq 0
+ (cl-search
+ (cl-subseq prev-seq diff)
+ (cl-subseq db-seq 0 seq-len)))))
(pop db-seq)))
(subseq-and-pop))
(subseq-and-pop))))
@@ -284,11 +382,22 @@ SEQ-LEN is how many elements of KEYS it takes to identify
a match."
lst (cdr lst))))))
(nreverse path-alist)))
+(defun avy-order-closest (x)
+ (abs (- (caar x) (point))))
+
+(defvar avy-command nil
+ "Store the current command symbol.
+E.g. 'avy-goto-line or 'avy-goto-char.")
+
(defun avy-tree (lst keys)
"Coerce LST into a balanced tree.
The degree of the tree is the length of KEYS.
KEYS are placed appropriately on internal nodes."
- (let ((len (length keys)))
+ (let* ((len (length keys))
+ (order-fn (cdr (assq avy-command avy-orders-alist)))
+ (lst (if order-fn
+ (cl-sort lst #'< :key order-fn)
+ lst)))
(cl-labels
((rd (ls)
(let ((ln (length ls)))
@@ -341,12 +450,33 @@ KEYS is the path from the root of `avy-tree' to LEAF."
(defun avy-handler-default (char)
"The default handler for a bad CHAR."
(let (dispatch)
- (if (setq dispatch (assoc char avy-dispatch-alist))
- (progn
- (setq avy-action (cdr dispatch))
- (throw 'done 'restart))
- (signal 'user-error (list "No such candidate" char))
- (throw 'done nil))))
+ (cond ((setq dispatch (assoc char avy-dispatch-alist))
+ (setq avy-action (cdr dispatch))
+ (throw 'done 'restart))
+ ((memq char '(27 ?\C-g))
+ ;; exit silently
+ (throw 'done 'exit))
+ ((eq char ??)
+ (avy-show-dispatch-help)
+ (throw 'done 'restart))
+ ((mouse-event-p char)
+ (signal 'user-error (list "Mouse event not handled" char)))
+ (t
+ (message "No such candidate: %s, hit `C-g' to quit."
+ (if (characterp char) (string char) char))))))
+
+(defun avy-show-dispatch-help ()
+ "Display action shortucts in echo area."
+ (let ((len (length "avy-action-")))
+ (message "%s" (mapconcat
+ (lambda (x)
+ (format "%s: %s"
+ (propertize
+ (char-to-string (car x))
+ 'face 'aw-key-face)
+ (substring (symbol-name (cdr x)) len)))
+ avy-dispatch-alist
+ " "))))
(defvar avy-handler-function 'avy-handler-default
"A function to call for a bad `read-key' in `avy-read'.")
@@ -354,15 +484,25 @@ KEYS is the path from the root of `avy-tree' to LEAF."
(defvar avy-current-path ""
"Store the current incomplete path during `avy-read'.")
+(defun avy-mouse-event-window (char)
+ "If CHAR is a mouse event, return the window of the event if any or the
selected window.
+Return nil if not a mouse event."
+ (when (mouse-event-p char)
+ (cond ((windowp (posn-window (event-start char)))
+ (posn-window (event-start char)))
+ ((framep (posn-window (event-start char)))
+ (frame-selected-window (posn-window (event-start char))))
+ (t (selected-window)))))
+
(defun avy-read (tree display-fn cleanup-fn)
- "Select a leaf from TREE using consecutive `read-char'.
+ "Select a leaf from TREE using consecutive `read-key'.
DISPLAY-FN should take CHAR and LEAF and signify that LEAFs
associated with CHAR will be selected if CHAR is pressed. This is
commonly done by adding a CHAR overlay at LEAF position.
CLEANUP-FN should take no arguments and remove the effects of
-multiple DISPLAY-FN invokations."
+multiple DISPLAY-FN invocations."
(catch 'done
(setq avy-current-path "")
(while tree
@@ -373,14 +513,19 @@ multiple DISPLAY-FN invokations."
(dolist (x avy--leafs)
(funcall display-fn (car x) (cdr x))))
(let ((char (funcall avy-translate-char-function (read-key)))
+ window
branch)
(funcall cleanup-fn)
- (if (setq branch (assoc char tree))
- (if (eq (car (setq tree (cdr branch))) 'leaf)
- (throw 'done (cdr tree))
- (setq avy-current-path
- (concat avy-current-path (string (avy--key-to-char
char)))))
- (funcall avy-handler-function char))))))
+ (if (setq window (avy-mouse-event-window char))
+ (throw 'done (cons char window))
+ ;; Ensure avy-current-path stores the full path prior to
+ ;; exit so other packages can utilize its value.
+ (setq avy-current-path
+ (concat avy-current-path (string (avy--key-to-char char))))
+ (if (setq branch (assoc char tree))
+ (if (eq (car (setq tree (cdr branch))) 'leaf)
+ (throw 'done (cdr tree)))
+ (funcall avy-handler-function char)))))))
(defun avy-read-de-bruijn (lst keys)
"Select from LST dispatching on KEYS."
@@ -417,6 +562,56 @@ multiple DISPLAY-FN invokations."
(funcall avy-handler-function char))))
(cdar alist)))))
+(defun avy-read-words (lst words)
+ "Select from LST using WORDS."
+ (catch 'done
+ (let ((num-words (length words))
+ (num-entries (length lst))
+ alist)
+ ;; If there are not enough words to cover all the candidates,
+ ;; we use a De Bruijn sequence to generate the remaining ones.
+ (when (< num-words num-entries)
+ (let ((keys avy-keys)
+ (bad-keys '(?a ?e ?i ?o ?u ?y))
+ (path-len 1)
+ (num-remaining (- num-entries num-words))
+ tmp-alist)
+ ;; Delete all keys which could lead to duplicates.
+ ;; We want at least three keys left to work with.
+ (dolist (x bad-keys)
+ (when (memq x keys)
+ (setq keys (delq ?a keys))))
+ (when (< (length keys) 3)
+ (signal 'user-error
+ '("Please add more keys to the variable `avy-keys'.")))
+ ;; Generate the sequence and add the keys to the existing words.
+ (while (not tmp-alist)
+ (cl-incf path-len)
+ (setq tmp-alist (avy--path-alist-1 lst path-len keys)))
+ (while (>= (cl-decf num-remaining) 0)
+ (push (mapconcat 'string (caar tmp-alist) nil) (cdr (last words)))
+ (setq tmp-alist (cdr tmp-alist)))))
+ (dolist (x lst)
+ (push (cons (string-to-list (pop words)) x) alist))
+ (setq avy-current-path "")
+ (while (or (> (length alist) 1)
+ (caar alist))
+ (dolist (x (reverse alist))
+ (avy--overlay-at-full (reverse (car x)) (cdr x)))
+ (let ((char (funcall avy-translate-char-function (read-key))))
+ (avy--remove-leading-chars)
+ (setq alist
+ (delq nil
+ (mapcar (lambda (x)
+ (when (eq (caar x) char)
+ (cons (cdr (car x)) (cdr x))))
+ alist)))
+ (setq avy-current-path
+ (concat avy-current-path (string (avy--key-to-char char))))
+ (unless alist
+ (funcall avy-handler-function char))))
+ (cdar alist))))
+
;;** Rest
(defun avy-window-list ()
"Return a list of windows depending on `avy-all-windows'."
@@ -432,9 +627,10 @@ multiple DISPLAY-FN invokations."
(t
(error "Unrecognized option: %S" avy-all-windows))))
-(defcustom avy-all-windows-alt t
+(defcustom avy-all-windows-alt nil
"The alternative `avy-all-windows' for use with \\[universal-argument]."
:type '(choice
+ (const :tag "Current window" nil)
(const :tag "All windows on the current frame" t)
(const :tag "All windows on all frames" all-frames)))
@@ -450,6 +646,11 @@ multiple DISPLAY-FN invokations."
(unless (memq major-mode avy-ignored-modes)
,@body)))))
+(defun avy-resume ()
+ "Stub to hold last avy command.
+Commands using `avy-with' macro can be resumed."
+ (interactive))
+
(defmacro avy-with (command &rest body)
"Set `avy-keys' according to COMMAND and execute BODY.
Set `avy-style' according to COMMMAND as well."
@@ -458,82 +659,218 @@ Set `avy-style' according to COMMMAND as well."
`(let ((avy-keys (or (cdr (assq ',command avy-keys-alist))
avy-keys))
(avy-style (or (cdr (assq ',command avy-styles-alist))
- avy-style)))
+ avy-style))
+ (avy-command ',command))
(setq avy-action nil)
+ (setf (symbol-function 'avy-resume)
+ (lambda ()
+ (interactive)
+ ,@body))
,@body))
(defun avy-action-goto (pt)
"Goto PT."
- (goto-char pt))
+ (let ((frame (window-frame (selected-window))))
+ (unless (equal frame (selected-frame))
+ (select-frame-set-input-focus frame)
+ (raise-frame frame))
+ (goto-char pt)))
+
+(defun avy-forward-item ()
+ (if (eq avy-command 'avy-goto-line)
+ (end-of-line)
+ (forward-sexp))
+ (point))
(defun avy-action-mark (pt)
"Mark sexp at PT."
(goto-char pt)
(set-mark (point))
- (forward-sexp))
+ (avy-forward-item))
(defun avy-action-copy (pt)
"Copy sexp starting on PT."
(save-excursion
(let (str)
(goto-char pt)
- (forward-sexp)
+ (avy-forward-item)
(setq str (buffer-substring pt (point)))
(kill-new str)
- (message "Copied: %s" str))))
-
-(defun avy-action-kill (pt)
- "Kill sexp at PT."
+ (message "Copied: %s" str)))
+ (let ((dat (ring-ref avy-ring 0)))
+ (select-frame-set-input-focus
+ (window-frame (cdr dat)))
+ (select-window (cdr dat))
+ (goto-char (car dat))))
+
+(defun avy-action-yank (pt)
+ "Yank sexp starting at PT at the current point."
+ (avy-action-copy pt)
+ (yank)
+ t)
+
+(defun avy-action-kill-move (pt)
+ "Kill sexp at PT and move there."
(goto-char pt)
- (forward-sexp)
+ (avy-forward-item)
(kill-region pt (point))
- (message "Killed: %s" (current-kill 0)))
+ (message "Killed: %s" (current-kill 0))
+ (point))
-(defun avy--process (candidates overlay-fn)
+(defun avy-action-kill-stay (pt)
+ "Kill sexp at PT."
+ (save-excursion
+ (goto-char pt)
+ (avy-forward-item)
+ (kill-region pt (point))
+ (just-one-space))
+ (message "Killed: %s" (current-kill 0))
+ (select-window
+ (cdr
+ (ring-ref avy-ring 0)))
+ t)
+
+(defun avy-action-zap-to-char (pt)
+ "Kill from point up to PT."
+ (if (> pt (point))
+ (kill-region (point) pt)
+ (kill-region pt (point))))
+
+(defun avy-action-teleport (pt)
+ "Kill sexp starting on PT and yank into the current location."
+ (avy-action-kill-stay pt)
+ (select-window
+ (cdr
+ (ring-ref avy-ring 0)))
+ (save-excursion
+ (yank))
+ t)
+
+(declare-function flyspell-correct-word-before-point "flyspell")
+
+(defun avy-action-ispell (pt)
+ "Auto correct word at PT."
+ (save-excursion
+ (goto-char pt)
+ (cond
+ ((eq avy-command 'avy-goto-line)
+ (ispell-region
+ (line-beginning-position)
+ (line-end-position)))
+ ((bound-and-true-p flyspell-mode)
+ (flyspell-correct-word-before-point))
+ ((looking-at-p "\\b")
+ (ispell-word))
+ (t
+ (progn
+ (backward-word)
+ (when (looking-at-p "\\b")
+ (ispell-word)))))))
+
+(defvar avy-pre-action #'avy-pre-action-default
+ "Function to call before `avy-action' is called.")
+
+(defun avy-pre-action-default (res)
+ (avy-push-mark)
+ (when (and (consp res)
+ (windowp (cdr res)))
+ (let* ((window (cdr res))
+ (frame (window-frame window)))
+ (unless (equal frame (selected-frame))
+ (select-frame-set-input-focus frame))
+ (select-window window))))
+
+(defun avy--process-1 (candidates overlay-fn &optional cleanup-fn)
+ (let ((len (length candidates)))
+ (cond ((= len 0)
+ nil)
+ ((and (= len 1) avy-single-candidate-jump)
+ (car candidates))
+ (t
+ (unwind-protect
+ (progn
+ (avy--make-backgrounds
+ (avy-window-list))
+ (cond ((eq avy-style 'de-bruijn)
+ (avy-read-de-bruijn
+ candidates avy-keys))
+ ((eq avy-style 'words)
+ (avy-read-words
+ candidates avy-words))
+ (t
+ (avy-read (avy-tree candidates avy-keys)
+ overlay-fn
+ (or cleanup-fn
#'avy--remove-leading-chars)))))
+ (avy--done))))))
+
+(defvar avy-last-candidates nil
+ "Store the last candidate list.")
+
+(defun avy--last-candidates-cycle (advancer)
+ (let* ((avy-last-candidates
+ (cl-remove-if-not
+ (lambda (x) (equal (cdr x) (selected-window)))
+ avy-last-candidates))
+ (min-dist
+ (apply #'min
+ (mapcar (lambda (x) (abs (- (caar x) (point))))
avy-last-candidates)))
+ (pos
+ (cl-position-if
+ (lambda (x)
+ (= (- (caar x) (point)) min-dist))
+ avy-last-candidates)))
+ (funcall advancer pos avy-last-candidates)))
+
+(defun avy-prev ()
+ "Go to the previous candidate of the last `avy-read'."
+ (interactive)
+ (avy--last-candidates-cycle
+ (lambda (pos lst)
+ (when (> pos 0)
+ (goto-char (caar (nth (1- pos) lst)))))))
+
+(defun avy-next ()
+ "Go to the next candidate of the last `avy-read'."
+ (interactive)
+ (avy--last-candidates-cycle
+ (lambda (pos lst)
+ (when (< pos (1- (length lst)))
+ (goto-char (caar (nth (1+ pos) lst)))))))
+
+(defun avy-process (candidates &optional overlay-fn cleanup-fn)
"Select one of CANDIDATES using `avy-read'.
-Use OVERLAY-FN to visualize the decision overlay."
+Use OVERLAY-FN to visualize the decision overlay.
+CLEANUP-FN should take no arguments and remove the effects of
+multiple OVERLAY-FN invocations."
+ (setq overlay-fn (or overlay-fn (avy--style-fn avy-style)))
+ (setq cleanup-fn (or cleanup-fn #'avy--remove-leading-chars))
(unless (and (consp (car candidates))
(windowp (cdar candidates)))
(setq candidates
(mapcar (lambda (x) (cons x (selected-window)))
candidates)))
- (let ((len (length candidates))
- (cands (copy-sequence candidates))
- res)
- (if (= len 0)
- (message "zero candidates")
- (if (= len 1)
- (setq res (car candidates))
- (unwind-protect
- (progn
- (avy--make-backgrounds
- (avy-window-list))
- (setq res (if (eq avy-style 'de-bruijn)
- (avy-read-de-bruijn
- candidates avy-keys)
- (avy-read (avy-tree candidates avy-keys)
- overlay-fn
- #'avy--remove-leading-chars))))
- (avy--done)))
- (cond ((eq res 'restart)
- (avy--process cands overlay-fn))
- ;; ignore exit from `avy-handler-function'
- ((eq res 'exit))
- (t
- (avy-push-mark)
- (when (and (consp res)
- (windowp (cdr res)))
- (let* ((window (cdr res))
- (frame (window-frame window)))
- (unless (equal frame (selected-frame))
- (select-frame-set-input-focus frame))
- (select-window window))
- (setq res (car res)))
-
- (funcall (or avy-action 'avy-action-goto)
- (if (consp res)
- (car res)
- res)))))))
+ (setq avy-last-candidates (copy-sequence candidates))
+ (let ((original-cands (copy-sequence candidates))
+ (res (avy--process-1 candidates overlay-fn cleanup-fn)))
+ (cond
+ ((null res)
+ (message "zero candidates")
+ t)
+ ((eq res 'restart)
+ (avy-process original-cands overlay-fn cleanup-fn))
+ ;; ignore exit from `avy-handler-function'
+ ((eq res 'exit))
+ (t
+ (funcall avy-pre-action res)
+ (setq res (car res))
+ (funcall (or avy-action 'avy-action-goto)
+ (if (consp res)
+ (car res)
+ res))
+ res))))
+
+(define-obsolete-function-alias 'avy--process 'avy-process
+ "0.4.0")
(defvar avy--overlays-back nil
"Hold overlays for when `avy-background' is t.")
@@ -558,18 +895,24 @@ Use OVERLAY-FN to visualize the decision overlay."
(setq avy--overlays-back nil)
(avy--remove-leading-chars))
+(defun avy--visible-p (s)
+ (let ((invisible (get-char-property s 'invisible)))
+ (or (null invisible)
+ (eq t buffer-invisibility-spec)
+ (null (assoc invisible buffer-invisibility-spec)))))
+
(defun avy--next-visible-point ()
"Return the next closest point without `invisible' property."
(let ((s (point)))
- (while (and (not (= (point-max) (setq s (next-overlay-change s))))
- (get-char-property s 'invisible)))
+ (while (and (not (= (point-max) (setq s (next-char-property-change s))))
+ (not (avy--visible-p s))))
s))
(defun avy--next-invisible-point ()
"Return the next closest point with `invisible' property."
(let ((s (point)))
- (while (and (not (= (point-max) (setq s (next-overlay-change s))))
- (not (get-char-property s 'invisible))))
+ (while (and (not (= (point-max) (setq s (next-char-property-change s))))
+ (avy--visible-p s)))
s))
(defun avy--find-visible-regions (rbeg rend)
@@ -604,7 +947,7 @@ When GROUP is non-nil, (BEG . END) should delimit that
regex group."
(save-excursion
(goto-char (car pair))
(while (re-search-forward regex (cdr pair) t)
- (unless (get-char-property (1- (point)) 'invisible)
+ (when (avy--visible-p (1- (point)))
(when (or (null pred)
(funcall pred))
(push (cons (cons (match-beginning group)
@@ -669,10 +1012,11 @@ Do this even when the char is terminating."
(defun avy--key-to-char (c)
"If C is no character, translate it using `avy-key-to-char-alist'."
- (if (characterp c)
- c
- (or (cdr (assoc c avy-key-to-char-alist))
- (error "Unknown key %s" c))))
+ (cond ((characterp c) c)
+ ((cdr (assoc c avy-key-to-char-alist)))
+ ((mouse-event-p c) c)
+ (t
+ (error "Unknown key %s" c))))
(defun avy-candidate-beg (leaf)
"Return the start position for LEAF."
@@ -750,7 +1094,7 @@ LEAF is normally ((BEG . END) . WND)."
(wnd (cdr leaf))
end)
(dotimes (i len)
- (set-text-properties (- len i 1) (- len i)
+ (set-text-properties i (1+ i)
`(face ,(nth i avy-lead-faces))
str))
(when (eq avy-style 'de-bruijn)
@@ -767,6 +1111,10 @@ LEAF is normally ((BEG . END) . WND)."
(end-of-visual-line)
(point))
(line-end-position)))
+ ;; `end-of-visual-line' is bugged sometimes
+ (lep (if (< lep beg)
+ (line-end-position)
+ lep))
(len-and-str (avy--update-offset-and-str len str lep)))
(setq len (car len-and-str))
(setq str (cdr len-and-str))
@@ -871,20 +1219,37 @@ exist."
(at-full 'avy--overlay-at-full)
(post #'avy--overlay-post)
(de-bruijn #'avy--overlay-at-full)
+ (words #'avy--overlay-at-full)
+ (ignore #'ignore)
(t (error "Unexpected style %S" style))))
-(defun avy--generic-jump (regex window-flip style &optional beg end)
+(cl-defun avy-jump (regex &key window-flip beg end action pred)
"Jump to REGEX.
+The window scope is determined by `avy-all-windows'.
When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'.
-STYLE determines the leading char overlay style.
-BEG and END delimit the area where candidates are searched."
+BEG and END narrow the scope where candidates are searched.
+ACTION is a function that takes point position as an argument.
+When PRED is non-nil, it's a filter for matching point positions."
+ (setq avy-action (or action avy-action))
(let ((avy-all-windows
(if window-flip
(not avy-all-windows)
avy-all-windows)))
- (avy--process
- (avy--regex-candidates regex beg end)
- (avy--style-fn style))))
+ (avy-process
+ (avy--regex-candidates regex beg end pred))))
+
+(defun avy--generic-jump (regex window-flip &optional beg end)
+ "Jump to REGEX.
+The window scope is determined by `avy-all-windows'.
+When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched."
+ (declare (obsolete avy-jump "0.4.0"))
+ (let ((avy-all-windows
+ (if window-flip
+ (not avy-all-windows)
+ avy-all-windows)))
+ (avy-process
+ (avy--regex-candidates regex beg end))))
;;* Commands
;;;###autoload
@@ -894,37 +1259,72 @@ The window scope is determined by `avy-all-windows' (ARG
negates it)."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-char
- (avy--generic-jump
+ (avy-jump
(if (= 13 char)
"\n"
(regexp-quote (string char)))
- arg
- avy-style)))
+ :window-flip arg)))
;;;###autoload
(defun avy-goto-char-in-line (char)
"Jump to the currently visible CHAR in the current line."
(interactive (list (read-char "char: " t)))
(avy-with avy-goto-char
- (avy--generic-jump
+ (avy-jump
(regexp-quote (string char))
- avy-all-windows
- avy-style
- (line-beginning-position)
- (line-end-position))))
+ :beg (line-beginning-position)
+ :end (line-end-position))))
;;;###autoload
-(defun avy-goto-char-2 (char1 char2 &optional arg)
+(defun avy-goto-char-2 (char1 char2 &optional arg beg end)
"Jump to the currently visible CHAR1 followed by CHAR2.
-The window scope is determined by `avy-all-windows' (ARG negates it)."
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched."
(interactive (list (read-char "char 1: " t)
(read-char "char 2: " t)
- current-prefix-arg))
+ current-prefix-arg
+ nil nil))
+ (when (eq char1 ?
)
+ (setq char1 ?\n))
+ (when (eq char2 ?
)
+ (setq char2 ?\n))
(avy-with avy-goto-char-2
- (avy--generic-jump
+ (avy-jump
(regexp-quote (string char1 char2))
- arg
- avy-style)))
+ :window-flip arg
+ :beg beg
+ :end end)))
+
+;;;###autoload
+(defun avy-goto-char-2-above (char1 char2 &optional arg)
+ "Jump to the currently visible CHAR1 followed by CHAR2.
+This is a scoped version of `avy-goto-char-2', where the scope is
+the visible part of the current buffer up to point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char 1: " t)
+ (read-char "char 2: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-char-2-above
+ (avy-goto-char-2
+ char1 char2 arg
+ (window-start) (point))))
+
+;;;###autoload
+(defun avy-goto-char-2-below (char1 char2 &optional arg)
+ "Jump to the currently visible CHAR1 followed by CHAR2.
+This is a scoped version of `avy-goto-char-2', where the scope is
+the visible part of the current buffer following point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char 1: " t)
+ (read-char "char 2: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-char-2-below
+ (avy-goto-char-2
+ char1 char2 arg
+ (point) (window-end (selected-window) t))))
;;;###autoload
(defun avy-isearch ()
@@ -932,23 +1332,48 @@ The window scope is determined by `avy-all-windows' (ARG
negates it)."
(interactive)
(avy-with avy-isearch
(let ((avy-background nil))
- (avy--process
- (avy--regex-candidates isearch-string)
- (avy--style-fn avy-style))
+ (avy-process
+ (avy--regex-candidates (if isearch-regexp
+ isearch-string
+ (regexp-quote isearch-string))))
(isearch-done))))
;;;###autoload
-(defun avy-goto-word-0 (arg)
+(defun avy-goto-word-0 (arg &optional beg end)
"Jump to a word start.
-The window scope is determined by `avy-all-windows' (ARG negates it)."
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched."
+ (interactive "P")
+ (avy-with avy-goto-word-0
+ (avy-jump avy-goto-word-0-regexp
+ :window-flip arg
+ :beg beg
+ :end end)))
+
+(defun avy-goto-word-0-above (arg)
+ "Jump to a word start between window start and point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive "P")
(avy-with avy-goto-word-0
- (avy--generic-jump "\\b\\sw" arg avy-style)))
+ (avy-goto-word-0 arg (window-start) (point))))
+
+(defun avy-goto-word-0-below (arg)
+ "Jump to a word start between point and window end.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive "P")
+ (avy-with avy-goto-word-0
+ (avy-goto-word-0 arg (point) (window-end (selected-window) t))))
;;;###autoload
-(defun avy-goto-word-1 (char &optional arg)
+(defun avy-goto-word-1 (char &optional arg beg end symbol)
"Jump to the currently visible CHAR at a word start.
-The window scope is determined by `avy-all-windows' (ARG negates it)."
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched.
+When SYMBOL is non-nil, jump to symbol start instead of word start."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-word-1
@@ -958,11 +1383,74 @@ The window scope is determined by `avy-all-windows' (ARG
negates it)."
((and avy-word-punc-regexp
(string-match avy-word-punc-regexp str))
(regexp-quote str))
+ ((<= char 26)
+ str)
(t
(concat
- "\\b"
+ (if symbol "\\_<" "\\b")
str)))))
- (avy--generic-jump regex arg avy-style))))
+ (avy-jump regex
+ :window-flip arg
+ :beg beg
+ :end end))))
+
+;;;###autoload
+(defun avy-goto-word-1-above (char &optional arg)
+ "Jump to the currently visible CHAR at a word start.
+This is a scoped version of `avy-goto-word-1', where the scope is
+the visible part of the current buffer up to point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-word-1
+ (avy-goto-word-1 char arg (window-start) (point))))
+
+;;;###autoload
+(defun avy-goto-word-1-below (char &optional arg)
+ "Jump to the currently visible CHAR at a word start.
+This is a scoped version of `avy-goto-word-1', where the scope is
+the visible part of the current buffer following point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-word-1
+ (avy-goto-word-1 char arg (point) (window-end (selected-window) t))))
+
+;;;###autoload
+(defun avy-goto-symbol-1 (char &optional arg)
+ "Jump to the currently visible CHAR at a symbol start.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-symbol-1
+ (avy-goto-word-1 char arg nil nil t)))
+
+;;;###autoload
+(defun avy-goto-symbol-1-above (char &optional arg)
+ "Jump to the currently visible CHAR at a symbol start.
+This is a scoped version of `avy-goto-symbol-1', where the scope is
+the visible part of the current buffer up to point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-symbol-1-above
+ (avy-goto-word-1 char arg (window-start) (point) t)))
+
+;;;###autoload
+(defun avy-goto-symbol-1-below (char &optional arg)
+ "Jump to the currently visible CHAR at a symbol start.
+This is a scoped version of `avy-goto-symbol-1', where the scope is
+the visible part of the current buffer following point.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive (list (read-char "char: " t)
+ current-prefix-arg))
+ (avy-with avy-goto-symbol-1-below
+ (avy-goto-word-1 char arg (point) (window-end (selected-window) t) t)))
(declare-function subword-backward "subword")
(defvar subword-backward-regexp)
@@ -973,13 +1461,14 @@ This variable is used by `avy-goto-subword-0' and
`avy-goto-subword-1'."
:type '(repeat character))
;;;###autoload
-(defun avy-goto-subword-0 (&optional arg predicate)
+(defun avy-goto-subword-0 (&optional arg predicate beg end)
"Jump to a word or subword start.
-
The window scope is determined by `avy-all-windows' (ARG negates it).
When PREDICATE is non-nil it's a function of zero parameters that
-should return true."
+should return true.
+
+BEG and END narrow the scope where candidates are searched."
(interactive "P")
(require 'subword)
(avy-with avy-goto-subword-0
@@ -992,19 +1481,24 @@ should return true."
(dolist (char avy-subword-extra-word-chars)
(modify-syntax-entry char "w" syn-tbl))
(with-syntax-table syn-tbl
- (let ((ws (window-start))
+ (let ((ws (or beg (window-start)))
window-cands)
(save-excursion
- (goto-char (window-end (selected-window) t))
+ (goto-char (or end (window-end (selected-window) t)))
(subword-backward)
(while (> (point) ws)
(when (or (null predicate)
(and predicate (funcall predicate)))
- (unless (get-char-property (point) 'invisible)
+ (unless (not (avy--visible-p (point)))
(push (cons (point) (selected-window)) window-cands)))
- (subword-backward)))
+ (subword-backward))
+ (and (= (point) ws)
+ (or (null predicate)
+ (and predicate (funcall predicate)))
+ (not (get-char-property (point) 'invisible))
+ (push (cons (point) (selected-window)) window-cands)))
(setq candidates (nconc candidates window-cands))))))
- (avy--process candidates (avy--style-fn avy-style)))))
+ (avy-process candidates))))
;;;###autoload
(defun avy-goto-subword-1 (char &optional arg)
@@ -1016,7 +1510,9 @@ The case of CHAR is ignored."
(avy-with avy-goto-subword-1
(let ((char (downcase char)))
(avy-goto-subword-0
- arg (lambda () (eq (downcase (char-after)) char))))))
+ arg (lambda ()
+ (and (char-after)
+ (eq (downcase (char-after)) char)))))))
;;;###autoload
(defun avy-goto-word-or-subword-1 ()
@@ -1029,10 +1525,16 @@ Which one depends on variable `subword-mode'."
(defvar visual-line-mode)
-(defun avy--line (&optional arg beg end)
- "Select a line.
-The window scope is determined by `avy-all-windows' (ARG negates it).
-Narrow the scope to BEG END."
+(defcustom avy-indent-line-overlay nil
+ "When non-nil, `avy-goto-line' will display the line overlay next to the
first non-whitespace character of each line."
+ :type 'boolean)
+
+(defun avy--line-cands (&optional arg beg end bottom-up)
+ "Get candidates for selecting a line.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched.
+When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(let (candidates)
(avy-dowindows arg
(let ((ws (or beg (window-start))))
@@ -1041,20 +1543,122 @@ Narrow the scope to BEG END."
(narrow-to-region ws (or end (window-end (selected-window) t)))
(goto-char (point-min))
(while (< (point) (point-max))
- (unless (get-char-property
- (max (1- (point)) ws) 'invisible)
+ (when (member (get-char-property
+ (max (1- (point)) ws) 'invisible) '(nil org-link))
(push (cons
(if (eq avy-style 'post)
(line-end-position)
- (point))
+ (save-excursion
+ (when avy-indent-line-overlay
+ (skip-chars-forward " \t"))
+ (point)))
(selected-window)) candidates))
(if visual-line-mode
(progn
(setq temporary-goal-column 0)
(line-move-visual 1 t))
(forward-line 1)))))))
- (let ((avy-action #'identity))
- (avy--process (nreverse candidates) (avy--style-fn avy-style)))))
+ (if bottom-up
+ candidates
+ (nreverse candidates))))
+
+(defun avy--linum-strings ()
+ "Get strings for `avy-linum-mode'."
+ (let* ((lines (mapcar #'car (avy--line-cands)))
+ (line-tree (avy-tree lines avy-keys))
+ (line-list nil))
+ (avy-traverse
+ line-tree
+ (lambda (path _leaf)
+ (let ((str (propertize (apply #'string (reverse path))
+ 'face 'avy-lead-face)))
+ (when (> (length str) 1)
+ (set-text-properties 0 1 '(face avy-lead-face-0) str))
+ (push str line-list))))
+ (nreverse line-list)))
+
+(defvar linum-available)
+(defvar linum-overlays)
+(defvar linum-format)
+(declare-function linum--face-width "linum")
+
+(define-minor-mode avy-linum-mode
+ "Minor mode that uses avy hints for `linum-mode'."
+ :group 'avy
+ (if avy-linum-mode
+ (progn
+ (require 'linum)
+ (advice-add 'linum-update-window :around 'avy--linum-update-window)
+ (linum-mode 1))
+ (advice-remove 'linum-update-window 'avy--linum-update-window)
+ (linum-mode -1)))
+
+(defun avy--linum-update-window (_ win)
+ "Update line numbers for the portion visible in window WIN."
+ (goto-char (window-start win))
+ (let ((line (line-number-at-pos))
+ (limit (window-end win t))
+ (fmt (cond ((stringp linum-format) linum-format)
+ ((eq linum-format 'dynamic)
+ (let ((w (length (number-to-string
+ (count-lines (point-min) (point-max))))))
+ (concat "%" (number-to-string w) "d")))))
+ (width 0)
+ (avy-strs (when avy-linum-mode
+ (avy--linum-strings))))
+ (run-hooks 'linum-before-numbering-hook)
+ ;; Create an overlay (or reuse an existing one) for each
+ ;; line visible in this window, if necessary.
+ (while (and (not (eobp)) (< (point) limit))
+ (let* ((str
+ (cond (avy-linum-mode
+ (pop avy-strs))
+ (fmt
+ (propertize (format fmt line) 'face 'linum))
+ (t
+ (funcall linum-format line))))
+ (visited (catch 'visited
+ (dolist (o (overlays-in (point) (point)))
+ (when (equal-including-properties
+ (overlay-get o 'linum-str) str)
+ (unless (memq o linum-overlays)
+ (push o linum-overlays))
+ (setq linum-available (delq o linum-available))
+ (throw 'visited t))))))
+ (setq width (max width (length str)))
+ (unless visited
+ (let ((ov (if (null linum-available)
+ (make-overlay (point) (point))
+ (move-overlay (pop linum-available) (point) (point)))))
+ (push ov linum-overlays)
+ (overlay-put ov 'before-string
+ (propertize " " 'display `((margin left-margin)
,str)))
+ (overlay-put ov 'linum-str str))))
+ ;; Text may contain those nasty intangible properties, but that
+ ;; shouldn't prevent us from counting those lines.
+ (let ((inhibit-point-motion-hooks t))
+ (forward-line))
+ (setq line (1+ line)))
+ (when (display-graphic-p)
+ (setq width (ceiling
+ (/ (* width 1.0 (linum--face-width 'linum))
+ (frame-char-width)))))
+ (set-window-margins win width (cdr (window-margins win)))))
+
+(defun avy--line (&optional arg beg end bottom-up)
+ "Select a line.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'.
+BEG and END narrow the scope where candidates are searched.
+When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
+ (let ((avy-action #'identity)
+ (avy-style (if avy-linum-mode
+ (progn
+ (message "Goto line:")
+ 'ignore)
+ avy-style)))
+ (avy-process
+ (avy--line-cands arg beg end bottom-up))))
;;;###autoload
(defun avy-goto-line (&optional arg)
@@ -1074,11 +1678,12 @@ Otherwise, forward to `goto-line' with ARG."
(goto-char (point-min))
(forward-line (1- arg)))
(avy-with avy-goto-line
- (let* ((avy-handler-function
+ (let* ((avy-handler-old avy-handler-function)
+ (avy-handler-function
(lambda (char)
(if (or (< char ?0)
(> char ?9))
- (avy-handler-default char)
+ (funcall avy-handler-old char)
(let ((line (read-from-minibuffer
"Goto line: " (string char))))
(when line
@@ -1093,23 +1698,35 @@ Otherwise, forward to `goto-line' with ARG."
(avy-action-goto r))))))
;;;###autoload
-(defun avy-goto-line-above ()
- "Goto visible line above the cursor."
+(defun avy-goto-line-above (&optional offset bottom-up)
+ "Goto visible line above the cursor.
+OFFSET changes the distance between the closest key to the cursor and
+the cursor
+When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(interactive)
+ (if offset
+ (setq offset (+ 2 (- offset))))
(let* ((avy-all-windows nil)
(r (avy--line nil (window-start)
- (line-beginning-position))))
+ (line-beginning-position (or offset 1))
+ bottom-up)))
(unless (eq r t)
(avy-action-goto r))))
;;;###autoload
-(defun avy-goto-line-below ()
- "Goto visible line below the cursor."
+(defun avy-goto-line-below (&optional offset bottom-up)
+ "Goto visible line below the cursor.
+OFFSET changes the distance between the closest key to the cursor and
+the cursor
+When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(interactive)
+ (if offset
+ (setq offset (+ offset 1)))
(let* ((avy-all-windows nil)
(r (avy--line
- nil (line-beginning-position 2)
- (window-end (selected-window) t))))
+ nil (line-beginning-position (or offset 2))
+ (window-end (selected-window) t)
+ bottom-up)))
(unless (eq r t)
(avy-action-goto r))))
@@ -1120,6 +1737,13 @@ Otherwise, forward to `goto-line' with ARG."
(const :tag "Below" below)))
;;;###autoload
+(defun avy-goto-end-of-line (&optional arg)
+ "Call `avy-goto-line' and move to the end of the line."
+ (interactive "p")
+ (avy-goto-line arg)
+ (end-of-line))
+
+;;;###autoload
(defun avy-copy-line (arg)
"Copy a selected line above the current line.
ARG lines can be used."
@@ -1201,29 +1825,177 @@ The window scope is determined by `avy-all-windows' or
(user-error "Unexpected `avy-line-insert-style'")))))))
;;;###autoload
+(defun avy-move-region ()
+ "Select two lines and move the text between them above the current line."
+ (interactive)
+ (avy-with avy-move-region
+ (let* ((initial-window (selected-window))
+ (beg (avy--line))
+ (end (avy--line))
+ text)
+ (when (> beg end)
+ (cl-rotatef beg end))
+ (setq end (save-excursion
+ (goto-char end)
+ (1+ (line-end-position))))
+ (setq text (buffer-substring beg end))
+ (move-beginning-of-line nil)
+ (delete-region beg end)
+ (select-window initial-window)
+ (insert text))))
+
+;;;###autoload
+(defun avy-kill-region (arg)
+ "Select two lines and kill the region between them.
+
+The window scope is determined by `avy-all-windows' or
+`avy-all-windows-alt' when ARG is non-nil."
+ (interactive "P")
+ (let ((initial-window (selected-window)))
+ (avy-with avy-kill-region
+ (let* ((beg (save-selected-window
+ (list (avy--line arg) (selected-window))))
+ (end (list (avy--line arg) (selected-window))))
+ (cond
+ ((not (numberp (car beg)))
+ (user-error "Fail to select the beginning of region"))
+ ((not (numberp (car end)))
+ (user-error "Fail to select the end of region"))
+ ;; Restrict operation to same window. It's better if it can be
+ ;; different windows but same buffer; however, then the cloned
+ ;; buffers with different narrowed regions might cause problem.
+ ((not (equal (cdr beg) (cdr end)))
+ (user-error "Selected points are not in the same window"))
+ ((< (car beg) (car end))
+ (save-excursion
+ (kill-region
+ (car beg)
+ (progn (goto-char (car end)) (forward-visible-line 1) (point)))))
+ (t
+ (save-excursion
+ (kill-region
+ (progn (goto-char (car beg)) (forward-visible-line 1) (point))
+ (car end)))))))
+ (select-window initial-window)))
+
+;;;###autoload
+(defun avy-kill-ring-save-region (arg)
+ "Select two lines and save the region between them to the kill ring.
+The window scope is determined by `avy-all-windows'.
+When ARG is non-nil, do the opposite of `avy-all-windows'."
+ (interactive "P")
+ (let ((initial-window (selected-window)))
+ (avy-with avy-kill-ring-save-region
+ (let* ((beg (save-selected-window
+ (list (avy--line arg) (selected-window))))
+ (end (list (avy--line arg) (selected-window))))
+ (cond
+ ((not (numberp (car beg)))
+ (user-error "Fail to select the beginning of region"))
+ ((not (numberp (car end)))
+ (user-error "Fail to select the end of region"))
+ ((not (equal (cdr beg) (cdr end)))
+ (user-error "Selected points are not in the same window"))
+ ((< (car beg) (car end))
+ (save-excursion
+ (kill-ring-save
+ (car beg)
+ (progn (goto-char (car end)) (forward-visible-line 1) (point)))))
+ (t
+ (save-excursion
+ (kill-ring-save
+ (progn (goto-char (car beg)) (forward-visible-line 1) (point))
+ (car end)))))))
+ (select-window initial-window)))
+
+;;;###autoload
+(defun avy-kill-whole-line (arg)
+ "Select line and kill the whole selected line.
+
+With a numerical prefix ARG, kill ARG line(s) starting from the
+selected line. If ARG is negative, kill backward.
+
+If ARG is zero, kill the selected line but exclude the trailing
+newline.
+
+\\[universal-argument] 3 \\[avy-kil-whole-line] kill three lines
+starting from the selected line. \\[universal-argument] -3
+
+\\[avy-kill-whole-line] kill three lines backward including the
+selected line."
+ (interactive "P")
+ (let ((initial-window (selected-window)))
+ (avy-with avy-kill-whole-line
+ (let* ((start (avy--line)))
+ (if (not (numberp start))
+ (user-error "Fail to select the line to kill")
+ (save-excursion (goto-char start)
+ (kill-whole-line arg)))))
+ (select-window initial-window)))
+
+;;;###autoload
+(defun avy-kill-ring-save-whole-line (arg)
+ "Select line and save the whole selected line as if killed, but don’t kill
it.
+
+This command is similar to `avy-kill-whole-line', except that it
+saves the line(s) as if killed, but does not kill it(them).
+
+With a numerical prefix ARG, kill ARG line(s) starting from the
+selected line. If ARG is negative, kill backward.
+
+If ARG is zero, kill the selected line but exclude the trailing
+newline."
+ (interactive "P")
+ (let ((initial-window (selected-window)))
+ (avy-with avy-kill-ring-save-whole-line
+ (let* ((start (avy--line)))
+ (if (not (numberp start))
+ (user-error "Fail to select the line to kill")
+ (save-excursion
+ (let ((kill-read-only-ok t)
+ (buffer-read-only t))
+ (goto-char start)
+ (kill-whole-line arg))))))
+ (select-window initial-window)))
+
+;;;###autoload
(defun avy-setup-default ()
"Setup the default shortcuts."
(eval-after-load "isearch"
'(define-key isearch-mode-map (kbd "C-'") 'avy-isearch)))
(defcustom avy-timeout-seconds 0.5
- "How many seconds to wait for the second char.")
+ "How many seconds to wait for the second char."
+ :type 'float)
+
+(defcustom avy-enter-times-out t
+ "Whether enter exits avy-goto-char-timer early. If nil it matches newline"
+ :type 'boolean)
-(defun avy--read-candidates ()
- "Read as many chars as possible and return their occurences.
+(defun avy--read-candidates (&optional re-builder)
+ "Read as many chars as possible and return their occurrences.
At least one char must be read, and then repeatedly one next char
may be read if it is entered before `avy-timeout-seconds'. DEL
deletes the last char entered, and RET exits with the currently
read string immediately instead of waiting for another char for
`avy-timeout-seconds'.
The format of the result is the same as that of `avy--regex-candidates'.
-This function obeys `avy-all-windows' setting."
- (let ((str "") char break overlays regex)
+This function obeys `avy-all-windows' setting.
+RE-BUILDER is a function that takes a string and returns a regex.
+When nil, `regexp-quote' is used.
+If a group is captured, the first group is highlighted.
+Otherwise, the whole regex is highlighted."
+ (let ((str "")
+ (re-builder (or re-builder #'regexp-quote))
+ char break overlays regex)
(unwind-protect
(progn
+ (avy--make-backgrounds
+ (avy-window-list))
(while (and (not break)
(setq char
- (read-char (format "char%s: "
+ (read-char (format "%d char%s: "
+ (length overlays)
(if (string= str "")
str
(format " (%s)" str)))
@@ -1237,12 +2009,17 @@ This function obeys `avy-all-windows' setting."
(cond
;; Handle RET
((= char 13)
- (setq break t))
- ;; Handle DEL
- ((= char 127)
+ (if avy-enter-times-out
+ (setq break t)
+ (setq str (concat str (list ?\n)))))
+ ;; Handle C-h, DEL
+ ((memq char avy-del-last-char-by)
(let ((l (length str)))
(when (>= l 1)
(setq str (substring str 0 (1- l))))))
+ ;; Handle ESC
+ ((= char 27)
+ (keyboard-quit))
(t
(setq str (concat str (list char)))))
;; Highlight
@@ -1256,16 +2033,18 @@ This function obeys `avy-all-windows' setting."
(window-end (selected-window) t)))
(save-excursion
(goto-char (car pair))
- (setq regex (regexp-quote str))
+ (setq regex (funcall re-builder str))
(while (re-search-forward regex (cdr pair) t)
- (unless (get-char-property (1- (point)) 'invisible)
- (let ((ov (make-overlay
- (match-beginning 0)
- (match-end 0))))
+ (unless (not (avy--visible-p (1- (point))))
+ (let* ((idx (if (= (length (match-data)) 4) 1 0))
+ (ov (make-overlay
+ (match-beginning idx) (match-end idx))))
(setq found t)
(push ov overlays)
- (overlay-put ov 'window (selected-window))
- (overlay-put ov 'face
'avy-goto-char-timer-face)))))))
+ (overlay-put
+ ov 'window (selected-window))
+ (overlay-put
+ ov 'face 'avy-goto-char-timer-face)))))))
;; No matches at all, so there's surely a typo in the input.
(unless found (beep)))))
(nreverse (mapcar (lambda (ov)
@@ -1274,7 +2053,8 @@ This function obeys `avy-all-windows' setting."
(overlay-get ov 'window)))
overlays)))
(dolist (ov overlays)
- (delete-overlay ov)))))
+ (delete-overlay ov))
+ (avy--done))))
;;;###autoload
(defun avy-goto-char-timer (&optional arg)
@@ -1285,19 +2065,16 @@ The window scope is determined by `avy-all-windows'
(ARG negates it)."
(not avy-all-windows)
avy-all-windows)))
(avy-with avy-goto-char-timer
- (avy--process
- (avy--read-candidates)
- (avy--style-fn avy-style)))))
-
-(defvar avy-ring (make-ring 20)
- "Hold the window and point history.")
+ (avy-process
+ (avy--read-candidates)))))
(defun avy-push-mark ()
"Store the current point and window."
- (ring-insert avy-ring
- (cons (point) (selected-window)))
- (unless (region-active-p)
- (push-mark)))
+ (let ((inhibit-message t))
+ (ring-insert avy-ring
+ (cons (point) (selected-window)))
+ (unless (region-active-p)
+ (push-mark))))
(defun avy-pop-mark ()
"Jump back to the last location of `avy-push-mark'."
@@ -1317,12 +2094,48 @@ The window scope is determined by `avy-all-windows'
(ARG negates it)."
(error
(set-mark-command 4)))))
-(define-obsolete-function-alias
- 'avy--goto 'identity "0.3.0"
- "Don't use this function any more.
-`avy--process' will do the jump all by itself.")
+;; ** Org-mode
+(defvar org-reverse-note-order)
+(declare-function org-refile "org")
+(declare-function org-back-to-heading "org")
+(declare-function org-reveal "org")
+
+(defvar org-after-refile-insert-hook)
-(define-obsolete-function-alias 'avy--with-avy-keys 'avy-with "0.3.0")
+(defun avy-org-refile-as-child ()
+ "Refile current heading as first child of heading selected with `avy.'"
+ ;; Inspired by `org-teleport':
http://kitchingroup.cheme.cmu.edu/blog/2016/03/18/Org-teleport-headlines/
+ (interactive)
+ (let* ((org-reverse-note-order t)
+ (marker (save-excursion
+ (avy-with avy-goto-line
+ (unless (eq 't (avy-jump (rx bol (1+ "*") (1+ space))))
+ ;; `avy-jump' returns t when aborted with C-g.
+ (point-marker)))))
+ (filename (buffer-file-name (or (buffer-base-buffer (marker-buffer
marker))
+ (marker-buffer marker))))
+ (rfloc (list nil filename nil marker))
+ ;; Ensure the refiled heading is visible.
+ (org-after-refile-insert-hook (if (member 'org-reveal
org-after-refile-insert-hook)
+ org-after-refile-insert-hook
+ (cons #'org-reveal
org-after-refile-insert-hook))))
+ (when marker
+ ;; Only attempt refile if avy session was not aborted.
+ (org-refile nil nil rfloc))))
+
+(defun avy-org-goto-heading-timer (&optional arg)
+ "Read one or many characters and jump to matching Org headings.
+The window scope is determined by `avy-all-windows' (ARG negates it)."
+ (interactive "P")
+ (let ((avy-all-windows (if arg
+ (not avy-all-windows)
+ avy-all-windows)))
+ (avy-with avy-goto-char-timer
+ (avy-process
+ (avy--read-candidates
+ (lambda (input)
+ (format "^\\*+ .*\\(%s\\)" input))))
+ (org-back-to-heading))))
(provide 'avy)
diff --git a/packages/avy/doc/Changelog.org b/packages/avy/doc/Changelog.org
index 6d5b80c..1c9ea2f 100644
--- a/packages/avy/doc/Changelog.org
+++ b/packages/avy/doc/Changelog.org
@@ -141,7 +141,7 @@ Pros and cons of =de-bruijn= over other styles:
clumped up chars, which is truncated for other styles
- a con is that the decision path is of the same length (e.g. 2 or 3)
for all candidates, while with other styles it's possible to have a
- few candidets with a shorter path.
+ few candidates with a shorter path.
See [[https://github.com/abo-abo/avy/issues/51][#51]] and
[[https://github.com/abo-abo/avy/issues/5][#5]].
@@ -323,3 +323,176 @@ Allows to customize the behavior of =avy-goto-subword-0=
and
=avy-goto-subword-1= by adding extra chars that should match as word
constituents.
See [[https://github.com/abo-abo/avy/issues/116][#116]].
+* 0.5.0
+** Fixes
+*** el:avy-action-copy
+Save selected window and frame. See
[[https://github.com/abo-abo/avy/issues/133][#133]].
+
+Copy line for el:avy-goto-line. See
[[https://github.com/abo-abo/avy/issues/191][#191]].
+*** el:avy-read
+Make ~C-g~ and ~ESC~ fail silently when reading char. See
[[https://github.com/abo-abo/avy/issues/137][#137]].
+
+Display error message on mouse clicks. See
[[https://github.com/abo-abo/avy/issues/226][#226]].
+
+Update el:avy-current-path before returning. See
[[https://github.com/abo-abo/avy/issues/226][#226]].
+
+Quit on ~ESC~. See [[https://github.com/abo-abo/avy/issues/249][#249]].
+
+Fix for el:org-toggle-link-display. See
[[https://github.com/abo-abo/avy/issues/261][#261]].
+
+Fix for el:buffer-invisibility-spec being t. See
[[https://github.com/abo-abo/avy/issues/264][#264]].
+
+Allow "invisible" 'org-link. See
[[https://github.com/abo-abo/avy/issues/269][#269]].
+*** el:avy-goto-word-1
+Works for "^A"-"^Z", see [[https://github.com/abo-abo/avy/issues/167][#167]].
+*** el:avy-goto-subword-0
+Add char at window start if empty, See
[[https://github.com/abo-abo/avy/issues/145][#145]].
+
+Add option to limit scope. See
[[https://github.com/abo-abo/avy/issues/235][#235]].
+*** el:avy-goto-subword-1
+Check el:char-after. See [[https://github.com/abo-abo/avy/issues/163][#163]].
+*** el:avy-isearch
+Escape regex. See [[https://github.com/abo-abo/avy/issues/147][#147]].
+*** el:avy-goto-char-2
+Translate ~RET~ to ~C-j~. See
[[https://github.com/abo-abo/avy/issues/153][#153]].
+*** el:avy-action-goto
+Add el:raise-frame.
+*** el:avy-goto-char-timer
+Allow ~C-h~ to delete. See [[https://github.com/abo-abo/avy/issues/193][#193]].
+
+Obey el:avy-background for the initial search. See
[[https://github.com/abo-abo/avy/issues/259][#259]].
+*** el:avy-goto-line
+Fix for empty buffer. See [[https://github.com/abo-abo/avy/issues/238][#238]].
+
+Add ability to display candidates from bottom to top. See
[[https://github.com/abo-abo/avy/issues/236][#236]].
+*** el:avy--overlay-at-full
+More consistent face order.
+See [[https://github.com/abo-abo/avy/issues/270][#270]].
+*** documentation
+See [[https://github.com/abo-abo/avy/issues/223][#223]],
[[https://github.com/abo-abo/avy/issues/226][#226]],
[[https://github.com/abo-abo/avy/issues/218][#218]],
[[https://github.com/abo-abo/avy/issues/245][#245]],
[[https://github.com/abo-abo/avy/issues/262][#262]].
+
+** New Features
+*** API
+New functions have been added as drop-in replacements of double-dash (private)
avy
+functions that were used in other packages and configs. Please replace the
references to
+the obsolete functions.
+
+**** el:avy-jump
+New API function to replace el:avy--generic-jump. See
[[https://github.com/abo-abo/avy/issues/265][#265]],
[[https://github.com/abo-abo/avy/issues/267][#267]].
+**** el:avy-process
+New API function to replace el:avy--process. See
[[https://github.com/abo-abo/avy/issues/266][#266]].
+
+*** New actions
+**** el:avy-action-kill-stay
+Kill a word with el:avy-goto-char without moving there.
+Bound to ~X~.
+**** el:avy-action-ispell
+Auto-correct word at point. See
[[https://github.com/abo-abo/avy/issues/142][#142]],
[[https://github.com/abo-abo/avy/issues/160][#160]],
[[https://github.com/abo-abo/avy/issues/161][#161]].
+Bound to ~i~.
+**** el:avy-action-yank
+Yank sexp starting at selected point at the current point. See
[[https://github.com/abo-abo/avy/issues/183][#183]].
+Bound to ~y~.
+**** el:avy-action-teleport
+Kill sexp starting on selected point and yank into the current location. See
[[https://github.com/abo-abo/avy/issues/207][#207]].
+Bound to ~t~.
+**** el:avy-action-zap-to-char
+Kill from point up to selected point. See
[[https://github.com/abo-abo/avy/issues/234][#234]].
+Bound to ~z~.
+
+*** New defcustoms
+**** New el:avy-style setting: 'words
+Use this setting:
+#+begin_src elisp
+(setq avy-style 'words)
+#+end_src
+And you'll see overlays like "by", "if", "is", "it", "my" for 2-letter
sequences, and
+"can", "car", "cog" for 3-letter sequences. You might find them easier to type
than "hla",
+"lls" and "jhl". But you will have to adjust your el:avy-dispatch-alist, e.g.
to use only
+upper case characters.
+
+See [[https://github.com/abo-abo/avy/issues/210][#210]],
[[https://github.com/abo-abo/avy/issues/219][#219]].
+**** el:avy-orders-alist
+Use it to customize the order of candidates with relation to point. The
default is for
+el:avy-goto-char to have the shortest overlay for candidates closest to point.
+See [[https://github.com/abo-abo/avy/issues/242][#242]].
+**** el:avy-indent-line-overlay
+When non-nil el:avy-goto-line will display the line overlay next to the first
+non-whitespace character of each line. See
[[https://github.com/abo-abo/avy/issues/244][#244]].
+**** el:avy-single-candidate-jump
+When non-nil, and there is only one candidate, jump there. See
[[https://github.com/abo-abo/avy/issues/250][#250]].
+**** el:avy-del-last-char-by
+Customize keys which delete the last read char. The defaults are ~C-h~ and
~DEL~. See [[https://github.com/abo-abo/avy/issues/251][#251]].
+**** el:avy-goto-word-0-regexp
+Customize el:avy-goto-word-0. See
[[https://github.com/abo-abo/avy/issues/136][#136]],
[[https://github.com/abo-abo/avy/issues/156][#156]].
+**** el:avy-pre-action
+Function to all before el:avy-action. See
[[https://github.com/abo-abo/avy/issues/260][#260]].
+**** el:avy-enter-times-out
+When non-nil (the default), ~RET~ exists el:avy-goto-char-timer early.
+When nil, it matches a newline.
+See [[https://github.com/abo-abo/avy/issues/220][#220]],
[[https://github.com/abo-abo/avy/issues/225][#225]].
+
+*** New commands
+**** el:avy-move-region
+Select two lines and move the text between them above the current line.
+See [[https://github.com/abo-abo/avy/issues/75][#75]],
[[https://github.com/abo-abo/avy/issues/187][#187]],
[[https://github.com/abo-abo/avy/issues/188][#188]].
+**** el:avy-goto-end-of-line
+Call el:avy-goto-line and move to the end of the line. See
[[https://github.com/abo-abo/avy/issues/240][#240]].
+
+**** el:avy-linum-mode
+Minor mode that uses avy hints for el:linum-mode.
+
+**** el:avy-resume
+Holds last command avy command after user input. This is a quick way to bring
back the
+same markers after a jump. See
[[https://github.com/abo-abo/avy/issues/157][#157]],
[[https://github.com/abo-abo/avy/issues/165][#165]].
+**** el:avy-next
+Go to the next candidate after el:avy-read.
+Example config:
+
+#+begin_src elisp
+(defhydra hydra-avy-cycle ()
+ ("j" avy-next "next")
+ ("k" avy-prev "prev")
+ ("q" nil "quit"))
+
+(global-set-key (kbd "C-M-'") 'hydra-avy-cycle/body)
+#+end_src
+
+After e.g. el:avy-goto-char or el:avy-goto-char-timer, use the above hydra to
cycle
+between the last candidates. See
[[https://github.com/abo-abo/avy/issues/254][#254]].
+**** *-above and *-below variants
+Command versions restricted to matches before or after the point.
+
+See [[https://github.com/abo-abo/avy/issues/148][#148]]:
+- el:avy-goto-char-2-above
+- el:avy-goto-char-2-below
+
+See [[https://github.com/abo-abo/avy/issues/151][#151]]:
+- el:avy-goto-word-1-above
+- el:avy-goto-word-1-below
+
+See [[https://github.com/abo-abo/avy/issues/156][#156]]:
+- el:avy-goto-symbol-1-above
+- el:avy-goto-symbol-1-below
+
+See [[https://github.com/abo-abo/avy/issues/186][#186]]:
+- el:avy-goto-word-0-below
+- el:avy-goto-word-0-above
+**** kill and save region functionality
+New avy-enabled commands:
+- el:avy-kill-whole-line
+- el:avy-kill-region
+- el:avy-kill-ring-save-whole-line
+- el:avy-kill-ring-save-region
+
+See [[https://github.com/abo-abo/avy/issues/158][#158]].
+**** org-mode functionality
+New avy-enabled commands:
+- el:avy-org-refile-as-child
+- el:avy-org-goto-heading-timer
+See [[https://github.com/abo-abo/avy/issues/214][#214]],
[[https://github.com/abo-abo/avy/issues/258][#258]].
+*** el:avy-goto-char-timer
+Show the number of matches so far in the prompt. See
[[https://github.com/abo-abo/avy/issues/253][#253]].
+*** el:avy-read
+Ignore mistyping when no candidates are available. See
[[https://github.com/abo-abo/avy/issues/256][#256]].
+
+When the overlays are shown, press ~?~ to get dispatch help.
diff --git a/packages/avy/targets/avy-init.el b/packages/avy/targets/avy-init.el
index 9ce46bb..6751b74 100644
--- a/packages/avy/targets/avy-init.el
+++ b/packages/avy/targets/avy-init.el
@@ -22,11 +22,5 @@
(add-to-list 'load-path default-directory)
(mapc #'byte-compile-file '("avy.el"))
(require 'avy)
-(if (fboundp 'checkdoc-file)
- (checkdoc-file "avy.el")
- (require 'checkdoc)
- (with-current-buffer (find-file "avy.el")
- (checkdoc-current-buffer t)))
-
(global-set-key (kbd "C-c j") 'avy-goto-char)
(global-set-key (kbd "C-'") 'avy-goto-char-2)
diff --git a/packages/avy/targets/checkdoc.el b/packages/avy/targets/checkdoc.el
new file mode 100644
index 0000000..be3823b
--- /dev/null
+++ b/packages/avy/targets/checkdoc.el
@@ -0,0 +1,2 @@
+(checkdoc-file "avy-test.el")
+(checkdoc-file "avy.el")
- [elpa] master updated (1744d5a -> 4acafa6), Oleh Krehel, 2019/05/11
- [elpa] master 4acafa6 110/110: Merge commit '0e59474430cbfbe7caf2a41cf7935fc613648c49' from avy,
Oleh Krehel <=
- [elpa] master b408f76 108/110: doc/Changelog.org: quote issues, Oleh Krehel, 2019/05/11
- [elpa] master f2cf43b 107/110: doc/Changelog.org: Release 0.5.0, Oleh Krehel, 2019/05/11
- [elpa] master 0e59474 109/110: avy.el (avy--read-candidates): Fix docstring, Oleh Krehel, 2019/05/11
- [elpa] master 85b5d57 104/110: avy.el (avy-jump): Add predicate argument, Oleh Krehel, 2019/05/11
- [elpa] master 152b07f 102/110: avy.el (avy-process): Return res, Oleh Krehel, 2019/05/11
- [elpa] master a723090 106/110: avy.el (avy--overlay-at-full): More consistent face order, Oleh Krehel, 2019/05/11
- [elpa] master 5b3676f 095/110: avy.el (avy-next): New command to go to the next candidate after avy-read, Oleh Krehel, 2019/05/11
- [elpa] master 4d52b5c 105/110: avy.el (avy--line-cands): Allow "invisible" 'org-link, Oleh Krehel, 2019/05/11
- [elpa] master e9f4d85 092/110: avy.el (avy-goto-char-timer): Obey avy-background for initial search, Oleh Krehel, 2019/05/11
- [elpa] master 9124022 097/110: avy.el (avy--generic-jump): Update docstring about removed arg, Oleh Krehel, 2019/05/11