Merge pull request #440 from zsh-users/develop

v0.6.0

.circleci/config.yml

@@ -0,0 +1,16 @@
+version: 2
+jobs:
+  build:
+    parallelism: 4
+    shell: /bin/bash --login
+    docker:
+    - image: ericfreese/zsh-autosuggestions-test:latest
+      command: /sbin/init
+    steps:
+    - checkout
+    - run:
+        name: Running tests
+        command: |
+          for v in $(grep "^[^#]" ZSH_VERSIONS | awk "(NR + $CIRCLE_NODE_INDEX) % $CIRCLE_NODE_TOTAL == 0"); do
+            TEST_ZSH_BIN=zsh-$v make test || exit 1
+          done

.editorconfig

@@ -0,0 +1,18 @@
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = tab
+indent_size = 4
+
+[*.md]
+indent_style = space
+
+[*.rb]
+indent_style = space
+indent_size = 2
+
+[*.yml]
+indent_style = space
+indent_size = 2

.gitignore

@@ -1,4 +0,0 @@
-/node_modules/
-/build/
-*.log
-*~

.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

.rubocop.yml

@@ -0,0 +1,30 @@
+# Rails:
+#   Enabled: true
+
+AllCops:
+  TargetRubyVersion: 2.3
+  Include:
+    - '**/Rakefile'
+    - '**/config.ru'
+    - '**/Gemfile'
+
+Metrics/LineLength:
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false

.ruby-version

@@ -0,0 +1 @@
+2.5.3

CHANGELOG.md

@@ -0,0 +1,96 @@
+# Changelog
+
+## v0.6.0
+- Added `completion` suggestion strategy powered by completion system (#111)
+- Allow setting `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE` to an empty string (#422)
+- Don't fetch suggestions after copy-earlier-word (#439)
+- Allow users to unignore zle-\* widgets (e.g. zle-line-init) (#432)
+
+
+## v0.5.2
+- Allow disabling automatic widget re-binding for better performance (#418)
+- Fix async suggestions when `SH_WORD_SPLIT` is set
+- Refactor async mode to use process substitution instead of zpty (#417)
+
+## v0.5.1
+- Speed up widget rebinding (#413)
+- Clean up global variable creations (#403)
+- Respect user's set options when running original widget (#402)
+
+## v0.5.0
+- Don't overwrite config with default values (#335)
+- Support fallback strategies by supplying array to suggestion config var
+- Rename "default" suggestion strategy to "history" to name it based on what it actually does
+- Reset opts in some functions affected by `GLOB_SUBST` (#334)
+- Support widgets starting with dashes (ex: `-a-widget`) (#337)
+- Skip async tests in zsh versions less than 5.0.8 because of reliability issues
+- Fix handling of newline + carriage return in async pty (#333)
+
+
+## v0.4.3
+- Avoid bell when accepting suggestions with `autosuggest-accept` (#228)
+- Don't fetch suggestions after [up,down]-line-or-beginning-search (#227, #241)
+- We are now running CI against new 5.5.1 version
+- Fix partial-accept in vi mode (#188)
+- Fix suggestion disappearing on fast movement after switching to `vicmd` mode (#290)
+- Fix issue rotating through kill ring with `yank-pop` (#301)
+- Fix issue creating new pty for async mode when previous pty is not properly cleaned up (#249)
+
+## v0.4.2
+- Fix bug in zsh versions older than 5.0.8 (#296)
+- Officially support back to zsh v4.3.11
+
+## v0.4.1
+- Switch to [[ and (( conditionals instead of [ (#257)
+- Avoid warnnestedvar warnings with `typeset -g` (#275)
+- Replace tabs with spaces in yaml (#268)
+- Clean up and fix escaping of special characters (#267)
+- Add `emacs-forward-word` to default list of partial accept widgets (#246)
+
+## v0.4.0
+- High-level integration tests using RSpec and tmux
+- Add continuous integration with Circle CI
+- Experimental support for asynchronous suggestions (#170)
+- Fix problems with multi-line suggestions (#225)
+- Optimize case where manually typing in suggestion
+- Avoid wrapping any zle-\* widgets (#206)
+- Remove support for deprecated options from v0.0.x
+- Handle history entries that begin with dashes
+- Gracefully handle being sourced multiple times (#126)
+- Add enable/disable/toggle widgets to disable/enable suggestions (#219)
+
+
+## v0.3.3
+- Switch from $history array to fc builtin for better performance with large HISTFILEs (#164)
+- Fix tilde handling when extended_glob is set (#168)
+- Add config option for maximum buffer length to fetch suggestions for (#178)
+- Add config option for list of widgets to ignore (#184)
+- Don't fetch a new suggestion unless a modification widget actually modifies the buffer (#183)
+
+## v0.3.2
+- Test runner now supports running specific tests and choosing zsh binary
+- Return code from original widget is now correctly passed through (#135)
+- Add `vi-add-eol` to list of accept widgets (#143)
+- Escapes widget names within evals to fix problems with irregular widget names (#152)
+- Plugin now clears suggestion while within a completion menu (#149)
+- .plugin file no longer relies on symbolic link support, fixing issues on Windows (#156)
+
+## v0.3.1
+
+- Fixes issue with `vi-next-char` not accepting suggestion (#137).
+- Fixes global variable warning when WARN_CREATE_GLOBAL option enabled (#133).
+- Split out a separate test file for each widget.
+
+## v0.3.0
+
+- Adds `autosuggest-execute` widget (PR #124).
+- Adds concept of suggestion "strategies" for different ways of fetching suggestions.
+- Adds "match_prev_cmd" strategy (PR #131).
+- Uses git submodules for testing dependencies.
+- Lots of test cleanup.
+- Various bug fixes for zsh 5.0.x and `sh_word_split` option.
+
+
+## v0.2.17
+
+Start of changelog.

DESCRIPTION

@@ -0,0 +1 @@
+Fish-like fast/unobtrusive autosuggestions for zsh.

Dockerfile

@@ -0,0 +1,20 @@
+FROM ruby:2.5.3-alpine
+
+RUN apk add --no-cache autoconf
+RUN apk add --no-cache libtool
+RUN apk add --no-cache libcap-dev
+RUN apk add --no-cache pcre-dev
+RUN apk add --no-cache curl
+RUN apk add --no-cache build-base
+RUN apk add --no-cache ncurses-dev
+RUN apk add --no-cache tmux
+
+WORKDIR /zsh-autosuggestions
+
+ADD ZSH_VERSIONS /zsh-autosuggestions/ZSH_VERSIONS
+ADD install_test_zsh.sh /zsh-autosuggestions/install_test_zsh.sh
+RUN ./install_test_zsh.sh
+
+ADD Gemfile /zsh-autosuggestions/Gemfile
+ADD Gemfile.lock /zsh-autosuggestions/Gemfile.lock
+RUN bundle install

Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'rspec-wait'
+gem 'pry-byebug'

Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.0.5)
+    coderay (1.1.1)
+    diff-lcs (1.3)
+    method_source (0.8.2)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.0)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rspec-wait (0.0.9)
+      rspec (>= 3, < 4)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry-byebug
+  rspec
+  rspec-wait
+
+BUNDLED WITH
+   1.13.6

INSTALL.md

@@ -0,0 +1,77 @@
+## Installation
+
+### Manual (Git Clone)
+
+1. Clone this repository somewhere on your machine. This guide will assume `~/.zsh/zsh-autosuggestions`.
+
+    ```sh
+    git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
+    ```
+
+2. Add the following to your `.zshrc`:
+
+    ```sh
+    source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
+    ```
+
+3. Start a new terminal session.
+
+### Antigen
+
+1. Add the following to your `.zshrc`:
+
+    ```sh
+    antigen bundle zsh-users/zsh-autosuggestions
+    ```
+
+2. Start a new terminal session.
+
+### Oh My Zsh
+
+1. Clone this repository into `$ZSH_CUSTOM/plugins` (by default `~/.oh-my-zsh/custom/plugins`)
+
+    ```sh
+    git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
+    ```
+
+2. Add the plugin to the list of plugins for Oh My Zsh to load (inside `~/.zshrc`):
+
+    ```sh
+    plugins=(zsh-autosuggestions)
+    ```
+
+3. Start a new terminal session.
+
+### Arch Linux
+
+1. Install [`zsh-autosuggestions`](https://www.archlinux.org/packages/community/any/zsh-autosuggestions/) from the `community` repository.
+
+    ```sh
+    pacman -S zsh-autosuggestions
+    ```
+
+    or, to use a package based on the `master` branch, install [`zsh-autosuggestions-git`](https://aur.archlinux.org/packages/zsh-autosuggestions-git/) from the [AUR](https://wiki.archlinux.org/index.php/Arch_User_Repository).
+
+2. Add the following to your `.zshrc`:
+
+    ```sh
+    source /usr/share/zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh
+    ```
+
+3. Start a new terminal session.
+
+### macOS via Homebrew
+1. Install the `zsh-autosuggestions` package using [Homebrew](https://brew.sh/).
+
+    ```sh
+    brew install zsh-autosuggestions
+    ```
+
+2. Add the following to your `.zshrc`:
+
+    ```sh
+    source /usr/local/share/zsh-autosuggestions/zsh-autosuggestions.zsh
+    ```
+
+3. Start a new terminal session.
+

LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2013 Thiago de Arruda
+Copyright (c) 2016-2019 Eric Freese
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

Makefile

@@ -0,0 +1,35 @@
+SRC_DIR    := ./src
+
+SRC_FILES := \
+	$(SRC_DIR)/config.zsh \
+	$(SRC_DIR)/util.zsh \
+	$(SRC_DIR)/bind.zsh \
+	$(SRC_DIR)/highlight.zsh \
+	$(SRC_DIR)/widgets.zsh \
+	$(SRC_DIR)/strategies/*.zsh \
+	$(SRC_DIR)/fetch.zsh \
+	$(SRC_DIR)/async.zsh \
+	$(SRC_DIR)/start.zsh
+
+HEADER_FILES := \
+	DESCRIPTION \
+	URL \
+	VERSION \
+	LICENSE
+
+PLUGIN_TARGET := zsh-autosuggestions.zsh
+
+all: $(PLUGIN_TARGET)
+
+$(PLUGIN_TARGET): $(HEADER_FILES) $(SRC_FILES)
+	cat $(HEADER_FILES) | sed -e 's/^/# /g' > $@
+	cat $(SRC_FILES) >> $@
+
+.PHONY: clean
+clean:
+	rm $(PLUGIN_TARGET)
+
+.PHONY: test
+test: all
+	@test -n "$$TEST_ZSH_BIN" && echo "Testing zsh binary: $(TEST_ZSH_BIN)" || true
+	bundle exec rspec $(TESTS)

README.md

@@ -0,0 +1,175 @@
+# zsh-autosuggestions
+
+_[Fish](http://fishshell.com/)-like fast/unobtrusive autosuggestions for zsh._
+
+It suggests commands as you type.
+
+Requirements: Zsh v4.3.11 or later
+
+[![CircleCI](https://circleci.com/gh/zsh-users/zsh-autosuggestions.svg?style=svg)](https://circleci.com/gh/zsh-users/zsh-autosuggestions)
+
+<a href="https://asciinema.org/a/37390" target="_blank"><img src="https://asciinema.org/a/37390.png" width="400" /></a>
+
+
+## Installation
+
+See [INSTALL.md](INSTALL.md).
+
+
+## Usage
+
+As you type commands, you will see a completion offered after the cursor in a muted gray color. This color can be changed by setting the `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE` variable. See [configuration](#configuration).
+
+If you press the <kbd>→</kbd> key (`forward-char` widget) or <kbd>End</kbd> (`end-of-line` widget) with the cursor at the end of the buffer, it will accept the suggestion, replacing the contents of the command line buffer with the suggestion.
+
+If you invoke the `forward-word` widget, it will partially accept the suggestion up to the point that the cursor moves to.
+
+
+## Configuration
+
+You may want to override the default global config variables. Default values of these variables can be found [here](src/config.zsh).
+
+**Note:** If you are using Oh My Zsh, you can put this configuration in a file in the `$ZSH_CUSTOM` directory. See their comments on [overriding internals](https://github.com/robbyrussell/oh-my-zsh/wiki/Customization#overriding-internals).
+
+
+### Suggestion Highlight Style
+
+Set `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE` to configure the style that the suggestion is shown with. The default is `fg=8`, which will set the foreground color to color 8 from the 256-color palette. If your terminal only supports 8 colors, you will need to use a number between 0 and 7.
+
+Background color can also be set, and the suggestion can be styled bold, underlined, or standout. For example, this would show suggestions with bold, underlined, pink text on a cyan background:
+
+```sh
+ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE="fg=#ff00ff,bg=cyan,bold,underline"
+```
+
+For more info, read the Character Highlighting section of the zsh manual: `man zshzle` or [online](http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Character-Highlighting).
+
+
+### Suggestion Strategy
+
+`ZSH_AUTOSUGGEST_STRATEGY` is an array that specifies how suggestions should be generated. The strategies in the array are tried successively until a suggestion is found. There are currently three built-in strategies to choose from:
+
+- `history`: Chooses the most recent match from history.
+- `match_prev_cmd`: Like `history`, but chooses the most recent match whose preceding history item matches the most recently executed command ([more info](src/strategies/match_prev_cmd.zsh)). 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`.
+- `completion`: (experimental) Chooses a suggestion based on what tab-completion would suggest. (requires `zpty` module)
+
+For example, setting `ZSH_AUTOSUGGEST_STRATEGY=(history completion)` will first try to find a suggestion from your history, but, if it can't find a match, will find a suggestion from the completion engine.
+
+
+### Widget Mapping
+
+This plugin works by triggering custom behavior when certain [zle widgets](http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Zle-Widgets) are invoked. You can add and remove widgets from these arrays to change the behavior of this plugin:
+
+- `ZSH_AUTOSUGGEST_CLEAR_WIDGETS`: Widgets in this array will clear the suggestion when invoked.
+- `ZSH_AUTOSUGGEST_ACCEPT_WIDGETS`: Widgets in this array will accept the suggestion when invoked.
+- `ZSH_AUTOSUGGEST_EXECUTE_WIDGETS`: Widgets in this array will execute the suggestion when invoked.
+- `ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS`: Widgets in this array will partially accept the suggestion when invoked.
+- `ZSH_AUTOSUGGEST_IGNORE_WIDGETS`: Widgets in this array will not trigger any custom behavior.
+
+Widgets that modify the buffer and are not found in any of these arrays will fetch a new suggestion after they are invoked.
+
+**Note:** A widget shouldn't belong to more than one of the above arrays.
+
+
+### Disabling suggestion for large buffers
+
+Set `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE` to an integer value to disable autosuggestion for large buffers. The default is unset, which means that autosuggestion will be tried for any buffer size. Recommended value is 20.
+This can be useful when pasting large amount of text in the terminal, to avoid triggering autosuggestion for strings that are too long.
+
+### Enable Asynchronous Mode
+
+As of `v0.4.0`, suggestions can be fetched asynchronously. To enable this behavior, set the `ZSH_AUTOSUGGEST_USE_ASYNC` variable (it can be set to anything).
+
+### Disabling automatic widget re-binding
+
+Set `ZSH_AUTOSUGGEST_MANUAL_REBIND` (it can be set to anything) to disable automatic widget re-binding on each precmd. This can be a big boost to performance, but you'll need to handle re-binding yourself if any of the widget lists change or if you or another plugin wrap any of the autosuggest widgets. To re-bind widgets, run `_zsh_autosuggest_bind_widgets`.
+
+
+### Key Bindings
+
+This plugin provides a few widgets that you can use with `bindkey`:
+
+1. `autosuggest-accept`: Accepts the current suggestion.
+2. `autosuggest-execute`: Accepts and executes the current suggestion.
+3. `autosuggest-clear`: Clears the current suggestion.
+4. `autosuggest-fetch`: Fetches a suggestion (works even when suggestions are disabled).
+5. `autosuggest-disable`: Disables suggestions.
+6. `autosuggest-enable`: Re-enables suggestions.
+7. `autosuggest-toggle`: Toggles between enabled/disabled suggestions.
+
+For example, this would bind <kbd>ctrl</kbd> + <kbd>space</kbd> to accept the current suggestion.
+
+```sh
+bindkey '^ ' autosuggest-accept
+```
+
+
+## Troubleshooting
+
+If you have a problem, please search through [the list of issues on GitHub](https://github.com/zsh-users/zsh-autosuggestions/issues) to see if someone else has already reported it.
+
+
+### Reporting an Issue
+
+Before reporting an issue, please try temporarily disabling sections of your configuration and other plugins that may be conflicting with this plugin to isolate the problem.
+
+When reporting an issue, please include:
+
+- The smallest, simplest `.zshrc` configuration that will reproduce the problem. See [this comment](https://github.com/zsh-users/zsh-autosuggestions/issues/102#issuecomment-180944764) for a good example of what this means.
+- The version of zsh you're using (`zsh --version`)
+- Which operating system you're running
+
+
+## Uninstallation
+
+1. Remove the code referencing this plugin from `~/.zshrc`.
+
+2. Remove the git repository from your hard drive
+
+    ```sh
+    rm -rf ~/.zsh/zsh-autosuggestions # Or wherever you installed
+    ```
+
+
+## Development
+
+### Build Process
+
+Edit the source files in `src/`. Run `make` to build `zsh-autosuggestions.zsh` from those source files.
+
+
+### Pull Requests
+
+Pull requests are welcome! If you send a pull request, please:
+
+- Request to merge into the `develop` branch (*NOT* `master`)
+- Match the existing coding conventions.
+- Include helpful comments to keep the barrier-to-entry low for people new to the project.
+- Write tests that cover your code as much as possible.
+
+
+### Testing
+
+Tests are written in ruby using the [`rspec`](http://rspec.info/) framework. They use [`tmux`](https://tmux.github.io/) to drive a pseudoterminal, sending simulated keystrokes and making assertions on the terminal content.
+
+Test files live in `spec/`. To run the tests, run `make test`. To run a specific test, run `TESTS=spec/some_spec.rb make test`. You can also specify a `zsh` binary to use by setting the `TEST_ZSH_BIN` environment variable (ex: `TEST_ZSH_BIN=/bin/zsh make test`).
+
+A docker image for testing is available [on docker hub](https://hub.docker.com/r/ericfreese/zsh-autosuggestions-test). It comes with ruby, the bundler dependencies, and all supported versions of zsh installed.
+
+Pull the docker image with:
+
+```sh
+docker pull ericfreese/zsh-autosuggestions-test
+```
+
+To run the tests for a specific version of zsh (where `<version>` below is substituted with the contents of a line from the [`ZSH_VERSIONS`](ZSH_VERSIONS) file):
+
+```sh
+docker run -it -e TEST_ZSH_BIN=zsh-<version> -v $PWD:/zsh-autosuggestions zsh-autosuggestions-test make test
+```
+
+
+## License
+
+This project is licensed under [MIT license](http://opensource.org/licenses/MIT).
+For the full text of the license, see the [LICENSE](LICENSE) file.

README.mkd

@@ -1,22 +0,0 @@
-# zsh-autosuggestions
-
-> [Fish](http://fishshell.com/)-like fast/unobtrusive autosuggestions for zsh.
-> [Shelr demo](http://shelr.tv/records/527007a99660803c5d000048).
-
-## Installation
-
-```zsh
-git clone git://github.com/tarruda/zsh-autosuggestions ~/.zsh-autosuggestions
-cat >> ~/.zshrc << "EOF"
-source ~/.zsh-autosuggestions/autosuggestions.zsh
-# Enable autosuggestions automatically
-zle-line-init() {
-	zle autosuggest-start
-}
-zle -N zle-line-init
-# use ctrl+t to toggle autosuggestions(hopefully this wont be needed)
-bindkey '^T' autosuggest-toggle
-# use ctrl+f to accept a suggested word
-bindkey '^F' autosuggest-accept-suggested-word
-EOF
-```

URL

@@ -0,0 +1 @@
+https://github.com/zsh-users/zsh-autosuggestions

VERSION

@@ -0,0 +1 @@
+v0.6.0

ZSH_VERSIONS

@@ -0,0 +1,16 @@
+# Zsh releases to run tests against
+# See https://github.com/zsh-users/zsh/releases
+#
+# When modifying this file, rebuild and push docker image:
+#   $ docker build -t ericfreese/zsh-autosuggestions-test .
+#   $ docker push ericfreese/zsh-autosuggestions-test
+4.3.11
+5.0.2
+5.0.8
+5.1.1
+5.2
+5.3.1
+5.4.2
+5.5.1
+5.6.2
+5.7.1

autosuggestions.zsh

@@ -1,228 +0,0 @@
-# Fish-like autosuggestions for zsh. Some of the code was based on the code
-# for 'predict-on' 
-#
-# ```zsh
-# zle-line-init() {
-#		autosuggest-enable
-# }
-# zle -N zle-line-init
-# ```
-zmodload zsh/net/socket
-
-source "${0:a:h}/completion-client.zsh"
-
-function {
-	[[ -n $ZLE_DISABLE_AUTOSUGGEST ]] && return
-	autosuggest-ensure-server
-}
-
-ZLE_AUTOSUGGEST_PAUSE_WIDGETS=(
-vi-cmd-mode vi-backward-char backward-char backward-word beginning-of-line
-history-search-forward history-search-backward up-line-or-history
-down-line-or-history
-)
-
-ZLE_AUTOSUGGEST_COMPLETION_WIDGETS=(
-complete-word expand-or-complete expand-or-complete-prefix list-choices
-menu-complete reverse-menu-complete menu-expand-or-complete menu-select
-accept-and-menu-complete
-)
-
-autosuggest-pause() {
-	[[ -z $ZLE_AUTOSUGGESTING ]] && return
-	unset ZLE_AUTOSUGGESTING
-	local widget
-	# When autosuggestions are disabled, kill the unmaterialized part
-	RBUFFER=''
-	zle -A self-insert autosuggest-paused-self-insert
-	zle -A .magic-space magic-space
-	zle -A .backward-delete-char backward-delete-char
-	zle -A .accept-line accept-line
-	for widget in $ZLE_AUTOSUGGEST_PAUSE_WIDGETS; do
-		eval "zle -A autosuggest-${widget}-orig ${widget}"
-	done
-	for widget in $ZLE_AUTOSUGGEST_COMPLETION_WIDGETS; do
-		eval "zle -A autosuggest-${widget}-orig $widget"
-	done
-	autosuggest-highlight-suggested-text
-
-	zle -F $ZLE_AUTOSUGGEST_CONNECTION
-}
-
-autosuggest-resume() {
-	[[ -n $ZLE_AUTOSUGGESTING ]] && return
-	ZLE_AUTOSUGGESTING=1
-	local widget
-	# Replace prediction widgets by versions that will also highlight RBUFFER
-	zle -N self-insert autosuggest-insert-or-space
-	zle -N magic-space autosuggest-insert-or-space
-	zle -N backward-delete-char autosuggest-backward-delete-char
-	zle -N accept-line autosuggest-accept-line
-	# Hook into some default widgets that should pause autosuggestion
-	# automatically 
-	for widget in $ZLE_AUTOSUGGEST_PAUSE_WIDGETS; do
-		eval "zle -A $widget autosuggest-${widget}-orig; \
-			zle -A autosuggest-suspend $widget"
-	done
-	# Hook into completion widgets to handle suggestions after completions
-	for widget in $ZLE_AUTOSUGGEST_COMPLETION_WIDGETS; do
-		eval "zle -A $widget autosuggest-${widget}-orig; \
-			zle -A autosuggest-tab $widget"
-	done
-	if [[ $BUFFER != '' ]]; then
-		autosuggest-request-suggestion
-	fi
-
-	if [[ -n $ZLE_AUTOSUGGEST_CONNECTION ]]; then
-		# install listen for suggestions asynchronously
-		zle -F $ZLE_AUTOSUGGEST_CONNECTION autosuggest-pop-suggestion
-	fi
-}
-
-autosuggest-start() {
-	autosuggest-resume
-	zle recursive-edit
-	integer rv=$?
-	autosuggest-pause
-	zle -A .self-insert self-insert
-	(( rv )) || zle accept-line
-	return rv
-}
-
-# Toggles autosuggestions on/off
-autosuggest-toggle() {
-	if [[ -n $ZLE_AUTOSUGGESTING ]]; then
-		autosuggest-pause
-	else
-		autosuggest-resume
-	fi
-}
-
-autosuggest-highlight-suggested-text() {
-	if [[ -n $ZLE_AUTOSUGGESTING ]]; then
-		local color='fg=8'
-		[[ -n $AUTOSUGGESTION_HIGHLIGHT_COLOR ]] &&\
-			color=$AUTOSUGGESTION_HIGHLIGHT_COLOR
-		region_highlight=("$(( $CURSOR + 1 )) $(( $CURSOR + $#RBUFFER )) $color")
-	else
-		region_highlight=()
-	fi
-}
-
-autosuggest-insert-or-space() {
-	if [[ $LBUFFER == *$'\012'* ]] || (( PENDING )); then
-		# Editing a multiline buffer or pasting in a chunk of text, dont
-		# autosuggest
-		zle .$WIDGET "$@"
-	elif [[ ${RBUFFER[1]} == ${KEYS[-1]} ]]; then
-    # Same as what's typed, just move on
-		((++CURSOR))
-		autosuggest-highlight-suggested-text
-	else
-    LBUFFER="$LBUFFER$KEYS"
-		autosuggest-request-suggestion
-	fi
-}
-
-autosuggest-backward-delete-char() {
-	if ! (( $CURSOR )); then
-	 	zle .kill-whole-line
-		return
-	fi
-
-	if [[ $LBUFFER == *$'\012'* || $LASTWIDGET != (self-insert|magic-space|backward-delete-char) ]]; then
-		# When editing a multiline buffer or if the last widget was e.g. a motion,
-		# then probably the intent is to actually edit the line, not change the
-		# search prefix.
-		LBUFFER="$LBUFFER[1,-2]"
-	else
-		((--CURSOR))
-		zle .history-beginning-search-forward || RBUFFER=''
-	fi
-}
-
-# When autosuggesting, ignore RBUFFER which corresponds to the 'unmaterialized'
-# section when the user accepts the line
-autosuggest-accept-line() {
-	RBUFFER=''
-	region_highlight=()
-	zle .accept-line
-}
-
-autosuggest-paused-self-insert() {
-	if [[ $RBUFFER == '' ]]; then
-		# Resume autosuggestions when inserting at the end of the line
-		autosuggest-enable
-		zle autosuggest-modify
-	else
-		zle .self-insert
-	fi
-}
-
-autosuggest-pop-suggestion() {
-	local words last_word suggestion
-	if ! IFS= read -r -u $ZLE_AUTOSUGGEST_CONNECTION suggestion; then
-		# server closed the connection, stop listenting
-		zle -F $ZLE_AUTOSUGGEST_CONNECTION
-		unset ZLE_AUTOSUGGEST_CONNECTION
-		return
-	fi
-	if [[ -n $suggestion ]]; then
-		local prefix=${suggestion%$'\2'*}
-		suggestion=${suggestion#*$'\2'}
-		# only use the suggestion if the prefix is still compatible with
-		# the suggestion(prefix should be contained in LBUFFER)
-		if [[ ${LBUFFER#$prefix*} != ${LBUFFER} ]]; then
-			words=(${(z)LBUFFER})
-			last_word=${words[-1]}
-			suggestion=${suggestion:$#last_word}
-			RBUFFER="$suggestion"
-			autosuggest-highlight-suggested-text
-		else
-			RBUFFER=''
-		fi
-	else
-		RBUFFER=''
-	fi
-	zle -Rc
-}
-
-autosuggest-request-suggestion() {
-	if (( $CURSOR == 0 )) || [[ ${LBUFFER[-1]} == ' ' ]]; then
-	 	RBUFFER=''
-		return
-	fi
-
-	[[ -n $ZLE_DISABLE_AUTOSUGGEST || $LBUFFER == '' ]] && return
-	zle .history-beginning-search-backward ||\
-		autosuggest-first-completion ${LBUFFER}
-	autosuggest-highlight-suggested-text
-}
-
-autosuggest-suspend() {
-	autosuggest-pause
-	zle autosuggest-${WIDGET}-orig "$@"
-}
-
-autosuggest-tab() {
-	RBUFFER=''
-	zle autosuggest-${WIDGET}-orig "$@"
-	autosuggest-highlight-suggested-text
-}
-
-autosuggest-accept-suggested-small-word() {
-	zle .vi-forward-word
-	autosuggest-highlight-suggested-text
-}
-
-autosuggest-accept-suggested-word() {
-	zle .forward-word
-	autosuggest-highlight-suggested-text
-}
-
-zle -N autosuggest-toggle
-zle -N autosuggest-start
-zle -N autosuggest-accept-suggested-small-word
-zle -N autosuggest-accept-suggested-word
-zle -N autosuggest-suspend
-zle -N autosuggest-tab

completion-client.zsh

@@ -1,41 +0,0 @@
-#!/usr/bin/env zsh
-zmodload zsh/net/socket
-
-AUTOSUGGEST_SERVER_SCRIPT="${0:a:h}/completion-server.zsh"
-
-autosuggest-ensure-server() {
-	setopt local_options no_hup
-	local server_dir="/tmp/zsh-autosuggest-$USER"
-	local pid_file="$server_dir/pid"
-	local socket_path="$server_dir/socket"
-
-	if [[ ! -S $socket_path || ! -r $pid_file ]] || ! kill -0 $(<$pid_file) &> /dev/null; then
-		if which setsid &> /dev/null; then
-			setsid zsh $AUTOSUGGEST_SERVER_SCRIPT $server_dir $pid_file $socket_path &!
-		else
-			zsh $AUTOSUGGEST_SERVER_SCRIPT $server_dir $pid_file $socket_path &!
-		fi
-	fi
-
-	autosuggest-server-connect
-}
-
-autosuggest-server-connect() {
-	unset ZLE_AUTOSUGGEST_CONNECTION
-
-	integer remaining_tries=10
-	while (( --remaining_tries )) && ! zsocket $socket_path &>/dev/null; do
-		sleep 0.3
-	done
-
-	[[ -z $REPLY ]] && return 1
-
-	ZLE_AUTOSUGGEST_CONNECTION=$REPLY
-}
-
-autosuggest-first-completion() {
-	[[ -z $ZLE_AUTOSUGGEST_CONNECTION ]] && return 1
-	setopt local_options noglob
-	local response
-	print -u $ZLE_AUTOSUGGEST_CONNECTION - $1 &> /dev/null || return 1
-}

completion-server-init.zsh

@@ -1,121 +0,0 @@
-# Based on:
-# https://github.com/Valodim/zsh-capture-completion/blob/master/.zshrc
-
-ZLE_DISABLE_AUTOSUGGEST=1
-# no prompt!
-PROMPT=
-
-# load completion system
-autoload compinit
-compinit
-
-# never run a command
-bindkey '\C-m' .kill-buffer
-bindkey '\C-j' .kill-buffer
-bindkey '\C-i' complete-word
-
-# send an emtpy line before completions are output
-empty-line() {
-	print
-	# handler needs to reinsert itself after being called
-	compprefuncs+=empty-line
-}
-compprefuncs+=empty-line
-
-# send a line with null-byte after completions are output
-null-line() {
-	print $'\0'
-	# handler needs to reinsert itself after being called
-	comppostfuncs+=null-line
-}
-comppostfuncs+=null-line
-
-zstyle ':completion:*' completer _complete
-# never group stuff!
-zstyle ':completion:*' list-grouped false
-# don't insert tab when attempting completion on empty line
-zstyle ':completion:*' insert-tab false
-# no list separator, this saves some stripping later on
-zstyle ':completion:*' list-separator ''
-# dont use matchers
-zstyle -d ':completion:*' matcher-list
-# dont format
-zstyle -d ':completion:*' format
-# no color formatting
-zstyle -d ':completion:*' list-colors
-
-# we use zparseopts
-zmodload zsh/zutil
-
-# override compadd (this our hook)
-compadd () {
-
-	# check if any of -O, -A or -D are given
-	if [[ ${@[1,(i)(-|--)]} == *-(O|A|D)\ * ]]; then
-		# if that is the case, just delegate and leave
-		builtin compadd "$@"
-		return $?
-	fi
-
-	# be careful with namespacing here, we don't want to mess with stuff that
-	# should be passed to compadd!
-	typeset -a __hits __dscr __tmp
-
-	# do we have a description parameter?
-	# note we don't use zparseopts here because of combined option parameters
-	# with arguments like -default- confuse it.
-	if (( $@[(I)-d] )); then # kind of a hack, $+@[(r)-d] doesn't work because of line noise overload
-		# next param after -d
-		__tmp=${@[$[${@[(i)-d]}+1]]}
-		# description can be given as an array parameter name, or inline () array
-		if [[ $__tmp == \(* ]]; then
-			eval "__dscr=$__tmp"
-		else
-			__dscr=( "${(@P)__tmp}" )
-		fi
-	fi
-
-	# capture completions by injecting -A parameter into the compadd call.
-	# this takes care of matching for us.
-	builtin compadd -A __hits -D __dscr "$@"
-
-	# JESUS CHRIST IT TOOK ME FOREVER TO FIGURE OUT THIS OPTION WAS SET AND WAS MESSING WITH MY SHIT HERE
-	setopt localoptions norcexpandparam extendedglob
-
-	# 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
-
-	# append / to directories? we are only emulating -f in a half-assed way
-	# here, but it's better than nothing.
-	integer dirsuf=0
-	# don't be fooled by -default- >.>
-	if [[ -z $hsuf && "${${@//-default-/}% -# *}" == *-[[:alnum:]]#f* ]]; then
-		dirsuf=1
-	fi
-
-	# just drop
-	[[ -n $__hits ]] || return
-
-	# this is the point where we have all matches in $__hits and all
-	# descriptions in $__dscr!
-
-	# display all matches
-	local dsuf dscr
-	for i in {1..$#__hits}; do
-
-		# add a dir suffix?
-		(( dirsuf )) && [[ -d $__hits[$i] ]] && dsuf=/ || dsuf=
-		# description to be displayed afterwards
-		# (( $#__dscr >= $i )) && dscr=" -- ${${__dscr[$i]}##$__hits[$i] #}" || dscr=
-
-		print - $'\1'$IPREFIX$apre$hpre$__hits[$i]$dsuf$hsuf$asuf$dscr
-
-	done
-
-	unset __hits __dscr __tmp
-}
-
-# signal the daemon we are ready for input
-print $'\0'

completion-server.zsh

@@ -1,128 +0,0 @@
-#!/usr/bin/env zsh
-# Based on:
-# https://github.com/Valodim/zsh-capture-completion/blob/master/capture.zsh
-
-# read everything until a line containing the byte 0 is found
-read-to-null() {
-	while zpty -r z chunk; do
-		[[ $chunk == *$'\0'* ]] && break
-		[[ $chunk != $'\1'* ]] && continue # ignore what doesnt start with '1'
-		print -n - ${chunk:1}
-	done
-}
-
-accept-connection() {
-	zsocket -a $server
-	fds[$REPLY]=1
-	print "connection accepted, fd: $REPLY"
-}
-
-handle-request() {
-	local connection=$1 current line
-	integer read_something=0
-	print "request received from fd $connection"
-	while read -u $connection prefix &> /dev/null; do
-		read_something=1
-		# send the prefix to be completed followed by a TAB to force
-		# completion
-		zpty -w -n z $prefix$'\t'
-		zpty -r z chunk &> /dev/null # read empty line before completions
-		current=''
-		# read completions one by one, storing the longest match
-		read-to-null | while IFS= read -r line; do
-			(( $#line > $#current )) && current=$line
-		done
-		# send the longest completion back to the client, strip the last
-		# non-printable character
-		if (( $#current )); then
-			print -u $connection - $prefix$'\2'${current:0:-1}
-		else
-			print -u $connection ''
-		fi
-		# clear input buffer
-		zpty -w z $'\n'
-		break # handle more requests/return to zselect
-	done
-	if ! (( read_something )); then
-		print "connection with fd $connection closed"
-	  unset fds[$connection]
-		exec {connection}>&- # free the file descriptor
-	fi
-}
-
-
-if [[ -n $ZLE_AUTOSUGGEST_SERVER_LOG ]]; then
-	exec >> "$HOME/.autosuggest-server.log"
-else
-	exec > /dev/null
-fi
-
-if [[ -n $ZLE_AUTOSUGGEST_SERVER_LOG_ERRORS ]]; then
-	exec 2>> "$HOME/.autosuggest-server-errors.log"
-else
-	exec 2> /dev/null
-fi
-
-exec < /dev/null
-
-zmodload zsh/zpty
-zmodload zsh/zselect
-zmodload zsh/net/socket
-setopt noglob
-print "autosuggestion server started, pid: $$"
-
-# Start an interactive zsh connected to a zpty
-zpty z ZLE_DISABLE_AUTOSUGGEST=1 zsh -i
-print 'interactive shell started'
-# Source the init script
-zpty -w z "source '${0:a:h}/completion-server-init.zsh'"
-
-# wait for ok from shell
-read-to-null &> /dev/null
-print 'interactive shell ready'
-
-# listen on a socket for completion requests
-server_dir=$1
-pid_file=$2
-socket_path=$3
-
-
-cleanup() {
-	print 'removing socket and pid file...'
-	rm -f $socket_path $pid_file
-	print "autosuggestion server stopped, pid: $$"
-	exit
-}
-
-trap cleanup TERM INT HUP EXIT
-
-mkdir -m 700 $server_dir &> /dev/null
-
-while ! zsocket -l $socket_path; do
-	if [[ ! -r $pid_file ]] || ! kill -0 $(<$pid_file) &> /dev/null; then
-		rm -f $socket_path
-	else
-		exit 1
-	fi
-	print "will retry listening on '$socket_path'"
-done
-
-server=$REPLY
-
-print "server listening on '$socket_path'"
-
-print $$ > $pid_file
-
-typeset -A fds ready
-fds[$server]=1
-
-while zselect -A ready ${(k)fds}; do
-	queue=(${(k)ready})
-	for fd in $queue; do
-		if (( fd == server )); then
-			accept-connection
-		else
-			handle-request $fd
-		fi
-	done
-done

install_test_zsh.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+set -ex
+
+for v in $(grep "^[^#]" ZSH_VERSIONS); do
+  mkdir zsh-$v
+  cd zsh-$v
+
+  curl -L https://api.github.com/repos/zsh-users/zsh/tarball/zsh-$v | tar xz --strip=1
+
+  ./Util/preconfig
+  ./configure --enable-pcre \
+              --enable-cap \
+              --enable-multibyte \
+              --with-term-lib='ncursesw tinfo' \
+              --with-tcsetpgrp \
+              --program-suffix="-$v"
+
+  make install.bin
+  make install.modules
+  make install.fns
+
+  cd ..
+
+  rm -rf zsh-$v
+done

spec/async_spec.rb

@@ -0,0 +1,70 @@
+context 'with asynchronous suggestions enabled' do
+  let(:options) { ["ZSH_AUTOSUGGEST_USE_ASYNC="] }
+
+  describe '`up-line-or-beginning-search`' do
+    let(:before_sourcing) do
+      -> do
+        session.
+          run_command('autoload -U up-line-or-beginning-search').
+          run_command('zle -N up-line-or-beginning-search').
+          send_string('bindkey "').
+          send_keys('C-v').send_keys('up').
+          send_string('" up-line-or-beginning-search').
+          send_keys('enter')
+      end
+    end
+
+    it 'should show previous history entries' do
+      with_history(
+        'echo foo',
+        'echo bar',
+        'echo baz'
+      ) do
+        session.clear_screen
+        3.times { session.send_keys('up') }
+        wait_for { session.content }.to eq("echo foo")
+      end
+    end
+  end
+
+  describe '`copy-earlier-word`' do
+    let(:before_sourcing) do
+      -> do
+        session.
+          run_command('autoload -Uz copy-earlier-word').
+          run_command('zle -N copy-earlier-word').
+          run_command('bindkey "^N" copy-earlier-word')
+      end
+    end
+
+    it 'should cycle through previous words in the buffer' do
+      session.clear_screen
+      session.send_string('foo bar baz')
+      sleep 0.5
+      session.send_keys('C-n')
+      wait_for { session.content }.to eq('foo bar bazbaz')
+      session.send_keys('C-n')
+      wait_for { session.content }.to eq('foo bar bazbar')
+      session.send_keys('C-n')
+      wait_for { session.content }.to eq('foo bar bazfoo')
+    end
+  end
+
+  describe 'pressing ^C after fetching a suggestion' do
+    before do
+      skip 'Workaround does not work below v5.0.8' if session.zsh_version < Gem::Version.new('5.0.8')
+    end
+
+    it 'terminates the prompt and begins a new one' do
+      session.send_keys('e')
+      sleep 0.5
+      session.send_keys('C-c')
+      sleep 0.5
+      session.send_keys('echo')
+
+      wait_for { session.content }.to eq("e\necho")
+    end
+  end
+end
+
+

spec/integrations/auto_cd_spec.rb

@@ -0,0 +1,14 @@
+describe 'with `AUTO_CD` option set' do
+  let(:after_sourcing) do
+    -> {
+      session.run_command('setopt AUTO_CD')
+      session.run_command('autoload compinit && compinit')
+    }
+  end
+
+  it 'directory names are still completed' do
+    session.send_string('sr')
+    session.send_keys('C-i')
+    wait_for { session.content }.to eq('src/')
+  end
+end

spec/integrations/bracketed_paste_magic_spec.rb

@@ -0,0 +1,43 @@
+describe 'pasting using bracketed-paste-magic' do
+  let(:before_sourcing) do
+    -> do
+      session.
+        run_command('autoload -Uz bracketed-paste-magic').
+        run_command('zle -N bracketed-paste bracketed-paste-magic')
+    end
+  end
+
+  context 'with suggestions disabled while pasting' do
+    before do
+      session.
+        run_command('bpm_init() { zle autosuggest-disable }').
+        run_command('bpm_finish() { zle autosuggest-enable }').
+        run_command('zstyle :bracketed-paste-magic paste-init bpm_init').
+        run_command('zstyle :bracketed-paste-magic paste-finish bpm_finish')
+    end
+
+    it 'does not show an incorrect suggestion' do
+      with_history('echo hello') do
+        session.paste_string("echo #{'a' * 60}")
+        sleep 1
+        expect(session.content).to eq("echo #{'a' * 60}")
+      end
+    end
+  end
+
+  context 'with `bracketed-paste` added to the list of widgets that clear the suggestion' do
+    let(:options) { ['ZSH_AUTOSUGGEST_CLEAR_WIDGETS+=(bracketed-paste)'] }
+
+    it 'does not retain an old suggestion' do
+      with_history ('echo foo') do
+        session.send_string('echo ')
+        wait_for { session.content }.to eq('echo foo')
+        session.paste_string('bar')
+        wait_for { session.content }.to eq('echo bar')
+        session.send_keys('C-a') # Any cursor movement works
+        sleep 1
+        expect(session.content).to eq('echo bar')
+      end
+    end
+  end
+end

spec/integrations/client_zpty_spec.rb

@@ -0,0 +1,14 @@
+describe 'a running zpty command' do
+  let(:before_sourcing) { -> { session.run_command('zmodload zsh/zpty && zpty -b kitty cat') } }
+
+  context 'when using `completion` strategy' do
+    let(:options) { ["ZSH_AUTOSUGGEST_STRATEGY=completion"] }
+
+    it 'is not affected' do
+      session.send_keys('a').send_keys('C-h')
+      session.run_command('zpty -t kitty; echo $?')
+
+      wait_for { session.content }.to end_with("\n0")
+    end
+  end
+end

spec/integrations/glob_subst_spec.rb

@@ -0,0 +1,12 @@
+describe 'with `GLOB_SUBST` option set' do
+  let(:after_sourcing) do
+    -> {
+      session.run_command('setopt GLOB_SUBST')
+    }
+  end
+
+  it 'error messages are not printed' do
+    session.send_string('[[')
+    wait_for { session.content }.to eq('[[')
+  end
+end

spec/integrations/rebound_bracket_spec.rb

@@ -0,0 +1,13 @@
+describe 'rebinding [' do
+  context 'initialized before sourcing the plugin' do
+    before do
+      session.run_command("function [ { $commands[\\[] \"$@\" }")
+      session.clear_screen
+    end
+
+    it 'executes the custom behavior and the built-in behavior' do
+      session.send_string('asdf')
+      wait_for { session.content }.to eq('asdf')
+    end
+  end
+end

spec/integrations/vi_mode_spec.rb

@@ -0,0 +1,67 @@
+describe 'when using vi mode' do
+  let(:before_sourcing) do
+    -> do
+      session.run_command('bindkey -v')
+    end
+  end
+
+  describe 'moving the cursor after exiting insert mode' do
+    it 'should not clear the current suggestion' do
+      with_history('foobar foo') do
+        session.
+          send_string('foo').
+          send_keys('escape').
+          send_keys('h')
+
+        wait_for { session.content }.to eq('foobar foo')
+      end
+    end
+  end
+
+  describe '`vi-forward-word-end`' do
+    it 'should accept through the end of the current word' do
+      with_history('foobar foo') do
+        session.
+          send_string('foo').
+          send_keys('escape').
+          send_keys('e'). # vi-forward-word-end
+          send_keys('a'). # vi-add-next
+          send_string('baz')
+
+        wait_for { session.content }.to eq('foobarbaz')
+      end
+    end
+  end
+
+  describe '`vi-forward-word`' do
+    it 'should accept through the first character of the next word' do
+      with_history('foobar foo') do
+        session.
+          send_string('foo').
+          send_keys('escape').
+          send_keys('w'). # vi-forward-word
+          send_keys('a'). # vi-add-next
+          send_string('az')
+
+        wait_for { session.content }.to eq('foobar faz')
+      end
+    end
+  end
+
+  describe '`vi-find-next-char`' do
+    it 'should accept through the next occurrence of the character' do
+      with_history('foobar foo') do
+        session.
+          send_string('foo').
+          send_keys('escape').
+          send_keys('f'). # vi-find-next-char
+          send_keys('o').
+          send_keys('a'). # vi-add-next
+          send_string('b')
+
+        wait_for { session.content }.to eq('foobar fob')
+      end
+    end
+  end
+end
+

spec/integrations/wrapped_widget_spec.rb

@@ -0,0 +1,39 @@
+describe 'a wrapped widget' do
+  let(:widget) { 'backward-delete-char' }
+
+  context 'initialized before sourcing the plugin' do
+    let(:before_sourcing) do
+      -> do
+        session.
+          run_command("_orig_#{widget}() { zle .#{widget} }").
+          run_command("zle -N orig-#{widget} _orig_#{widget}").
+          run_command("#{widget}-magic() { zle orig-#{widget}; BUFFER+=b }").
+          run_command("zle -N #{widget} #{widget}-magic")
+      end
+    end
+
+    it 'executes the custom behavior and the built-in behavior' do
+      with_history('foobar', 'foodar') do
+        session.send_string('food').send_keys('C-h')
+        wait_for { session.content }.to eq('foobar')
+      end
+    end
+  end
+
+  context 'initialized after sourcing the plugin' do
+    before do
+      session.
+        run_command("zle -N orig-#{widget} ${widgets[#{widget}]#*:}").
+        run_command("#{widget}-magic() { zle orig-#{widget}; BUFFER+=b }").
+        run_command("zle -N #{widget} #{widget}-magic").
+        clear_screen
+    end
+
+    it 'executes the custom behavior and the built-in behavior' do
+      with_history('foobar', 'foodar') do
+        session.send_string('food').send_keys('C-h')
+        wait_for { session.content }.to eq('foobar')
+      end
+    end
+  end
+end

spec/integrations/zle_input_stack_spec.rb

@@ -0,0 +1,24 @@
+describe 'using `zle -U`' do
+  let(:before_sourcing) do
+    -> do
+      session.
+        run_command('_zsh_autosuggest_strategy_test() { sleep 1; _zsh_autosuggest_strategy_history "$1" }').
+        run_command('foo() { zle -U - "echo hello" }; zle -N foo; bindkey ^B foo')
+    end
+  end
+
+  let(:options) { ['unset ZSH_AUTOSUGGEST_USE_ASYNC', 'ZSH_AUTOSUGGEST_STRATEGY=test'] }
+
+  # TODO: This is only possible with the $KEYS_QUEUED_COUNT widget parameter, coming soon...
+  xit 'does not fetch a suggestion for every inserted character' do
+    session.send_keys('C-b')
+    wait_for { session.content }.to eq('echo hello')
+  end
+
+  it 'shows a suggestion when the widget completes' do
+    with_history('echo hello world') do
+      session.send_keys('C-b')
+      wait_for { session.content(esc_seqs: true) }.to match(/\Aecho hello\e\[[0-9]+m world/)
+    end
+  end
+end

spec/kill_ring_spec.rb

@@ -0,0 +1,23 @@
+context 'with some items in the kill ring' do
+  before do
+    session.
+      send_string('echo foo').
+      send_keys('C-u').
+      send_string('echo bar').
+      send_keys('C-u')
+  end
+
+  describe '`yank-pop`' do
+    it 'should cycle through all items in the kill ring' do
+      session.send_keys('C-y')
+      wait_for { session.content }.to eq('echo bar')
+
+      session.send_keys('escape').send_keys('y')
+      wait_for { session.content }.to eq('echo foo')
+
+      session.send_keys('escape').send_keys('y')
+      wait_for { session.content }.to eq('echo bar')
+    end
+  end
+end
+

spec/line_init_spec.rb

@@ -0,0 +1,17 @@
+context 'with zle-line-init unignored' do
+  let(:after_sourcing) do
+    -> do
+      session.
+        run_command('setopt extendedglob').
+        run_command('ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(${(@)ZSH_AUTOSUGGEST_IGNORE_WIDGETS:#zle-\*} zle-\^line-init)').
+        run_command('zle-line-init() { BUFFER="echo" }')
+    end
+  end
+
+  it 'should fetch a suggestion on each line initialization' do
+    with_history('echo foo') do
+      session.run_command('zle -N zle-line-init')
+      wait_for { session.content }.to end_with('echo foo')
+    end
+  end
+end

spec/multi_line_spec.rb

@@ -0,0 +1,13 @@
+describe 'a multi-line suggestion' do
+  it 'should be displayed on multiple lines' do
+    with_history(-> {
+      session.send_string('echo "')
+      session.send_keys('enter')
+      session.send_string('"')
+      session.send_keys('enter')
+    }) do
+      session.send_keys('e')
+      wait_for { session.content }.to eq("echo \"\n\"")
+    end
+  end
+end

spec/options/buffer_max_size_spec.rb

@@ -0,0 +1,30 @@
+describe 'a suggestion' do
+  let(:term_opts) { { width: 200 } }
+  let(:long_command) { "echo #{'a' * 100}" }
+
+  around do |example|
+    with_history(long_command) { example.run }
+  end
+
+  it 'is provided for any buffer length' do
+    session.send_string(long_command[0...-1])
+    wait_for { session.content }.to eq(long_command)
+  end
+
+  context 'when ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE is specified' do
+    let(:buffer_max_size) { 10 }
+    let(:options) { ["ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=#{buffer_max_size}"] }
+
+    it 'is provided when the buffer is shorter than the specified length' do
+      session.send_string(long_command[0...(buffer_max_size - 1)])
+      wait_for { session.content }.to eq(long_command)
+    end
+
+    it 'is provided when the buffer is equal to the specified length' do
+      session.send_string(long_command[0...(buffer_max_size)])
+      wait_for { session.content }.to eq(long_command)
+    end
+
+    it 'is not provided when the buffer is longer than the specified length'
+  end
+end

spec/options/highlight_style_spec.rb

@@ -0,0 +1,7 @@
+describe 'a displayed suggestion' do
+  it 'is shown in the default style'
+
+  describe 'when ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE is set to a zle_highlight string' do
+    it 'is shown in the specified style'
+  end
+end

spec/options/original_widget_prefix_spec.rb

@@ -0,0 +1,7 @@
+describe 'an original zle widget' do
+  context 'is accessible with the default prefix'
+
+  context 'when ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX is set' do
+    it 'is accessible with the specified prefix'
+  end
+end

spec/options/strategy_spec.rb

@@ -0,0 +1,55 @@
+describe 'a suggestion for a given prefix' do
+  let(:history_strategy) { '_zsh_autosuggest_strategy_history() { suggestion="history" }' }
+  let(:foobar_strategy) { '_zsh_autosuggest_strategy_foobar() { [[ "foobar baz" = $1* ]] && suggestion="foobar baz" }' }
+  let(:foobaz_strategy) { '_zsh_autosuggest_strategy_foobaz() { [[ "foobaz bar" = $1* ]] && suggestion="foobaz bar" }' }
+
+  let(:after_sourcing) do
+    -> do
+      session.run_command(history_strategy)
+    end
+  end
+
+  it 'by default is determined by calling the `history` strategy function' do
+    session.send_string('h')
+    wait_for { session.content }.to eq('history')
+  end
+
+  context 'when ZSH_AUTOSUGGEST_STRATEGY is set to an array' do
+    let(:after_sourcing) do
+      -> do
+        session.
+          run_command(foobar_strategy).
+          run_command(foobaz_strategy).
+          run_command('ZSH_AUTOSUGGEST_STRATEGY=(foobar foobaz)')
+      end
+    end
+
+    it 'is determined by the first strategy function to return a suggestion' do
+      session.send_string('foo')
+      wait_for { session.content }.to eq('foobar baz')
+
+      session.send_string('baz')
+      wait_for { session.content }.to eq('foobaz bar')
+    end
+  end
+
+  context 'when ZSH_AUTOSUGGEST_STRATEGY is set to a string' do
+    let(:after_sourcing) do
+      -> do
+        session.
+          run_command(foobar_strategy).
+          run_command(foobaz_strategy).
+          run_command('ZSH_AUTOSUGGEST_STRATEGY="foobar foobaz"')
+      end
+    end
+
+    it 'is determined by the first strategy function to return a suggestion' do
+      session.send_string('foo')
+      wait_for { session.content }.to eq('foobar baz')
+
+      session.send_string('baz')
+      wait_for { session.content }.to eq('foobaz bar')
+    end
+  end
+end
+

spec/options/use_async_spec.rb

@@ -0,0 +1,7 @@
+describe 'suggestion fetching' do
+  it 'is performed synchronously'
+
+  context 'when ZSH_AUTOSUGGEST_USE_ASYNC is set' do
+    it 'is performed asynchronously'
+  end
+end

spec/options/widget_lists_spec.rb

@@ -0,0 +1,120 @@
+describe 'a zle widget' do
+  let(:widget) { 'my-widget' }
+  let(:before_sourcing) { -> { session.run_command("#{widget}() {}; zle -N #{widget}; bindkey ^B #{widget}") } }
+
+  context 'when added to ZSH_AUTOSUGGEST_ACCEPT_WIDGETS' do
+    let(:options) { ["ZSH_AUTOSUGGEST_ACCEPT_WIDGETS+=(#{widget})"] }
+
+    it 'accepts the suggestion when invoked' do
+      with_history('echo hello') do
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+        session.send_keys('C-b')
+        wait_for { session.content(esc_seqs: true) }.to eq('echo hello')
+      end
+    end
+  end
+
+  context 'when added to ZSH_AUTOSUGGEST_CLEAR_WIDGETS' do
+    let(:options) { ["ZSH_AUTOSUGGEST_CLEAR_WIDGETS+=(#{widget})"] }
+
+    it 'clears the suggestion when invoked' do
+      with_history('echo hello') do
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+        session.send_keys('C-b')
+        wait_for { session.content }.to eq('e')
+      end
+    end
+  end
+
+  context 'when added to ZSH_AUTOSUGGEST_EXECUTE_WIDGETS' do
+    let(:options) { ["ZSH_AUTOSUGGEST_EXECUTE_WIDGETS+=(#{widget})"] }
+
+    it 'executes the suggestion when invoked' do
+      with_history('echo hello') do
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+        session.send_keys('C-b')
+        wait_for { session.content }.to end_with("\nhello")
+      end
+    end
+  end
+
+  context 'when added to ZSH_AUTOSUGGEST_IGNORE_WIDGETS' do
+    let(:options) { ["ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(#{widget})"] }
+
+    it 'should not be wrapped with an autosuggest widget' do
+      session.run_command("echo $widgets[#{widget}]")
+      wait_for { session.content }.to end_with("\nuser:#{widget}")
+    end
+  end
+
+  context 'that moves the cursor forward' do
+    before { session.run_command("#{widget}() { zle forward-char }") }
+
+    context 'when added to ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS' do
+      let(:options) { ["ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS=(#{widget})"] }
+
+      it 'accepts the suggestion as far as the cursor is moved when invoked' do
+        with_history('echo hello') do
+          session.send_string('e')
+          wait_for { session.content }.to start_with('echo hello')
+          session.send_keys('C-b')
+          wait_for { session.content(esc_seqs: true) }.to match(/\Aec\e\[[0-9]+mho hello/)
+        end
+      end
+    end
+  end
+
+  context 'that modifies the buffer' do
+    before { session.run_command("#{widget}() { BUFFER=\"foo\" }") }
+
+    context 'when not added to any of the widget lists' do
+      it 'modifies the buffer and fetches a new suggestion' do
+        with_history('foobar') do
+          session.send_keys('C-b')
+          wait_for { session.content }.to eq('foobar')
+        end
+      end
+    end
+  end
+end
+
+describe 'a modification to the widget lists' do
+  let(:widget) { 'my-widget' }
+  let(:before_sourcing) { -> { session.run_command("#{widget}() {}; zle -N #{widget}; bindkey ^B #{widget}") } }
+  before { session.run_command("ZSH_AUTOSUGGEST_ACCEPT_WIDGETS+=(#{widget})") }
+
+  it 'takes effect on the next cmd line' do
+    with_history('echo hello') do
+      session.send_string('e')
+      wait_for { session.content }.to eq('echo hello')
+      session.send_keys('C-b')
+      wait_for { session.content(esc_seqs: true) }.to eq('echo hello')
+    end
+  end
+
+  context 'when manual rebind is enabled' do
+    let(:options) { ["ZSH_AUTOSUGGEST_MANUAL_REBIND=true"] }
+
+    it 'does not take effect until bind command is re-run' do
+      with_history('echo hello') do
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+        session.send_keys('C-b')
+        sleep 1
+        expect(session.content(esc_seqs: true)).not_to eq('echo hello')
+
+        session.send_keys('C-c')
+        session.run_command('_zsh_autosuggest_bind_widgets').clear_screen
+        wait_for { session.content }.to eq('')
+
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+        session.send_keys('C-b')
+        wait_for { session.content(esc_seqs: true) }.to eq('echo hello')
+      end
+    end
+  end
+end

spec/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'pry'
+require 'rspec/wait'
+require 'terminal_session'
+
+RSpec.shared_context 'terminal session' do
+  let(:term_opts) { {} }
+  let(:session) { TerminalSession.new(term_opts) }
+  let(:before_sourcing) { -> {} }
+  let(:after_sourcing) { -> {} }
+  let(:options) { [] }
+
+  around do |example|
+    before_sourcing.call
+    session.run_command(['source zsh-autosuggestions.zsh', *options].join('; '))
+    after_sourcing.call
+    session.clear_screen
+
+    example.run
+
+    session.destroy
+  end
+
+  def with_history(*commands, &block)
+    session.run_command('fc -p')
+
+    commands.each do |c|
+      c.respond_to?(:call) ? c.call : session.run_command(c)
+    end
+
+    session.clear_screen
+
+    yield block
+
+    session.send_keys('C-c')
+    session.run_command('fc -P')
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.wait_timeout = 2
+
+  config.include_context 'terminal session'
+end

spec/strategies/completion_spec.rb

@@ -0,0 +1,38 @@
+describe 'the `completion` suggestion strategy' do
+  let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=completion'] }
+  let(:before_sourcing) do
+    -> do
+      session.
+        run_command('autoload compinit && compinit').
+        run_command('_foo() { compadd bar; compadd bat }').
+        run_command('compdef _foo baz')
+    end
+  end
+
+  it 'suggests the first completion result' do
+    session.send_string('baz ')
+    wait_for { session.content }.to eq('baz bar')
+  end
+
+  it 'does not add extra carriage returns when prefix has a line feed' do
+    skip '`stty` does not work inside zpty below zsh version 5.0.3' if session.zsh_version < Gem::Version.new('5.0.3')
+    session.send_string('baz \\').send_keys('C-v', 'C-j')
+    wait_for { session.content }.to eq("baz \\\nbar")
+  end
+
+  context 'when async mode is enabled' do
+    let(:options) { ['ZSH_AUTOSUGGEST_USE_ASYNC=true', 'ZSH_AUTOSUGGEST_STRATEGY=completion'] }
+
+    it 'suggests the first completion result' do
+      session.send_string('baz ')
+      wait_for { session.content }.to eq('baz bar')
+    end
+
+    it 'does not add extra carriage returns when prefix has a line feed' do
+      skip '`stty` does not work inside zpty below zsh version 5.0.3' if session.zsh_version < Gem::Version.new('5.0.3')
+      session.send_string('baz \\').send_keys('C-v', 'C-j')
+      wait_for { session.content }.to eq("baz \\\nbar")
+    end
+  end
+end
+

spec/strategies/history_spec.rb

@@ -0,0 +1,12 @@
+require 'strategies/special_characters_helper'
+
+describe 'the `history` suggestion strategy' do
+  it 'suggests the last matching history entry' do
+    with_history('ls foo', 'ls bar', 'echo baz') do
+      session.send_string('ls')
+      wait_for { session.content }.to eq('ls bar')
+    end
+  end
+
+  include_examples 'special characters'
+end

spec/strategies/match_prev_cmd_spec.rb

@@ -0,0 +1,21 @@
+require 'strategies/special_characters_helper'
+
+describe 'the `match_prev_cmd` strategy' do
+  let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=match_prev_cmd'] }
+
+  it 'suggests the last matching history entry after the previous command' do
+    with_history(
+      'echo what',
+      'ls foo',
+      'echo what',
+      'ls bar',
+      'ls baz',
+      'echo what'
+    ) do
+      session.send_string('ls')
+      wait_for { session.content }.to eq('ls bar')
+    end
+  end
+
+  include_examples 'special characters'
+end

spec/strategies/special_characters_helper.rb

@@ -0,0 +1,62 @@
+shared_examples 'special characters' do
+  describe 'a special character in the buffer' do
+    it 'should be treated like any other character' do
+      with_history('echo "hello*"', 'echo "hello."') do
+        session.send_string('echo "hello*')
+        wait_for { session.content }.to eq('echo "hello*"')
+      end
+
+      with_history('echo "hello?"', 'echo "hello."') do
+        session.send_string('echo "hello?')
+        wait_for { session.content }.to eq('echo "hello?"')
+      end
+
+      with_history('echo "hello\nworld"') do
+        session.send_string('echo "hello\\')
+        wait_for { session.content }.to eq('echo "hello\nworld"')
+      end
+
+      with_history('echo "\\\\"') do
+        session.send_string('echo "\\\\')
+        wait_for { session.content }.to eq('echo "\\\\"')
+      end
+
+      with_history('echo ~/foo') do
+        session.send_string('echo ~')
+        wait_for { session.content }.to eq('echo ~/foo')
+      end
+
+      with_history('echo "$(ls foo)"') do
+        session.send_string('echo "$(')
+        wait_for { session.content }.to eq('echo "$(ls foo)"')
+      end
+
+      with_history('echo "$history[123]"') do
+        session.send_string('echo "$history[')
+        wait_for { session.content }.to eq('echo "$history[123]"')
+        session.send_string('123]')
+        wait_for { session.content }.to eq('echo "$history[123]"')
+      end
+
+      with_history('echo "#yolo"') do
+        session.send_string('echo "#')
+        wait_for { session.content }.to eq('echo "#yolo"')
+      end
+
+      with_history('echo "#foo"', 'echo $#abc') do
+        session.send_string('echo "#')
+        wait_for { session.content }.to eq('echo "#foo"')
+      end
+
+      with_history('echo "^A"', 'echo "^B"') do
+        session.send_string('echo "^A')
+        wait_for { session.content }.to eq('echo "^A"')
+      end
+
+      with_history('-foo() {}') do
+        session.send_string('-')
+        wait_for { session.content }.to eq('-foo() {}')
+      end
+    end
+  end
+end

spec/terminal_session.rb

@@ -0,0 +1,99 @@
+require 'securerandom'
+
+class TerminalSession
+  ZSH_BIN = ENV['TEST_ZSH_BIN'] || 'zsh'
+
+  def initialize(opts = {})
+    opts = {
+      width: 80,
+      height: 24,
+      prompt: '',
+      term: 'xterm-256color',
+      zsh_bin: ZSH_BIN
+    }.merge(opts)
+
+    @opts = opts
+
+    cmd="PS1=\"#{opts[:prompt]}\" TERM=#{opts[:term]} #{ZSH_BIN} -f"
+    tmux_command("new-session -d -x #{opts[:width]} -y #{opts[:height]} '#{cmd}'")
+  end
+
+  def zsh_version
+    @zsh_version ||= Gem::Version.new(`#{ZSH_BIN} -c 'echo -n $ZSH_VERSION'`)
+  end
+
+  def tmux_socket_name
+    @tmux_socket_name ||= SecureRandom.hex(6)
+  end
+
+  def run_command(command)
+    send_string(command)
+    send_keys('enter')
+
+    self
+  end
+
+  def send_string(str)
+    tmux_command("send-keys -t 0 -l -- '#{str.gsub("'", "\\'")}'")
+
+    self
+  end
+
+  def send_keys(*keys)
+    tmux_command("send-keys -t 0 #{keys.join(' ')}")
+
+    self
+  end
+
+  def paste_string(str)
+    tmux_command("set-buffer -- '#{str}'")
+    tmux_command("paste-buffer -dpr -t 0")
+
+    self
+  end
+
+  def content(esc_seqs: false)
+    cmd = 'capture-pane -p -t 0'
+    cmd += ' -e' if esc_seqs
+    tmux_command(cmd).strip
+  end
+
+  def clear_screen
+    send_keys('C-l')
+
+    i = 0
+    until content == opts[:prompt] || i > 20 do
+      sleep(0.1)
+      i = i + 1
+    end
+
+    self
+  end
+
+  def destroy
+    tmux_command('kill-session')
+  end
+
+  def cursor
+    tmux_command("display-message -t 0 -p '\#{cursor_x},\#{cursor_y}'").
+      strip.
+      split(',').
+      map(&:to_i)
+  end
+
+  def attach!
+    tmux_command('attach-session')
+  end
+
+  private
+
+  attr_reader :opts
+
+  def tmux_command(cmd)
+    out = `tmux -u -L #{tmux_socket_name} #{cmd}`
+
+    raise("tmux error running: '#{cmd}'") unless $?.success?
+
+    out
+  end
+end

spec/widgets/disable_spec.rb

@@ -0,0 +1,19 @@
+describe 'the `autosuggest-disable` widget' do
+  before do
+    session.run_command('bindkey ^B autosuggest-disable')
+  end
+
+  it 'disables suggestions and clears the suggestion' do
+    with_history('echo hello') do
+      session.send_string('echo')
+      wait_for { session.content }.to eq('echo hello')
+
+      session.send_keys('C-b')
+      wait_for { session.content }.to eq('echo')
+
+      session.send_string(' h')
+      sleep 1
+      expect(session.content).to eq('echo h')
+    end
+  end
+end

spec/widgets/enable_spec.rb

@@ -0,0 +1,42 @@
+describe 'the `autosuggest-enable` widget' do
+  before do
+    session.
+      run_command('typeset -g _ZSH_AUTOSUGGEST_DISABLED').
+      run_command('bindkey ^B autosuggest-enable')
+  end
+
+  it 'enables suggestions and fetches a suggestion' do
+    with_history('echo hello') do
+      session.send_string('e')
+      sleep 1
+      expect(session.content).to eq('e')
+
+      session.send_keys('C-b')
+      session.send_string('c')
+      wait_for { session.content }.to eq('echo hello')
+    end
+  end
+
+  context 'invoked on an empty buffer' do
+    it 'does not fetch a suggestion' do
+      with_history('echo hello') do
+        session.send_keys('C-b')
+        sleep 1
+        expect(session.content).to eq('')
+      end
+    end
+  end
+
+  context 'invoked on a non-empty buffer' do
+    it 'fetches a suggestion' do
+      with_history('echo hello') do
+        session.send_string('e')
+        sleep 1
+        expect(session.content).to eq('e')
+
+        session.send_keys('C-b')
+        wait_for { session.content }.to eq('echo hello')
+      end
+    end
+  end
+end

spec/widgets/fetch_spec.rb

@@ -0,0 +1,24 @@
+describe 'the `autosuggest-fetch` widget' do
+  context 'when suggestions are disabled' do
+    before do
+      session.
+        run_command('bindkey ^B autosuggest-disable').
+        run_command('bindkey ^F autosuggest-fetch').
+        send_keys('C-b')
+    end
+
+    it 'will fetch and display a suggestion' do
+      with_history('echo hello') do
+        session.send_string('echo h')
+        sleep 1
+        expect(session.content).to eq('echo h')
+
+        session.send_keys('C-f')
+        wait_for { session.content }.to eq('echo hello')
+
+        session.send_string('e')
+        wait_for { session.content }.to eq('echo hello')
+      end
+    end
+  end
+end

spec/widgets/toggle_spec.rb

@@ -0,0 +1,26 @@
+describe 'the `autosuggest-toggle` widget' do
+  before do
+    session.run_command('bindkey ^B autosuggest-toggle')
+  end
+
+  it 'toggles suggestions' do
+    with_history('echo world', 'echo hello') do
+      session.send_string('echo')
+      wait_for { session.content }.to eq('echo hello')
+
+      session.send_keys('C-b')
+      wait_for { session.content }.to eq('echo')
+
+      session.send_string(' h')
+      sleep 1
+      expect(session.content).to eq('echo h')
+
+      session.send_keys('C-b')
+      wait_for { session.content }.to eq('echo hello')
+
+      session.send_keys('C-h')
+      session.send_string('w')
+      wait_for { session.content }.to eq('echo world')
+    end
+  end
+end

src/async.zsh

@@ -0,0 +1,72 @@
+
+#--------------------------------------------------------------------#
+# Async                                                              #
+#--------------------------------------------------------------------#
+
+zmodload zsh/system
+
+_zsh_autosuggest_async_request() {
+	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
+
+	# 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 and remove the handler
+		exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&-
+		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
+
+		# Zsh will make a new process group for the child process only if job
+		# control is enabled (MONITOR option)
+		if [[ -o MONITOR ]]; then
+			# Send the signal to the process group to kill any processes that may
+			# have been forked by the suggestion strategy
+			kill -TERM -$_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		else
+			# Kill just the child process since it wasn't placed in a new process
+			# group. If the suggestion strategy forked any child processes they may
+			# be orphaned and left behind.
+			kill -TERM $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		fi
+	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"
+	)
+
+	# There's a weird bug here where ^C stops working unless we force a fork
+	# See https://github.com/zsh-users/zsh-autosuggestions/issues/364
+	command true
+
+	# 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
+}
+
+# Called when new data is ready to be read from the pipe
+# First arg will be fd ready for reading
+# Second arg will be passed in case of error
+_zsh_autosuggest_async_response() {
+	emulate -L zsh
+
+	local suggestion
+
+	if [[ -z "$2" || "$2" == "hup" ]]; then
+		# Read everything from the fd and give it as a suggestion
+		IFS='' read -rd '' -u $1 suggestion
+		zle autosuggest-suggest -- "$suggestion"
+
+		# Close the fd
+		exec {1}<&-
+	fi
+
+	# Always remove the handler
+	zle -F "$1"
+}

src/bind.zsh

@@ -0,0 +1,106 @@
+
+#--------------------------------------------------------------------#
+# Widget Helpers                                                     #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_incr_bind_count() {
+	typeset -gi bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]+1))
+	_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=$bind_count
+}
+
+# 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
+
+	local widget=$1
+	local autosuggest_action=$2
+	local prefix=$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX
+
+	local -i bind_count
+
+	# Save a reference to the original widget
+	case $widgets[$widget] in
+		# Already bound
+		user:_zsh_autosuggest_(bound|orig)_*)
+			bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$widget]))
+			;;
+
+		# User-defined widget
+		user:*)
+			_zsh_autosuggest_incr_bind_count $widget
+			zle -N $prefix$bind_count-$widget ${widgets[$widget]#*:}
+			;;
+
+		# 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
+			;;
+
+		# Completion widget
+		completion:*)
+			_zsh_autosuggest_incr_bind_count $widget
+			eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
+			;;
+	esac
+
+	# 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} \$@
+	}"
+
+	# Create the bound widget
+	zle -N -- $widget _zsh_autosuggest_bound_${bind_count}_$widget
+}
+
+# Map all configured widgets to the right autosuggest widgets
+_zsh_autosuggest_bind_widgets() {
+	emulate -L zsh
+
+ 	local widget
+	local ignore_widgets
+
+	ignore_widgets=(
+		.\*
+		_\*
+		autosuggest-\*
+		$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\*
+		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	)
+
+	# 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
+		else
+			# Assume any unspecified widget might modify the buffer
+			_zsh_autosuggest_bind_widget $widget modify
+		fi
+	done
+}
+
+# Given the name of an original widget and args, invoke it, if it exists
+_zsh_autosuggest_invoke_original_widget() {
+	# Do nothing unless called with at least one arg
+	(( $# )) || return 0
+
+	local original_widget_name="$1"
+
+	shift
+
+	if (( ${+widgets[$original_widget_name]} )); then
+		zle $original_widget_name -- $@
+	fi
+}

src/config.zsh

@@ -0,0 +1,93 @@
+
+#--------------------------------------------------------------------#
+# Global Configuration Variables                                     #
+#--------------------------------------------------------------------#
+
+# 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} )) &&
+typeset -g ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'
+
+# Prefix to use when saving original versions of bound widgets
+(( ! ${+ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX} )) &&
+typeset -g 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} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_STRATEGY
+	ZSH_AUTOSUGGEST_STRATEGY=(history)
+}
+
+# Widgets that clear the suggestion
+(( ! ${+ZSH_AUTOSUGGEST_CLEAR_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+	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
+		up-line-or-history
+		down-line-or-history
+		accept-line
+		copy-earlier-word
+	)
+}
+
+# Widgets that accept the entire suggestion
+(( ! ${+ZSH_AUTOSUGGEST_ACCEPT_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+	ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(
+		forward-char
+		end-of-line
+		vi-forward-char
+		vi-end-of-line
+		vi-add-eol
+	)
+}
+
+# Widgets that accept the entire suggestion and execute it
+(( ! ${+ZSH_AUTOSUGGEST_EXECUTE_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_EXECUTE_WIDGETS
+	ZSH_AUTOSUGGEST_EXECUTE_WIDGETS=(
+	)
+}
+
+# Widgets that accept the suggestion as far as the cursor moves
+(( ! ${+ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
+	ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS=(
+		forward-word
+		emacs-forward-word
+		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
+	)
+}
+
+# Widgets that should be ignored (globbing supported but must be escaped)
+(( ! ${+ZSH_AUTOSUGGEST_IGNORE_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(
+		orig-\*
+		beep
+		run-help
+		set-local-history
+		which-command
+		yank
+		yank-pop
+		zle-\*
+	)
+}
+
+# Pty name for capturing completions for completion suggestion strategy
+(( ! ${+ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME} )) &&
+typeset -g ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME=zsh_autosuggest_completion_pty

src/fetch.zsh

@@ -0,0 +1,27 @@
+
+#--------------------------------------------------------------------#
+# 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"
+
+		# Ensure the suggestion matches the prefix
+		[[ "$suggestion" != "$1"* ]] && unset suggestion
+
+		# Break once we've found a valid suggestion
+		[[ -n "$suggestion" ]] && break
+	done
+}

src/highlight.zsh

@@ -0,0 +1,26 @@
+
+#--------------------------------------------------------------------#
+# Highlighting                                                       #
+#--------------------------------------------------------------------#
+
+# If there was a highlight, remove it
+_zsh_autosuggest_highlight_reset() {
+	typeset -g _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
+
+	if [[ -n "$_ZSH_AUTOSUGGEST_LAST_HIGHLIGHT" ]]; then
+		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() {
+	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")
+	else
+		unset _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
+	fi
+}

src/start.zsh

@@ -0,0 +1,23 @@
+
+#--------------------------------------------------------------------#
+# Start                                                              #
+#--------------------------------------------------------------------#
+
+# Start the autosuggestion widgets
+_zsh_autosuggest_start() {
+	# By default we 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. However this has
+	# a decent performance hit, so users can set ZSH_AUTOSUGGEST_MANUAL_REBIND
+	# to disable the automatic re-binding.
+	if (( ${+ZSH_AUTOSUGGEST_MANUAL_REBIND} )); then
+		add-zsh-hook -d precmd _zsh_autosuggest_start
+	fi
+
+	_zsh_autosuggest_bind_widgets
+}
+
+# Start the autosuggestion widgets on the next precmd
+autoload -Uz add-zsh-hook
+add-zsh-hook precmd _zsh_autosuggest_start

src/strategies/completion.zsh

@@ -0,0 +1,130 @@
+
+#--------------------------------------------------------------------#
+# Completion Suggestion Strategy                                     #
+#--------------------------------------------------------------------#
+# Fetches a suggestion from the completion engine
+#
+
+_zsh_autosuggest_capture_postcompletion() {
+	# Always insert the first completion into the buffer
+	compstate[insert]=1
+
+	# Don't list completions
+	unset 'compstate[list]'
+}
+
+_zsh_autosuggest_capture_completion_widget() {
+	# Add a post-completion hook to be called after all completions have been
+	# gathered. The hook can modify compstate to affect what is done with the
+	# gathered completions.
+	local -a +h comppostfuncs
+	comppostfuncs=(_zsh_autosuggest_capture_postcompletion)
+
+	# Only capture completions at the end of the buffer
+	CURSOR=$#BUFFER
+
+	# Run the original widget wrapping `.complete-word` so we don't
+	# recursively try to fetch suggestions, since our pty is forked
+	# after autosuggestions is initialized.
+	zle -- ${(k)widgets[(r)completion:.complete-word:_main_complete]}
+
+	if is-at-least 5.0.3; then
+		# Don't do any cr/lf transformations. We need to do this immediately before
+		# output because if we do it in setup, onlcr will be re-enabled when we enter
+		# vared in the async code path. There is a bug in zpty module in older versions
+		# where the tty is not properly attached to the pty slave, resulting in stty
+		# getting stopped with a SIGTTOU. See zsh-workers thread 31660 and upstream
+		# commit f75904a38
+		stty -onlcr -ocrnl -F /dev/tty
+	fi
+
+	# The completion has been added, print the buffer as the suggestion
+	echo -nE - $'\0'$BUFFER$'\0'
+}
+
+zle -N autosuggest-capture-completion _zsh_autosuggest_capture_completion_widget
+
+_zsh_autosuggest_capture_setup() {
+	autoload -Uz is-at-least
+
+	# There is a bug in zpty module in older zsh versions 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.
+	if ! is-at-least 5.4; then
+		zshexit() {
+			# The zsh builtin `kill` fails sometimes in older versions
+			# https://unix.stackexchange.com/a/477647/156673
+			kill -KILL $$ 2>&- || command kill -KILL $$
+
+			# Block for long enough for the signal to come through
+			sleep 1
+		}
+	fi
+
+	# Try to avoid any suggestions that wouldn't match the prefix
+	zstyle ':completion:*' matcher-list ''
+	zstyle ':completion:*' path-completion false
+	zstyle ':completion:*' max-errors 0 not-numeric
+
+	bindkey '^I' autosuggest-capture-completion
+}
+
+_zsh_autosuggest_capture_completion_sync() {
+	_zsh_autosuggest_capture_setup
+
+	zle autosuggest-capture-completion
+}
+
+_zsh_autosuggest_capture_completion_async() {
+	_zsh_autosuggest_capture_setup
+
+	zmodload zsh/parameter 2>/dev/null || return # 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 1
+}
+
+_zsh_autosuggest_strategy_completion() {
+	typeset -g suggestion
+	local line REPLY
+
+	# Exit if we don't have completions
+	whence compdef >/dev/null || return
+
+	# Exit if we don't have zpty
+	zmodload zsh/zpty 2>/dev/null || return
+
+	# Zle will be inactive if we are in async mode
+	if zle; then
+		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_sync
+	else
+		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_async "\$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'
+
+		# Extract the suggestion from between the null bytes.  On older
+		# versions of zsh (older than 5.3), we sometimes get extra bytes after
+		# the second null byte, so trim those off the end.
+		# See http://www.zsh.org/mla/workers/2015/msg03290.html
+		suggestion="${${line#*$'\0'}%$'\0'*}"
+	} always {
+		# Destroy the pty
+		zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME
+	}
+}

src/strategies/history.zsh

@@ -0,0 +1,25 @@
+
+#--------------------------------------------------------------------#
+# 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}"
+
+	# Get the history items that match
+	# - (r) subscript flag makes the pattern match on values
+	typeset -g suggestion="${history[(r)${prefix}*]}"
+}

src/strategies/match_prev_cmd.zsh

@@ -0,0 +1,59 @@
+
+#--------------------------------------------------------------------#
+# Match Previous Command Suggestion Strategy                         #
+#--------------------------------------------------------------------#
+# Suggests the most recent history item that matches the given
+# prefix and whose preceding history item also matches the most
+# recently executed command.
+#
+# 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
+		if [[ "${history[$((key - 1))]}" == "$prev_cmd" ]]; then
+			histkey="$key"
+			break
+		fi
+	done
+
+	# Give back the matched history entry
+	typeset -g suggestion="$history[$histkey]"
+}

src/util.zsh

@@ -0,0 +1,11 @@
+
+#--------------------------------------------------------------------#
+# Utility Functions                                                  #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_escape_command() {
+	setopt localoptions EXTENDED_GLOB
+
+	# Escape special chars in the string (requires EXTENDED_GLOB)
+	echo -E "${1//(#m)[\"\'\\()\[\]|*?~]/\\$MATCH}"
+}

src/widgets.zsh

@@ -0,0 +1,220 @@
+
+#--------------------------------------------------------------------#
+# Autosuggest Widget Implementations                                 #
+#--------------------------------------------------------------------#
+
+# 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
+}
+
+# Clear the suggestion
+_zsh_autosuggest_clear() {
+	# Remove the suggestion
+	unset POSTDISPLAY
+
+	_zsh_autosuggest_invoke_original_widget $@
+}
+
+# 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"
+
+	# Clear suggestion while waiting for next one
+	unset POSTDISPLAY
+
+	# Original widget may modify the buffer
+	_zsh_autosuggest_invoke_original_widget $@
+	retval=$?
+
+	emulate -L zsh
+
+	# 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
+
+	# 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
+			_zsh_autosuggest_fetch
+		fi
+	fi
+
+	return $retval
+}
+
+# Fetch a new suggestion based on what's currently in the buffer
+_zsh_autosuggest_fetch() {
+	if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then
+		_zsh_autosuggest_async_request "$BUFFER"
+	else
+		local suggestion
+		_zsh_autosuggest_fetch_suggestion "$BUFFER"
+		_zsh_autosuggest_suggest "$suggestion"
+	fi
+}
+
+# Offer a suggestion
+_zsh_autosuggest_suggest() {
+	emulate -L zsh
+
+	local suggestion="$1"
+
+	if [[ -n "$suggestion" ]] && (( $#BUFFER )); then
+		POSTDISPLAY="${suggestion#$BUFFER}"
+	else
+		unset POSTDISPLAY
+	fi
+}
+
+# Accept the entire suggestion
+_zsh_autosuggest_accept() {
+	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
+		max_cursor_pos=$((max_cursor_pos - 1))
+	fi
+
+	# Only accept if the cursor is at the end of the buffer
+	if [[ $CURSOR = $max_cursor_pos ]]; then
+		# 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 $@
+}
+
+# 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"
+}
+
+# Partially accept the suggestion
+_zsh_autosuggest_partial_accept() {
+	local -i retval cursor_loc
+
+	# Save the contents of the buffer so we can restore later if needed
+	local original_buffer="$BUFFER"
+
+	# Temporarily accept the suggestion.
+	BUFFER="$BUFFER$POSTDISPLAY"
+
+	# Original widget moves the cursor
+	_zsh_autosuggest_invoke_original_widget $@
+	retval=$?
+
+	# Normalize cursor location across vi/emacs modes
+	cursor_loc=$CURSOR
+	if [[ "$KEYMAP" = "vicmd" ]]; then
+		cursor_loc=$((cursor_loc + 1))
+	fi
+
+	# If we've moved past the end of the original buffer
+	if (( $cursor_loc > $#original_buffer )); then
+		# Set POSTDISPLAY to text right of the cursor
+		POSTDISPLAY="${BUFFER[$(($cursor_loc + 1)),$#BUFFER]}"
+
+		# Clip the buffer at the cursor
+		BUFFER="${BUFFER[1,$cursor_loc]}"
+	else
+		# Restore the original buffer
+		BUFFER="$original_buffer"
+	fi
+
+	return $retval
+}
+
+() {
+	local action
+	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
+
+			zle -R
+
+			return \$retval
+		}"
+	done
+
+	zle -N autosuggest-fetch _zsh_autosuggest_widget_fetch
+	zle -N autosuggest-suggest _zsh_autosuggest_widget_suggest
+	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
+}

zsh-autosuggestions.plugin.zsh

@@ -0,0 +1 @@
+source ${0:A:h}/zsh-autosuggestions.zsh

zsh-autosuggestions.zsh

@@ -0,0 +1,818 @@
+# Fish-like fast/unobtrusive autosuggestions for zsh.
+# https://github.com/zsh-users/zsh-autosuggestions
+# v0.6.0
+# Copyright (c) 2013 Thiago de Arruda
+# Copyright (c) 2016-2018 Eric Freese
+# 
+# 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.
+
+#--------------------------------------------------------------------#
+# Global Configuration Variables                                     #
+#--------------------------------------------------------------------#
+
+# 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} )) &&
+typeset -g ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'
+
+# Prefix to use when saving original versions of bound widgets
+(( ! ${+ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX} )) &&
+typeset -g 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} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_STRATEGY
+	ZSH_AUTOSUGGEST_STRATEGY=(history)
+}
+
+# Widgets that clear the suggestion
+(( ! ${+ZSH_AUTOSUGGEST_CLEAR_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+	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
+		up-line-or-history
+		down-line-or-history
+		accept-line
+		copy-earlier-word
+	)
+}
+
+# Widgets that accept the entire suggestion
+(( ! ${+ZSH_AUTOSUGGEST_ACCEPT_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+	ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(
+		forward-char
+		end-of-line
+		vi-forward-char
+		vi-end-of-line
+		vi-add-eol
+	)
+}
+
+# Widgets that accept the entire suggestion and execute it
+(( ! ${+ZSH_AUTOSUGGEST_EXECUTE_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_EXECUTE_WIDGETS
+	ZSH_AUTOSUGGEST_EXECUTE_WIDGETS=(
+	)
+}
+
+# Widgets that accept the suggestion as far as the cursor moves
+(( ! ${+ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
+	ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS=(
+		forward-word
+		emacs-forward-word
+		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
+	)
+}
+
+# Widgets that should be ignored (globbing supported but must be escaped)
+(( ! ${+ZSH_AUTOSUGGEST_IGNORE_WIDGETS} )) && {
+	typeset -ga ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(
+		orig-\*
+		beep
+		run-help
+		set-local-history
+		which-command
+		yank
+		yank-pop
+		zle-\*
+	)
+}
+
+# Pty name for capturing completions for completion suggestion strategy
+(( ! ${+ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME} )) &&
+typeset -g ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME=zsh_autosuggest_completion_pty
+
+#--------------------------------------------------------------------#
+# Utility Functions                                                  #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_escape_command() {
+	setopt localoptions EXTENDED_GLOB
+
+	# Escape special chars in the string (requires EXTENDED_GLOB)
+	echo -E "${1//(#m)[\"\'\\()\[\]|*?~]/\\$MATCH}"
+}
+
+#--------------------------------------------------------------------#
+# Widget Helpers                                                     #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_incr_bind_count() {
+	typeset -gi bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]+1))
+	_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=$bind_count
+}
+
+# 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
+
+	local widget=$1
+	local autosuggest_action=$2
+	local prefix=$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX
+
+	local -i bind_count
+
+	# Save a reference to the original widget
+	case $widgets[$widget] in
+		# Already bound
+		user:_zsh_autosuggest_(bound|orig)_*)
+			bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$widget]))
+			;;
+
+		# User-defined widget
+		user:*)
+			_zsh_autosuggest_incr_bind_count $widget
+			zle -N $prefix$bind_count-$widget ${widgets[$widget]#*:}
+			;;
+
+		# 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
+			;;
+
+		# Completion widget
+		completion:*)
+			_zsh_autosuggest_incr_bind_count $widget
+			eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
+			;;
+	esac
+
+	# 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} \$@
+	}"
+
+	# Create the bound widget
+	zle -N -- $widget _zsh_autosuggest_bound_${bind_count}_$widget
+}
+
+# Map all configured widgets to the right autosuggest widgets
+_zsh_autosuggest_bind_widgets() {
+	emulate -L zsh
+
+ 	local widget
+	local ignore_widgets
+
+	ignore_widgets=(
+		.\*
+		_\*
+		autosuggest-\*
+		$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\*
+		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	)
+
+	# 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
+		else
+			# Assume any unspecified widget might modify the buffer
+			_zsh_autosuggest_bind_widget $widget modify
+		fi
+	done
+}
+
+# Given the name of an original widget and args, invoke it, if it exists
+_zsh_autosuggest_invoke_original_widget() {
+	# Do nothing unless called with at least one arg
+	(( $# )) || return 0
+
+	local original_widget_name="$1"
+
+	shift
+
+	if (( ${+widgets[$original_widget_name]} )); then
+		zle $original_widget_name -- $@
+	fi
+}
+
+#--------------------------------------------------------------------#
+# Highlighting                                                       #
+#--------------------------------------------------------------------#
+
+# If there was a highlight, remove it
+_zsh_autosuggest_highlight_reset() {
+	typeset -g _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
+
+	if [[ -n "$_ZSH_AUTOSUGGEST_LAST_HIGHLIGHT" ]]; then
+		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() {
+	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")
+	else
+		unset _ZSH_AUTOSUGGEST_LAST_HIGHLIGHT
+	fi
+}
+
+#--------------------------------------------------------------------#
+# Autosuggest Widget Implementations                                 #
+#--------------------------------------------------------------------#
+
+# 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
+}
+
+# Clear the suggestion
+_zsh_autosuggest_clear() {
+	# Remove the suggestion
+	unset POSTDISPLAY
+
+	_zsh_autosuggest_invoke_original_widget $@
+}
+
+# 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"
+
+	# Clear suggestion while waiting for next one
+	unset POSTDISPLAY
+
+	# Original widget may modify the buffer
+	_zsh_autosuggest_invoke_original_widget $@
+	retval=$?
+
+	emulate -L zsh
+
+	# 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
+
+	# 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
+			_zsh_autosuggest_fetch
+		fi
+	fi
+
+	return $retval
+}
+
+# Fetch a new suggestion based on what's currently in the buffer
+_zsh_autosuggest_fetch() {
+	if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then
+		_zsh_autosuggest_async_request "$BUFFER"
+	else
+		local suggestion
+		_zsh_autosuggest_fetch_suggestion "$BUFFER"
+		_zsh_autosuggest_suggest "$suggestion"
+	fi
+}
+
+# Offer a suggestion
+_zsh_autosuggest_suggest() {
+	emulate -L zsh
+
+	local suggestion="$1"
+
+	if [[ -n "$suggestion" ]] && (( $#BUFFER )); then
+		POSTDISPLAY="${suggestion#$BUFFER}"
+	else
+		unset POSTDISPLAY
+	fi
+}
+
+# Accept the entire suggestion
+_zsh_autosuggest_accept() {
+	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
+		max_cursor_pos=$((max_cursor_pos - 1))
+	fi
+
+	# Only accept if the cursor is at the end of the buffer
+	if [[ $CURSOR = $max_cursor_pos ]]; then
+		# 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 $@
+}
+
+# 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"
+}
+
+# Partially accept the suggestion
+_zsh_autosuggest_partial_accept() {
+	local -i retval cursor_loc
+
+	# Save the contents of the buffer so we can restore later if needed
+	local original_buffer="$BUFFER"
+
+	# Temporarily accept the suggestion.
+	BUFFER="$BUFFER$POSTDISPLAY"
+
+	# Original widget moves the cursor
+	_zsh_autosuggest_invoke_original_widget $@
+	retval=$?
+
+	# Normalize cursor location across vi/emacs modes
+	cursor_loc=$CURSOR
+	if [[ "$KEYMAP" = "vicmd" ]]; then
+		cursor_loc=$((cursor_loc + 1))
+	fi
+
+	# If we've moved past the end of the original buffer
+	if (( $cursor_loc > $#original_buffer )); then
+		# Set POSTDISPLAY to text right of the cursor
+		POSTDISPLAY="${BUFFER[$(($cursor_loc + 1)),$#BUFFER]}"
+
+		# Clip the buffer at the cursor
+		BUFFER="${BUFFER[1,$cursor_loc]}"
+	else
+		# Restore the original buffer
+		BUFFER="$original_buffer"
+	fi
+
+	return $retval
+}
+
+() {
+	local action
+	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
+
+			zle -R
+
+			return \$retval
+		}"
+	done
+
+	zle -N autosuggest-fetch _zsh_autosuggest_widget_fetch
+	zle -N autosuggest-suggest _zsh_autosuggest_widget_suggest
+	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
+}
+
+#--------------------------------------------------------------------#
+# Completion Suggestion Strategy                                     #
+#--------------------------------------------------------------------#
+# Fetches a suggestion from the completion engine
+#
+
+_zsh_autosuggest_capture_postcompletion() {
+	# Always insert the first completion into the buffer
+	compstate[insert]=1
+
+	# Don't list completions
+	unset 'compstate[list]'
+}
+
+_zsh_autosuggest_capture_completion_widget() {
+	# Add a post-completion hook to be called after all completions have been
+	# gathered. The hook can modify compstate to affect what is done with the
+	# gathered completions.
+	local -a +h comppostfuncs
+	comppostfuncs=(_zsh_autosuggest_capture_postcompletion)
+
+	# Only capture completions at the end of the buffer
+	CURSOR=$#BUFFER
+
+	# Run the original widget wrapping `.complete-word` so we don't
+	# recursively try to fetch suggestions, since our pty is forked
+	# after autosuggestions is initialized.
+	zle -- ${(k)widgets[(r)completion:.complete-word:_main_complete]}
+
+	if is-at-least 5.0.3; then
+		# Don't do any cr/lf transformations. We need to do this immediately before
+		# output because if we do it in setup, onlcr will be re-enabled when we enter
+		# vared in the async code path. There is a bug in zpty module in older versions
+		# where the tty is not properly attached to the pty slave, resulting in stty
+		# getting stopped with a SIGTTOU. See zsh-workers thread 31660 and upstream
+		# commit f75904a38
+		stty -onlcr -ocrnl -F /dev/tty
+	fi
+
+	# The completion has been added, print the buffer as the suggestion
+	echo -nE - $'\0'$BUFFER$'\0'
+}
+
+zle -N autosuggest-capture-completion _zsh_autosuggest_capture_completion_widget
+
+_zsh_autosuggest_capture_setup() {
+	autoload -Uz is-at-least
+
+	# There is a bug in zpty module in older zsh versions 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.
+	if ! is-at-least 5.4; then
+		zshexit() {
+			# The zsh builtin `kill` fails sometimes in older versions
+			# https://unix.stackexchange.com/a/477647/156673
+			kill -KILL $$ 2>&- || command kill -KILL $$
+
+			# Block for long enough for the signal to come through
+			sleep 1
+		}
+	fi
+
+	# Try to avoid any suggestions that wouldn't match the prefix
+	zstyle ':completion:*' matcher-list ''
+	zstyle ':completion:*' path-completion false
+	zstyle ':completion:*' max-errors 0 not-numeric
+
+	bindkey '^I' autosuggest-capture-completion
+}
+
+_zsh_autosuggest_capture_completion_sync() {
+	_zsh_autosuggest_capture_setup
+
+	zle autosuggest-capture-completion
+}
+
+_zsh_autosuggest_capture_completion_async() {
+	_zsh_autosuggest_capture_setup
+
+	zmodload zsh/parameter 2>/dev/null || return # 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 1
+}
+
+_zsh_autosuggest_strategy_completion() {
+	typeset -g suggestion
+	local line REPLY
+
+	# Exit if we don't have completions
+	whence compdef >/dev/null || return
+
+	# Exit if we don't have zpty
+	zmodload zsh/zpty 2>/dev/null || return
+
+	# Zle will be inactive if we are in async mode
+	if zle; then
+		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_sync
+	else
+		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_async "\$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'
+
+		# Extract the suggestion from between the null bytes.  On older
+		# versions of zsh (older than 5.3), we sometimes get extra bytes after
+		# the second null byte, so trim those off the end.
+		# See http://www.zsh.org/mla/workers/2015/msg03290.html
+		suggestion="${${line#*$'\0'}%$'\0'*}"
+	} always {
+		# Destroy the pty
+		zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME
+	}
+}
+
+#--------------------------------------------------------------------#
+# 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}"
+
+	# 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
+# prefix and whose preceding history item also matches the most
+# recently executed command.
+#
+# 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
+		if [[ "${history[$((key - 1))]}" == "$prev_cmd" ]]; then
+			histkey="$key"
+			break
+		fi
+	done
+
+	# 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"
+
+		# Ensure the suggestion matches the prefix
+		[[ "$suggestion" != "$1"* ]] && unset suggestion
+
+		# Break once we've found a valid suggestion
+		[[ -n "$suggestion" ]] && break
+	done
+}
+
+#--------------------------------------------------------------------#
+# Async                                                              #
+#--------------------------------------------------------------------#
+
+zmodload zsh/system
+
+_zsh_autosuggest_async_request() {
+	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
+
+	# 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 and remove the handler
+		exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&-
+		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
+
+		# Zsh will make a new process group for the child process only if job
+		# control is enabled (MONITOR option)
+		if [[ -o MONITOR ]]; then
+			# Send the signal to the process group to kill any processes that may
+			# have been forked by the suggestion strategy
+			kill -TERM -$_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		else
+			# Kill just the child process since it wasn't placed in a new process
+			# group. If the suggestion strategy forked any child processes they may
+			# be orphaned and left behind.
+			kill -TERM $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		fi
+	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"
+	)
+
+	# There's a weird bug here where ^C stops working unless we force a fork
+	# See https://github.com/zsh-users/zsh-autosuggestions/issues/364
+	command true
+
+	# 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
+}
+
+# Called when new data is ready to be read from the pipe
+# First arg will be fd ready for reading
+# Second arg will be passed in case of error
+_zsh_autosuggest_async_response() {
+	emulate -L zsh
+
+	local suggestion
+
+	if [[ -z "$2" || "$2" == "hup" ]]; then
+		# Read everything from the fd and give it as a suggestion
+		IFS='' read -rd '' -u $1 suggestion
+		zle autosuggest-suggest -- "$suggestion"
+
+		# Close the fd
+		exec {1}<&-
+	fi
+
+	# Always remove the handler
+	zle -F "$1"
+}
+
+#--------------------------------------------------------------------#
+# Start                                                              #
+#--------------------------------------------------------------------#
+
+# Start the autosuggestion widgets
+_zsh_autosuggest_start() {
+	# By default we 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. However this has
+	# a decent performance hit, so users can set ZSH_AUTOSUGGEST_MANUAL_REBIND
+	# to disable the automatic re-binding.
+	if (( ${+ZSH_AUTOSUGGEST_MANUAL_REBIND} )); then
+		add-zsh-hook -d precmd _zsh_autosuggest_start
+	fi
+
+	_zsh_autosuggest_bind_widgets
+}
+
+# Start the autosuggestion widgets on the next precmd
+autoload -Uz add-zsh-hook
+add-zsh-hook precmd _zsh_autosuggest_start