zsh-autosuggestions/zsh-autosuggestions.zsh

777 lines
23 KiB
Bash
Raw Normal View History

2016-02-05 23:14:08 +01:00
# Fish-like fast/unobtrusive autosuggestions for zsh.
# https://github.com/zsh-users/zsh-autosuggestions
2018-05-21 19:38:41 +02:00
# v0.4.3
2016-02-05 23:14:08 +01:00
# Copyright (c) 2013 Thiago de Arruda
2018-05-21 18:52:41 +02:00
# Copyright (c) 2016-2018 Eric Freese
2016-02-05 23:14:08 +01:00
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use,
# copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following
# conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
2016-02-14 08:29:43 +01:00
#--------------------------------------------------------------------#
# Global Configuration Variables #
#--------------------------------------------------------------------#
2016-02-05 23:14:08 +01:00
# Color to use when highlighting suggestion
# Uses format of `region_highlight`
# More info: http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Zle-Widgets
ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'
# Prefix to use when saving original versions of bound widgets
ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
# Strategies to use to fetch a suggestion
# Will try each strategy in order until a suggestion is returned
ZSH_AUTOSUGGEST_STRATEGY=(history)
2016-02-05 23:14:08 +01:00
# Widgets that clear the suggestion
ZSH_AUTOSUGGEST_CLEAR_WIDGETS=(
history-search-forward
history-search-backward
history-beginning-search-forward
history-beginning-search-backward
history-substring-search-up
history-substring-search-down
up-line-or-beginning-search
down-line-or-beginning-search
2016-02-05 23:14:08 +01:00
up-line-or-history
down-line-or-history
accept-line
)
# Widgets that accept the entire suggestion
ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(
forward-char
end-of-line
vi-forward-char
vi-end-of-line
vi-add-eol
2016-02-05 23:14:08 +01:00
)
# Widgets that accept the entire suggestion and execute it
ZSH_AUTOSUGGEST_EXECUTE_WIDGETS=(
)
2016-02-05 23:14:08 +01:00
# Widgets that accept the suggestion as far as the cursor moves
ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS=(
forward-word
emacs-forward-word
2016-02-05 23:14:08 +01:00
vi-forward-word
vi-forward-word-end
vi-forward-blank-word
vi-forward-blank-word-end
vi-find-next-char
vi-find-next-char-skip
2016-02-05 23:14:08 +01:00
)
# Widgets that should be ignored (globbing supported but must be escaped)
ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(
orig-\*
beep
run-help
set-local-history
which-command
yank
2017-12-24 22:46:20 +01:00
yank-pop
)
2016-07-18 11:56:21 +02:00
# Max size of buffer to trigger autosuggestion. Leave undefined for no upper bound.
ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=
2017-01-29 18:39:07 +01:00
# Pty name for calculating autosuggestions asynchronously
ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=zsh_autosuggest_async_pty
# Pty name for capturing completions for completion suggestion strategy
ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME=zsh_autosuggest_completion_pty
2017-01-29 18:39:07 +01:00
#--------------------------------------------------------------------#
# Utility Functions #
#--------------------------------------------------------------------#
_zsh_autosuggest_escape_command() {
setopt localoptions EXTENDED_GLOB
# Escape special chars in the string (requires EXTENDED_GLOB)
echo -E "${1//(#m)[\"\'\\()\[\]|*?~]/\\$MATCH}"
}
2016-02-14 08:29:43 +01:00
#--------------------------------------------------------------------#
# Widget Helpers #
#--------------------------------------------------------------------#
2016-02-05 23:14:08 +01:00
_zsh_autosuggest_incr_bind_count() {
if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]++))
else
_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=1
fi
typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
}
_zsh_autosuggest_get_bind_count() {
if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
else
typeset -gi bind_count=0
fi
}
2016-02-05 23:14:08 +01:00
# Bind a single widget to an autosuggest widget, saving a reference to the original widget
_zsh_autosuggest_bind_widget() {
typeset -gA _ZSH_AUTOSUGGEST_BIND_COUNTS
2016-02-05 23:14:08 +01:00
local widget=$1
local autosuggest_action=$2
2016-02-05 23:14:08 +01:00
local prefix=$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX
local -i bind_count
# Save a reference to the original widget
2016-02-05 23:14:08 +01:00
case $widgets[$widget] in
# Already bound
2016-02-15 16:31:00 +01:00
user:_zsh_autosuggest_(bound|orig)_*);;
2016-02-05 23:14:08 +01:00
# User-defined widget
user:*)
_zsh_autosuggest_incr_bind_count $widget
zle -N $prefix${bind_count}-$widget ${widgets[$widget]#*:}
2016-02-05 23:14:08 +01:00
;;
# Built-in widget
builtin)
_zsh_autosuggest_incr_bind_count $widget
eval "_zsh_autosuggest_orig_${(q)widget}() { zle .${(q)widget} }"
zle -N $prefix${bind_count}-$widget _zsh_autosuggest_orig_$widget
2016-02-05 23:14:08 +01:00
;;
# Completion widget
completion:*)
_zsh_autosuggest_incr_bind_count $widget
eval "zle -C $prefix${bind_count}-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
2016-02-05 23:14:08 +01:00
;;
esac
_zsh_autosuggest_get_bind_count $widget
2016-02-15 16:31:00 +01:00
# Pass the original widget's name explicitly into the autosuggest
# function. Use this passed in widget name to call the original
# widget instead of relying on the $WIDGET variable being set
# correctly. $WIDGET cannot be trusted because other plugins call
# zle without the `-w` flag (e.g. `zle self-insert` instead of
# `zle self-insert -w`).
eval "_zsh_autosuggest_bound_${bind_count}_${(q)widget}() {
_zsh_autosuggest_widget_$autosuggest_action $prefix$bind_count-${(q)widget} \$@
2016-02-15 16:31:00 +01:00
}"
2016-02-05 23:14:08 +01:00
# Create the bound widget
zle -N -- $widget _zsh_autosuggest_bound_${bind_count}_$widget
2016-02-05 23:14:08 +01:00
}
# Map all configured widgets to the right autosuggest widgets
_zsh_autosuggest_bind_widgets() {
local widget
local ignore_widgets
ignore_widgets=(
.\*
_\*
zle-\*
autosuggest-\*
$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\*
$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
)
2016-02-05 23:14:08 +01:00
# Find every widget we might want to bind and bind it appropriately
for widget in ${${(f)"$(builtin zle -la)"}:#${(j:|:)~ignore_widgets}}; do
if [[ -n ${ZSH_AUTOSUGGEST_CLEAR_WIDGETS[(r)$widget]} ]]; then
_zsh_autosuggest_bind_widget $widget clear
elif [[ -n ${ZSH_AUTOSUGGEST_ACCEPT_WIDGETS[(r)$widget]} ]]; then
_zsh_autosuggest_bind_widget $widget accept
elif [[ -n ${ZSH_AUTOSUGGEST_EXECUTE_WIDGETS[(r)$widget]} ]]; then
_zsh_autosuggest_bind_widget $widget execute
elif [[ -n ${ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS[(r)$widget]} ]]; then
_zsh_autosuggest_bind_widget $widget partial_accept
2016-02-05 23:14:08 +01:00
else
# Assume any unspecified widget might modify the buffer
_zsh_autosuggest_bind_widget $widget modify
2016-02-05 23:14:08 +01:00
fi
done
}
2016-02-15 16:31:00 +01:00
# Given the name of an original widget and args, invoke it, if it exists
2016-02-05 23:14:08 +01:00
_zsh_autosuggest_invoke_original_widget() {
# Do nothing unless called with at least one arg
(( $# )) || return 0
2016-03-06 05:03:14 +01:00
local original_widget_name="$1"
2016-02-15 16:31:00 +01:00
shift
2016-02-05 23:14:08 +01:00
if (( ${+widgets[$original_widget_name]} )); then
zle $original_widget_name -- $@
2016-02-05 23:14:08 +01:00
fi
}
2016-02-14 08:29:43 +01:00
#--------------------------------------------------------------------#
# Highlighting #
#--------------------------------------------------------------------#
2016-02-05 23:14:08 +01:00
# If there was a highlight, remove it
_zsh_autosuggest_highlight_reset() {
2016-03-15 04:50:04 +01:00
typeset -g _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
if [[ -n "$_ZSH_AUTOSUGGEST_LAST_HIGHLIGHT" ]]; then
2016-02-05 23:14:08 +01:00
region_highlight=("${(@)region_highlight:#$_ZSH_AUTOSUGGEST_LAST_HIGHLIGHT}")
unset _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
fi
}
# If there's a suggestion, highlight it
_zsh_autosuggest_highlight_apply() {
2016-03-15 04:50:04 +01:00
typeset -g _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
if (( $#POSTDISPLAY )); then
typeset -g _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT="$#BUFFER $(($#BUFFER + $#POSTDISPLAY)) $ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE"
region_highlight+=("$_ZSH_AUTOSUGGEST_LAST_HIGHLIGHT")
2016-02-05 23:14:08 +01:00
else
unset _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
fi
}
2016-02-14 08:29:43 +01:00
#--------------------------------------------------------------------#
# Autosuggest Widget Implementations #
#--------------------------------------------------------------------#
2016-02-05 23:14:08 +01:00
# Disable suggestions
_zsh_autosuggest_disable() {
typeset -g _ZSH_AUTOSUGGEST_DISABLED
_zsh_autosuggest_clear
}
# Enable suggestions
_zsh_autosuggest_enable() {
unset _ZSH_AUTOSUGGEST_DISABLED
if (( $#BUFFER )); then
_zsh_autosuggest_fetch
fi
}
# Toggle suggestions (enable/disable)
_zsh_autosuggest_toggle() {
if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then
_zsh_autosuggest_enable
else
_zsh_autosuggest_disable
fi
}
2016-02-05 23:14:08 +01:00
# Clear the suggestion
_zsh_autosuggest_clear() {
# Remove the suggestion
unset POSTDISPLAY
_zsh_autosuggest_invoke_original_widget $@
2016-02-05 23:14:08 +01:00
}
# Modify the buffer and get a new suggestion
_zsh_autosuggest_modify() {
local -i retval
# Only available in zsh >= 5.4
local -i KEYS_QUEUED_COUNT
# Save the contents of the buffer/postdisplay
local orig_buffer="$BUFFER"
local orig_postdisplay="$POSTDISPLAY"
2016-07-20 05:04:18 +02:00
# Clear suggestion while waiting for next one
unset POSTDISPLAY
# Original widget may modify the buffer
_zsh_autosuggest_invoke_original_widget $@
retval=$?
2016-02-05 23:14:08 +01:00
# Don't fetch a new suggestion if there's more input to be read immediately
if (( $PENDING > 0 )) || (( $KEYS_QUEUED_COUNT > 0 )); then
POSTDISPLAY="$orig_postdisplay"
return $retval
fi
# Optimize if manually typing in the suggestion
if (( $#BUFFER > $#orig_buffer )); then
local added=${BUFFER#$orig_buffer}
# If the string added matches the beginning of the postdisplay
if [[ "$added" = "${orig_postdisplay:0:$#added}" ]]; then
POSTDISPLAY="${orig_postdisplay:$#added}"
return $retval
fi
fi
# Don't fetch a new suggestion if the buffer hasn't changed
if [[ "$BUFFER" = "$orig_buffer" ]]; then
POSTDISPLAY="$orig_postdisplay"
return $retval
fi
# Bail out if suggestions are disabled
if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then
return $?
fi
2016-02-05 23:14:08 +01:00
# Get a new suggestion if the buffer is not empty after modification
if (( $#BUFFER > 0 )); then
if [[ -z "$ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" ]] || (( $#BUFFER <= $ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE )); then
2017-01-27 23:18:26 +01:00
_zsh_autosuggest_fetch
fi
2016-02-05 23:14:08 +01:00
fi
return $retval
2016-02-05 23:14:08 +01:00
}
2017-01-27 23:18:26 +01:00
# Fetch a new suggestion based on what's currently in the buffer
_zsh_autosuggest_fetch() {
if [[ -n "${ZSH_AUTOSUGGEST_USE_ASYNC+x}" ]]; then
2017-01-27 23:18:26 +01:00
_zsh_autosuggest_async_request "$BUFFER"
else
local suggestion
_zsh_autosuggest_fetch_suggestion "$BUFFER"
2017-01-27 23:18:26 +01:00
_zsh_autosuggest_suggest "$suggestion"
fi
}
# Offer a suggestion
_zsh_autosuggest_suggest() {
local suggestion="$1"
if [[ -n "$suggestion" ]] && (( $#BUFFER )); then
2017-01-27 23:18:26 +01:00
POSTDISPLAY="${suggestion#$BUFFER}"
else
unset POSTDISPLAY
fi
}
2016-02-05 23:14:08 +01:00
# Accept the entire suggestion
_zsh_autosuggest_accept() {
2016-03-15 04:41:14 +01:00
local -i max_cursor_pos=$#BUFFER
# When vicmd keymap is active, the cursor can't move all the way
# to the end of the buffer
if [[ "$KEYMAP" = "vicmd" ]]; then
2016-03-15 04:41:14 +01:00
max_cursor_pos=$((max_cursor_pos - 1))
fi
2016-02-05 23:14:08 +01:00
# Only accept if the cursor is at the end of the buffer
if [[ $CURSOR = $max_cursor_pos ]]; then
2016-02-05 23:14:08 +01:00
# Add the suggestion to the buffer
BUFFER="$BUFFER$POSTDISPLAY"
# Remove the suggestion
unset POSTDISPLAY
# Move the cursor to the end of the buffer
CURSOR=${#BUFFER}
fi
_zsh_autosuggest_invoke_original_widget $@
2016-02-05 23:14:08 +01:00
}
# Accept the entire suggestion and execute it
_zsh_autosuggest_execute() {
# Add the suggestion to the buffer
BUFFER="$BUFFER$POSTDISPLAY"
# Remove the suggestion
unset POSTDISPLAY
# Call the original `accept-line` to handle syntax highlighting or
# other potential custom behavior
_zsh_autosuggest_invoke_original_widget "accept-line"
}
2016-02-05 23:14:08 +01:00
# Partially accept the suggestion
_zsh_autosuggest_partial_accept() {
local -i retval cursor_loc
2016-02-05 23:14:08 +01:00
# Save the contents of the buffer so we can restore later if needed
2016-03-06 05:03:14 +01:00
local original_buffer="$BUFFER"
2016-02-05 23:14:08 +01:00
# Temporarily accept the suggestion.
BUFFER="$BUFFER$POSTDISPLAY"
# Original widget moves the cursor
_zsh_autosuggest_invoke_original_widget $@
retval=$?
2016-02-05 23:14:08 +01:00
# Normalize cursor location across vi/emacs modes
cursor_loc=$CURSOR
if [[ "$KEYMAP" = "vicmd" ]]; then
cursor_loc=$((cursor_loc + 1))
fi
2016-02-05 23:14:08 +01:00
# If we've moved past the end of the original buffer
if (( $cursor_loc > $#original_buffer )); then
2016-02-05 23:14:08 +01:00
# Set POSTDISPLAY to text right of the cursor
POSTDISPLAY="${BUFFER[$(($cursor_loc + 1)),$#BUFFER]}"
2016-02-05 23:14:08 +01:00
# Clip the buffer at the cursor
BUFFER="${BUFFER[1,$cursor_loc]}"
2016-02-05 23:14:08 +01:00
else
# Restore the original buffer
2016-03-06 05:03:14 +01:00
BUFFER="$original_buffer"
2016-02-05 23:14:08 +01:00
fi
return $retval
2016-02-05 23:14:08 +01:00
}
for action in clear modify fetch suggest accept partial_accept execute enable disable toggle; do
eval "_zsh_autosuggest_widget_$action() {
local -i retval
_zsh_autosuggest_highlight_reset
_zsh_autosuggest_$action \$@
retval=\$?
_zsh_autosuggest_highlight_apply
2017-01-27 23:18:26 +01:00
zle -R
return \$retval
}"
done
2016-02-05 23:14:08 +01:00
2017-01-27 23:18:26 +01:00
zle -N autosuggest-fetch _zsh_autosuggest_widget_fetch
zle -N autosuggest-suggest _zsh_autosuggest_widget_suggest
2016-02-05 23:14:08 +01:00
zle -N autosuggest-accept _zsh_autosuggest_widget_accept
zle -N autosuggest-clear _zsh_autosuggest_widget_clear
zle -N autosuggest-execute _zsh_autosuggest_widget_execute
zle -N autosuggest-enable _zsh_autosuggest_widget_enable
zle -N autosuggest-disable _zsh_autosuggest_widget_disable
zle -N autosuggest-toggle _zsh_autosuggest_widget_toggle
2016-02-05 23:14:08 +01:00
#--------------------------------------------------------------------#
# Completion Suggestion Strategy #
#--------------------------------------------------------------------#
# Fetches suggestions from zsh's completion engine
# Based on https://github.com/Valodim/zsh-capture-completion
#
_zsh_autosuggest_capture_setup() {
zmodload zsh/zutil # For `zparseopts`
2018-05-24 06:04:47 +02:00
# Ensure completions have been initialized
if ! whence compdef >/dev/null; then
autoload -Uz compinit && compinit
fi
# There is a bug in zpty module (fixed in zsh/master) by which a
# zpty that exits will kill all zpty processes that were forked
# before it. Here we set up a zsh exit hook to SIGKILL the zpty
# process immediately, before it has a chance to kill any other
# zpty processes.
zshexit() {
kill -KILL $$
sleep 1 # Block for long enough for the signal to come through
}
# Never group stuff!
zstyle ':completion:*' list-grouped false
# No list separator, this saves some stripping later on
zstyle ':completion:*' list-separator ''
# Override compadd (this is our hook)
compadd () {
setopt localoptions norcexpandparam
# Just delegate and leave if any of -O, -A or -D are given
if [[ ${@[1,(i)(-|--)]} == *-(O|A|D)\ * ]]; then
builtin compadd "$@"
return $?
fi
# Capture completions by injecting -A parameter into the compadd call.
# This takes care of matching for us.
typeset -a __hits
builtin compadd -A __hits "$@"
# Exit if no completion results
[[ -n $__hits ]] || return
# Extract prefixes and suffixes from compadd call. we can't do zsh's cool
# -r remove-func magic, but it's better than nothing.
typeset -A apre hpre hsuf asuf
zparseopts -E P:=apre p:=hpre S:=asuf s:=hsuf
# Print the first match
echo -nE - $'\0'$IPREFIX$apre$hpre$__hits[1]$dsuf$hsuf$asuf$'\0'
}
}
_zsh_autosuggest_capture_widget() {
_zsh_autosuggest_capture_setup
zle complete-word
}
zle -N autosuggest-capture-completion _zsh_autosuggest_capture_widget
_zsh_autosuggest_capture_buffer() {
local BUFFERCONTENT="$1"
_zsh_autosuggest_capture_setup
zmodload zsh/parameter # For `$functions`
# Make vared completion work as if for a normal command line
# https://stackoverflow.com/a/7057118/154703
autoload +X _complete
functions[_original_complete]=$functions[_complete]
_complete () {
unset 'compstate[vared]'
_original_complete "$@"
}
# Open zle with buffer set so we can capture completions for it
vared BUFFERCONTENT
}
_zsh_autosuggest_capture_completion() {
zmodload zsh/zpty 2>/dev/null || return
typeset -g completion
local line REPLY
# Zle will be inactive if we are in async mode
if zle; then
zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME zle autosuggest-capture-completion
else
zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_buffer "\$1"
zpty -w $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME $'\t'
fi
# The completion result is surrounded by null bytes, so read the
# content between the first two null bytes.
zpty -r $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME line '*'$'\0''*'$'\0'
# On older versions of zsh, we sometimes get extra bytes after the
# second null byte, so trim those off the end
completion="${${${(M)line:#*$'\0'*$'\0'*}#*$'\0'}%%$'\0'*}"
# Destroy the pty
zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME
}
_zsh_autosuggest_strategy_completion() {
2018-06-11 07:35:22 +02:00
typeset -g suggestion
local completion
# Fetch the first completion result
_zsh_autosuggest_capture_completion "$1"
2018-06-30 23:03:14 +02:00
[[ -z "$completion" ]] && return
# Add the completion string to the buffer to build the full suggestion
local -i i=1
while [[ "$completion" != "${1[$i,-1]}"* ]]; do ((i++)); done
suggestion="${1[1,$i-1]}$completion"
}
#--------------------------------------------------------------------#
# History Suggestion Strategy #
#--------------------------------------------------------------------#
# Suggests the most recent history item that matches the given
# prefix.
#
_zsh_autosuggest_strategy_history() {
# Reset options to defaults and enable LOCAL_OPTIONS
emulate -L zsh
# Enable globbing flags so that we can use (#m)
setopt EXTENDED_GLOB
# Escape backslashes and all of the glob operators so we can use
# this string as a pattern to search the $history associative array.
# - (#m) globbing flag enables setting references for match data
# TODO: Use (b) flag when we can drop support for zsh older than v5.0.8
local prefix="${1//(#m)[\\*?[\]<>()|^~#]/\\$MATCH}"
2017-02-17 03:18:03 +01:00
# Get the history items that match
# - (r) subscript flag makes the pattern match on values
typeset -g suggestion="${history[(r)${prefix}*]}"
}
#--------------------------------------------------------------------#
# Match Previous Command Suggestion Strategy #
#--------------------------------------------------------------------#
# Suggests the most recent history item that matches the given
2016-03-05 03:23:32 +01:00
# prefix and whose preceding history item also matches the most
# recently executed command.
#
2016-03-05 03:23:32 +01:00
# For example, suppose your history has the following entries:
# - pwd
# - ls foo
# - ls bar
# - pwd
#
# Given the history list above, when you type 'ls', the suggestion
# will be 'ls foo' rather than 'ls bar' because your most recently
# executed command (pwd) was previously followed by 'ls foo'.
#
# Note that this strategy won't work as expected with ZSH options that don't
# preserve the history order such as `HIST_IGNORE_ALL_DUPS` or
# `HIST_EXPIRE_DUPS_FIRST`.
_zsh_autosuggest_strategy_match_prev_cmd() {
# Reset options to defaults and enable LOCAL_OPTIONS
emulate -L zsh
# Enable globbing flags so that we can use (#m)
setopt EXTENDED_GLOB
# TODO: Use (b) flag when we can drop support for zsh older than v5.0.8
local prefix="${1//(#m)[\\*?[\]<>()|^~#]/\\$MATCH}"
# Get all history event numbers that correspond to history
# entries that match pattern $prefix*
local history_match_keys
history_match_keys=(${(k)history[(R)$prefix*]})
# By default we use the first history number (most recent history entry)
local histkey="${history_match_keys[1]}"
# Get the previously executed command
local prev_cmd="$(_zsh_autosuggest_escape_command "${history[$((HISTCMD-1))]}")"
# Iterate up to the first 200 history event numbers that match $prefix
for key in "${(@)history_match_keys[1,200]}"; do
# Stop if we ran out of history
[[ $key -gt 1 ]] || break
# See if the history entry preceding the suggestion matches the
# previous command, and use it if it does
2016-03-06 05:03:14 +01:00
if [[ "${history[$((key - 1))]}" == "$prev_cmd" ]]; then
histkey="$key"
break
fi
done
2017-01-27 23:18:26 +01:00
# Give back the matched history entry
typeset -g suggestion="$history[$histkey]"
}
#--------------------------------------------------------------------#
# Fetch Suggestion #
#--------------------------------------------------------------------#
# Loops through all specified strategies and returns a suggestion
# from the first strategy to provide one.
#
_zsh_autosuggest_fetch_suggestion() {
typeset -g suggestion
local -a strategies
local strategy
# Ensure we are working with an array
strategies=(${=ZSH_AUTOSUGGEST_STRATEGY})
for strategy in $strategies; do
# Try to get a suggestion from this strategy
_zsh_autosuggest_strategy_$strategy "$1"
# Break once we've found a suggestion
[[ -n "$suggestion" ]] && break
done
}
2016-07-20 05:04:18 +02:00
#--------------------------------------------------------------------#
# Async #
#--------------------------------------------------------------------#
zmodload zsh/system
_zsh_autosuggest_async_request() {
typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
2016-07-20 05:04:18 +02:00
# If we've got a pending request, cancel it
if [[ -n "$_ZSH_AUTOSUGGEST_ASYNC_FD" ]] && { true <&$_ZSH_AUTOSUGGEST_ASYNC_FD } 2>/dev/null; then
# Close the file descriptor
exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&-
# Assume the child process created a new process group and send
# TERM to the group to attempt to kill all descendent processes
kill -TERM -$_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
fi
# Fork a process to fetch a suggestion and open a pipe to read from it
exec {_ZSH_AUTOSUGGEST_ASYNC_FD}< <(
# Tell parent process our pid
echo $sysparams[pid]
# Fetch and print the suggestion
local suggestion
_zsh_autosuggest_fetch_suggestion "$1"
echo -nE "$suggestion"
)
2016-07-20 05:04:18 +02:00
# Read the pid from the child process
read _ZSH_AUTOSUGGEST_CHILD_PID <&$_ZSH_AUTOSUGGEST_ASYNC_FD
# When the fd is readable, call the response handler
zle -F "$_ZSH_AUTOSUGGEST_ASYNC_FD" _zsh_autosuggest_async_response
2017-01-27 23:18:26 +01:00
}
# Called when new data is ready to be read from the pipe
2017-01-25 03:53:26 +01:00
# First arg will be fd ready for reading
# Second arg will be passed in case of error
2017-01-27 23:18:26 +01:00
_zsh_autosuggest_async_response() {
# Read everything from the fd and give it as a suggestion
zle autosuggest-suggest -- "$(<&$1)"
2017-01-25 03:53:26 +01:00
# Remove the handler and close the fd
zle -F "$1"
exec {1}<&-
2016-07-20 05:04:18 +02:00
}
2016-02-14 08:29:43 +01:00
#--------------------------------------------------------------------#
# Start #
#--------------------------------------------------------------------#
2016-02-05 23:14:08 +01:00
# Start the autosuggestion widgets
_zsh_autosuggest_start() {
add-zsh-hook -d precmd _zsh_autosuggest_start
2016-02-05 23:14:08 +01:00
_zsh_autosuggest_bind_widgets
# Re-bind widgets on every precmd to ensure we wrap other wrappers.
# Specifically, highlighting breaks if our widgets are wrapped by
# zsh-syntax-highlighting widgets. This also allows modifications
# to the widget list variables to take effect on the next precmd.
add-zsh-hook precmd _zsh_autosuggest_bind_widgets
2016-02-05 23:14:08 +01:00
}
2017-01-27 23:18:26 +01:00
# Start the autosuggestion widgets on the next precmd
autoload -Uz add-zsh-hook
add-zsh-hook precmd _zsh_autosuggest_start