diff --git a/.circleci/config.yml b/.circleci/config.yml deleted file mode 100644 index 8de098f..0000000 --- a/.circleci/config.yml +++ /dev/null @@ -1,16 +0,0 @@ -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 diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md new file mode 100644 index 0000000..7663df6 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug-report.md @@ -0,0 +1,36 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: bug +assignees: '' + +--- + +### Describe the bug + + +### To Reproduce +Steps to reproduce the behavior: + + + +```sh +% zsh -df +% source path/to/zsh-autosuggestions.zsh +% ... # what do you do to reproduce? +``` + +### Expected behavior + + +### Screenshots + + +### Desktop + - OS + distribution: + - Zsh version: + - Plugin version: + +### Additional context + diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..5874625 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: enhancement +assignees: '' + +--- + +### Is your feature request related to a problem? Please describe. + + +### Describe the solution you'd like + + +### Describe alternatives you've considered + + +### Additional context + diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml new file mode 100644 index 0000000..ec7bc75 --- /dev/null +++ b/.github/workflows/integration.yml @@ -0,0 +1,51 @@ +on: [push, pull_request] +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true +env: + IMAGE_CACHE_PATH: /tmp/.image-cache + IMAGE_CACHE_NAME: zsh-autosuggestions-test +jobs: + determine-versions: + runs-on: ubuntu-22.04 + outputs: + versions: ${{ steps.set-versions.outputs.versions }} + steps: + - uses: actions/checkout@v3 + - id: set-versions + run: | + echo "versions=$( + grep "^[^#]" ZSH_VERSIONS \ + | sed -E 's/(^|$)/"/g' \ + | paste -sd ',' - \ + | sed -e 's/^/[/' -e 's/$/]/' + )" >> $GITHUB_OUTPUT + test: + needs: determine-versions + runs-on: ubuntu-22.04 + strategy: + matrix: + version: ${{ fromJson(needs.determine-versions.outputs.versions) }} + steps: + - uses: actions/checkout@v3 + - name: Docker image cache + id: image-cache + uses: actions/cache@v3 + with: + path: ${{ env.IMAGE_CACHE_PATH }} + key: image-cache-${{ matrix.version }}-${{ hashFiles('Dockerfile', 'install_test_zsh.sh', 'Gemfile.lock') }} + - name: Load cached docker image if available + if: ${{ steps.image-cache.outputs.cache-hit }} + run: gunzip < $IMAGE_CACHE_PATH/$IMAGE_CACHE_NAME.tar.gz | docker load + - name: Build the docker image if necessary + if: ${{ !steps.image-cache.outputs.cache-hit }} + run: | + docker build --build-arg TEST_ZSH_VERSION=${{ matrix.version }} -t $IMAGE_CACHE_NAME . + mkdir -p $IMAGE_CACHE_PATH + docker save $IMAGE_CACHE_NAME | gzip > $IMAGE_CACHE_PATH/$IMAGE_CACHE_NAME.tar.gz + - name: Run the tests + run: | + docker run --rm \ + -v $PWD:/zsh-autosuggestions \ + $IMAGE_CACHE_NAME \ + make test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d8decde --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +# zsh word code files +*.zwc diff --git a/CHANGELOG.md b/CHANGELOG.md index 387071b..30c7735 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,50 @@ # Changelog +## v0.7.1 +- Clear POSTDISPLAY instead of unsetting (#634) +- Always reset async file descriptor after consuming it (#630) +- Always use builtin `exec` (#628) +- Add `history-beginning-search-*-end` widgets to clear widget list (#619) +- Switch CI from Circle CI to GitHub Actions + +## v0.7.0 +- Enable asynchronous mode by default (#498) +- No longer wrap user widgets starting with `autosuggest-` prefix (#496) +- Fix a bug wrapping widgets that modify the buffer (#541) + + +## v0.6.4 +- Fix `vi-forward-char` triggering a bell when using it to accept a suggestion (#488) +- New configuration option to skip completion suggestions when buffer matches a pattern (#487) +- New configuration option to ignore history entries matching a pattern (#456) + +## v0.6.3 +- Fixed bug moving cursor to end of buffer after accepting suggestion (#453) + +## v0.6.2 +- Fixed bug deleting the last character in the buffer in vi mode (#450) +- Degrade gracefully when user doesn't have `zsh/system` module installed (#447) + +## v0.6.1 +- Fixed bug occurring when `_complete` had been aliased (#443) + +## 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 @@ -36,7 +81,7 @@ - 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) +- 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) diff --git a/Dockerfile b/Dockerfile index 0d51407..f5dd3c4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,8 @@ FROM ruby:2.5.3-alpine +ARG TEST_ZSH_VERSION +RUN : "${TEST_ZSH_VERSION:?}" + RUN apk add --no-cache autoconf RUN apk add --no-cache libtool RUN apk add --no-cache libcap-dev @@ -11,10 +14,8 @@ 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 +ADD install_test_zsh.sh ./ RUN ./install_test_zsh.sh -ADD Gemfile /zsh-autosuggestions/Gemfile -ADD Gemfile.lock /zsh-autosuggestions/Gemfile.lock +ADD Gemfile Gemfile.lock ./ RUN bundle install diff --git a/INSTALL.md b/INSTALL.md index d439ef9..7f0a395 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -1,6 +1,71 @@ -## Installation +# Installation -### Manual (Git Clone) +* [Packages](#packages) +* [Antigen](#antigen) +* [Oh My Zsh](#oh-my-zsh) +* [HomeBrew](#homebrew) +* [Manual](#manual-git-clone) + +## Packages + +| System | Package | +| ------------- | ------------- | +| Alpine Linux | [zsh-autosuggestions](https://pkgs.alpinelinux.org/packages?name=zsh-autosuggestions) | +| Debian / Ubuntu | [zsh-autosuggestions OBS repository](https://software.opensuse.org/download.html?project=shells%3Azsh-users%3Azsh-autosuggestions&package=zsh-autosuggestions) | +| Fedora / CentOS / RHEL / Scientific Linux | [zsh-autosuggestions OBS repository](https://software.opensuse.org/download.html?project=shells%3Azsh-users%3Azsh-autosuggestions&package=zsh-autosuggestions) | +| OpenSUSE / SLE | [zsh-autosuggestions OBS repository](https://software.opensuse.org/download.html?project=shells%3Azsh-users%3Azsh-autosuggestions&package=zsh-autosuggestions) | +| Arch Linux / Manjaro / Antergos / Hyperbola | [zsh-autosuggestions](https://www.archlinux.org/packages/zsh-autosuggestions), [zsh-autosuggestions-git](https://aur.archlinux.org/packages/zsh-autosuggestions-git) | +| NixOS | [zsh-autosuggestions](https://github.com/NixOS/nixpkgs/blob/master/pkgs/by-name/zs/zsh-autosuggestions/package.nix) | +| Void Linux | [zsh-autosuggestions](https://github.com/void-linux/void-packages/blob/master/srcpkgs/zsh-autosuggestions/template) | +| Mac OS | [homebrew](https://formulae.brew.sh/formula/zsh-autosuggestions) | +| NetBSD | [pkgsrc](http://ftp.netbsd.org/pub/pkgsrc/current/pkgsrc/shells/zsh-autosuggestions/README.html) | +| FreeBSD | [pkg](https://cgit.freebsd.org/ports/tree/shells/zsh-autosuggestions) | + +## 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=( + # other plugins... + zsh-autosuggestions + ) + ``` + +3. Start a new terminal session. + +## Homebrew + +1. Install command: + ```sh + brew install zsh-autosuggestions + ``` + +2. To activate the autosuggestions, add the following at the end of your .zshrc: + + ```sh + source $(brew --prefix)/share/zsh-autosuggestions/zsh-autosuggestions.zsh + ``` + +3. Start a new terminal session. + +## Manual (Git Clone) 1. Clone this repository somewhere on your machine. This guide will assume `~/.zsh/zsh-autosuggestions`. @@ -15,63 +80,3 @@ ``` 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. - diff --git a/LICENSE b/LICENSE index bcbc8b9..7ea78cc 100644 --- a/LICENSE +++ b/LICENSE @@ -1,5 +1,5 @@ Copyright (c) 2013 Thiago de Arruda -Copyright (c) 2016-2018 Eric Freese +Copyright (c) 2016-2021 Eric Freese Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation diff --git a/Makefile b/Makefile index b89ff04..6f5431e 100644 --- a/Makefile +++ b/Makefile @@ -1,10 +1,8 @@ -SRC_DIR := ./src +SRC_DIR := ./src SRC_FILES := \ - $(SRC_DIR)/setup.zsh \ $(SRC_DIR)/config.zsh \ $(SRC_DIR)/util.zsh \ - $(SRC_DIR)/features.zsh \ $(SRC_DIR)/bind.zsh \ $(SRC_DIR)/highlight.zsh \ $(SRC_DIR)/widgets.zsh \ diff --git a/README.md b/README.md index 7e3e674..a8c1b6c 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,11 @@ _[Fish](http://fishshell.com/)-like fast/unobtrusive autosuggestions for zsh._ -It suggests commands as you type, based on command history. +It suggests commands as you type based on history and completions. 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) +[![Chat on Gitter](https://img.shields.io/gitter/room/zsh-users/zsh-autosuggestions.svg)](https://gitter.im/zsh-users/zsh-autosuggestions) @@ -34,16 +34,29 @@ You may want to override the default global config variables. Default values of ### Suggestion Highlight Style -Set `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE` to configure the style that the suggestion is shown with. The default is `fg=8`. +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](https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg). 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). + +**Note:** Some iTerm2 users have reported [not being able to see the suggestions](https://github.com/zsh-users/zsh-autosuggestions/issues/416#issuecomment-486516333). If this affects you, the problem is likely caused by incorrect color settings. In order to correct this, go into iTerm2's setting, navigate to profile > colors and make sure that the colors for Basic Colors > Background and ANSI Colors > Bright Black are **different**. ### 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 two built-in strategies to choose from: +`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. +- `completion`: Chooses a suggestion based on what tab-completion would suggest. (requires `zpty` module, which is included with zsh since 4.0.1) - `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`. +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 @@ -63,11 +76,29 @@ Widgets that modify the buffer and are not found in any of these arrays will fet ### 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 too long strings. +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 +### Asynchronous Mode -As of `v0.4.0`, suggestions can be fetched asynchronously using the `zsh/zpty` module. To enable this behavior, set the `ZSH_AUTOSUGGEST_USE_ASYNC` variable (it can be set to anything). +Suggestions are fetched asynchronously by default in zsh versions 5.0.8 and greater. To disable asynchronous suggestions and fetch them synchronously instead, `unset ZSH_AUTOSUGGEST_USE_ASYNC` after sourcing the plugin. + +Alternatively, if you are using a version of zsh older than 5.0.8 and want to enable asynchronous mode, set the `ZSH_AUTOSUGGEST_USE_ASYNC` variable after sourcing the plugin (it can be set to anything). Note that there is [a bug](https://github.com/zsh-users/zsh-autosuggestions/issues/364#issuecomment-481423232) in versions of zsh older than 5.0.8 where ctrl + c will fail to reset the prompt immediately after fetching a suggestion asynchronously. + +### 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`. + +### Ignoring history suggestions that match a pattern + +Set `ZSH_AUTOSUGGEST_HISTORY_IGNORE` to a [glob pattern](http://zsh.sourceforge.net/Doc/Release/Expansion.html#Glob-Operators) to prevent offering suggestions for history entries that match the pattern. For example, set it to `"cd *"` to never suggest any `cd` commands from history. Or set to `"?(#c50,)"` to never suggest anything 50 characters or longer. + +**Note:** This only affects the `history` and `match_prev_cmd` suggestion strategies. + +### Skipping completion suggestions for certain cases + +Set `ZSH_AUTOSUGGEST_COMPLETION_IGNORE` to a [glob pattern](http://zsh.sourceforge.net/Doc/Release/Expansion.html#Glob-Operators) to prevent offering completion suggestions when the buffer matches that pattern. For example, set it to `"git *"` to disable completion suggestions for git subcommands. + +**Note:** This only affects the `completion` suggestion strategy. ### Key Bindings @@ -91,8 +122,7 @@ 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. - +If you have a problem, please search through [the list of issues on GitHub](https://github.com/zsh-users/zsh-autosuggestions/issues?q=) to see if someone else has already reported it. ### Reporting an Issue @@ -139,18 +169,16 @@ Tests are written in ruby using the [`rspec`](http://rspec.info/) framework. The 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: +It's possible to run the tests for any supported version of zsh in a Docker image by building an image from the provided Dockerfile. To build the docker image for a specific version of zsh (where `` below is substituted with the contents of a line from the [`ZSH_VERSIONS`](ZSH_VERSIONS) file), run: ```sh -docker pull ericfreese/zsh-autosuggestions-test +docker build --build-arg TEST_ZSH_VERSION= -t zsh-autosuggestions-test . ``` -To run the tests for a specific version of zsh (where `` below is substituted with the contents of a line from the [`ZSH_VERSIONS`](ZSH_VERSIONS) file): +After building the image, run the tests via: ```sh -docker run -it -e TEST_ZSH_BIN=zsh- -v $PWD:/zsh-autosuggestions zsh-autosuggestions-test make test +docker run -it -v $PWD:/zsh-autosuggestions zsh-autosuggestions-test make test ``` diff --git a/VERSION b/VERSION index b043aa6..63f2359 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v0.5.0 +v0.7.1 diff --git a/ZSH_VERSIONS b/ZSH_VERSIONS index e08b87c..23006db 100644 --- a/ZSH_VERSIONS +++ b/ZSH_VERSIONS @@ -1,9 +1,5 @@ # 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 @@ -13,3 +9,6 @@ 5.4.2 5.5.1 5.6.2 +5.7.1 +5.8.1 +5.9 diff --git a/install_test_zsh.sh b/install_test_zsh.sh index 1578183..6cac9f5 100755 --- a/install_test_zsh.sh +++ b/install_test_zsh.sh @@ -2,25 +2,22 @@ set -ex -for v in $(grep "^[^#]" ZSH_VERSIONS); do - mkdir zsh-$v - cd zsh-$v +mkdir zsh-build +cd zsh-build - curl -L https://api.github.com/repos/zsh-users/zsh/tarball/zsh-$v | tar xz --strip=1 +curl -L https://api.github.com/repos/zsh-users/zsh/tarball/zsh-$TEST_ZSH_VERSION | tar xz --strip=1 - ./Util/preconfig - ./configure --enable-pcre \ - --enable-cap \ - --enable-multibyte \ - --with-term-lib='ncursesw tinfo' \ - --without-tcsetpgrp \ - --program-suffix="-$v" +./Util/preconfig +./configure --enable-pcre \ + --enable-cap \ + --enable-multibyte \ + --with-term-lib='ncursesw tinfo' \ + --with-tcsetpgrp - make install.bin - make install.modules - make install.fns +make install.bin +make install.modules +make install.fns - cd .. +cd .. - rm -rf zsh-$v -done +rm -rf zsh-build diff --git a/spec/async_spec.rb b/spec/async_spec.rb index 152adde..0af7232 100644 --- a/spec/async_spec.rb +++ b/spec/async_spec.rb @@ -1,8 +1,4 @@ context 'with asynchronous suggestions enabled' do - before do - skip 'Async mode not supported below v5.0.8' if session.zsh_version < Gem::Version.new('5.0.8') - end - let(:options) { ["ZSH_AUTOSUGGEST_USE_ASYNC="] } describe '`up-line-or-beginning-search`' do @@ -31,52 +27,42 @@ context 'with asynchronous suggestions enabled' do end end - it 'should not add extra carriage returns before newlines' do - session. - send_string('echo "'). - send_keys('escape'). - send_keys('enter'). - send_string('"'). - send_keys('enter') + 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 - session.clear_screen - - session.send_string('echo') - wait_for { session.content }.to eq("echo \"\n\"") + 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 - it 'should treat carriage returns and newlines as separate characters' do - session. - send_string('echo "'). - send_keys('C-v'). - send_keys('enter'). - send_string('foo"'). - send_keys('enter') + 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 - session. - send_string('echo "'). - send_keys('control'). - send_keys('enter'). - send_string('bar"'). - send_keys('enter') + 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') - session.clear_screen - - session. - send_string('echo "'). - send_keys('C-v'). - send_keys('enter') - - wait_for { session.content }.to eq('echo "^Mfoo"') - end - - describe 'exiting a subshell' do - it 'should not cause error messages to be printed' do - session.run_command('$(exit)') - - sleep 1 - - expect(session.content).to eq('$(exit)') + wait_for { session.content }.to eq("e\necho") end end end diff --git a/spec/integrations/auto_cd_spec.rb b/spec/integrations/auto_cd_spec.rb new file mode 100644 index 0000000..94bd24b --- /dev/null +++ b/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 diff --git a/spec/integrations/bracketed_paste_magic_spec.rb b/spec/integrations/bracketed_paste_magic_spec.rb index 64092ad..41ff267 100644 --- a/spec/integrations/bracketed_paste_magic_spec.rb +++ b/spec/integrations/bracketed_paste_magic_spec.rb @@ -24,4 +24,20 @@ describe 'pasting using bracketed-paste-magic' do 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 diff --git a/spec/integrations/client_zpty_spec.rb b/spec/integrations/client_zpty_spec.rb index 8f1550e..b8abb37 100644 --- a/spec/integrations/client_zpty_spec.rb +++ b/spec/integrations/client_zpty_spec.rb @@ -1,10 +1,14 @@ describe 'a running zpty command' do let(:before_sourcing) { -> { session.run_command('zmodload zsh/zpty && zpty -b kitty cat') } } - it 'is not affected by running zsh-autosuggestions' do - sleep 1 # Give a little time for precmd hooks to run - session.run_command('zpty -t kitty; echo $?') + context 'when using `completion` strategy' do + let(:options) { ["ZSH_AUTOSUGGEST_STRATEGY=completion"] } - wait_for { session.content }.to end_with("\n0") + 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 diff --git a/spec/integrations/glob_subst_spec.rb b/spec/integrations/glob_subst_spec.rb new file mode 100644 index 0000000..c3dd671 --- /dev/null +++ b/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 diff --git a/spec/integrations/vi_mode_spec.rb b/spec/integrations/vi_mode_spec.rb index cf471b5..0a295c2 100644 --- a/spec/integrations/vi_mode_spec.rb +++ b/spec/integrations/vi_mode_spec.rb @@ -63,5 +63,18 @@ describe 'when using vi mode' do end end end -end + describe '`vi-delete`' do + it 'should be able to remove the last character in the buffer' do + skip 'deleting last char did not work below zsh version 5.0.8' if session.zsh_version < Gem::Version.new('5.0.8') + + session. + send_string('echo foo'). + send_keys('escape'). + send_keys('d'). + send_keys('l') + + wait_for { session.content }.to eq('echo fo') + end + end +end diff --git a/spec/line_init_spec.rb b/spec/line_init_spec.rb new file mode 100644 index 0000000..826277f --- /dev/null +++ b/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 diff --git a/spec/multi_line_spec.rb b/spec/multi_line_spec.rb index 4ff2ae1..364780a 100644 --- a/spec/multi_line_spec.rb +++ b/spec/multi_line_spec.rb @@ -1,11 +1,6 @@ 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 + with_history("echo \"\n\"") do session.send_keys('e') wait_for { session.content }.to eq("echo \"\n\"") end diff --git a/spec/options/async_zpty_name_spec.rb b/spec/options/async_zpty_name_spec.rb deleted file mode 100644 index 407ee70..0000000 --- a/spec/options/async_zpty_name_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -context 'when async suggestions are enabled' do - let(:options) { ["ZSH_AUTOSUGGEST_USE_ASYNC="] } - - describe 'the zpty for async suggestions' do - it 'is created with the default name' do - session.run_command('zpty -t zsh_autosuggest_pty &>/dev/null; echo $?') - wait_for { session.content }.to end_with("\n0") - end - - context 'when ZSH_AUTOSUGGEST_ASYNC_PTY_NAME is set' do - let(:options) { super() + ['ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=foo_pty'] } - - it 'is created with the specified name' do - session.run_command('zpty -t foo_pty &>/dev/null; echo $?') - wait_for { session.content }.to end_with("\n0") - end - end - end -end diff --git a/spec/options/use_async_spec.rb b/spec/options/use_async_spec.rb deleted file mode 100644 index 420dcc3..0000000 --- a/spec/options/use_async_spec.rb +++ /dev/null @@ -1,7 +0,0 @@ -describe 'suggestion fetching' do - it 'is performed synchronously' - - context 'when ZSH_AUTOSUGGEST_USE_ASYNC is set' do - it 'is performed asynchronously' - end -end diff --git a/spec/options/widget_lists_spec.rb b/spec/options/widget_lists_spec.rb index c207c0c..421b84e 100644 --- a/spec/options/widget_lists_spec.rb +++ b/spec/options/widget_lists_spec.rb @@ -5,12 +5,13 @@ describe 'a zle widget' do context 'when added to ZSH_AUTOSUGGEST_ACCEPT_WIDGETS' do let(:options) { ["ZSH_AUTOSUGGEST_ACCEPT_WIDGETS+=(#{widget})"] } - it 'accepts the suggestion when invoked' do + it 'accepts the suggestion and moves the cursor to the end of the buffer 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') + wait_for { session.cursor }.to eq([10, 0]) end end end @@ -94,4 +95,27 @@ describe 'a modification to the widget lists' do 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 diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index abea917..dc1abb0 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,6 +1,7 @@ require 'pry' require 'rspec/wait' require 'terminal_session' +require 'tempfile' RSpec.shared_context 'terminal session' do let(:term_opts) { {} } @@ -11,8 +12,7 @@ RSpec.shared_context 'terminal session' do around do |example| before_sourcing.call - session.run_command(options.join('; ')) - session.run_command('source zsh-autosuggestions.zsh') + session.run_command(['source zsh-autosuggestions.zsh', *options].join('; ')) after_sourcing.call session.clear_screen @@ -22,18 +22,20 @@ RSpec.shared_context 'terminal session' do end def with_history(*commands, &block) - session.run_command('fc -p') + Tempfile.create do |f| + f.write(commands.map{|c| c.gsub("\n", "\\\n")}.join("\n")) + f.flush - commands.each do |c| - c.respond_to?(:call) ? c.call : session.run_command(c) + session.run_command('fc -p') + session.run_command("fc -R #{f.path}") + + session.clear_screen + + yield block + + session.send_keys('C-c') + session.run_command('fc -P') end - - session.clear_screen - - yield block - - session.send_keys('C-c') - session.run_command('fc -P') end end diff --git a/spec/strategies/completion_spec.rb b/spec/strategies/completion_spec.rb new file mode 100644 index 0000000..92794d6 --- /dev/null +++ b/spec/strategies/completion_spec.rb @@ -0,0 +1,72 @@ +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('_num() { compadd two; compadd three }'). + run_command('compdef _foo baz'). + run_command('compdef _num one') + 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 `_complete` is aliased' do + let(:before_sourcing) do + -> do + session. + run_command('autoload compinit && compinit'). + run_command('_foo() { compadd bar; compadd bat }'). + run_command('compdef _foo baz'). + run_command('alias _complete=_complete') + end + end + + it 'suggests the first completion result' do + session.send_string('baz ') + wait_for { session.content }.to eq('baz bar') + end + end + + context 'when ZSH_AUTOSUGGEST_COMPLETION_IGNORE is set to a pattern' do + let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=completion', 'ZSH_AUTOSUGGEST_COMPLETION_IGNORE="one *"'] } + + it 'makes suggestions when the buffer does not match the pattern' do + session.send_string('baz ') + wait_for { session.content }.to eq('baz bar') + end + + it 'does not make suggestions when the buffer matches the pattern' do + session.send_string('one t') + sleep 1 + expect(session.content).to eq('one t') + end + 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 + diff --git a/spec/strategies/default_spec.rb b/spec/strategies/default_spec.rb deleted file mode 100644 index 89321f3..0000000 --- a/spec/strategies/default_spec.rb +++ /dev/null @@ -1,12 +0,0 @@ -require 'strategies/special_characters_helper' - -describe 'the default 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 diff --git a/spec/strategies/history_spec.rb b/spec/strategies/history_spec.rb new file mode 100644 index 0000000..eee8efd --- /dev/null +++ b/spec/strategies/history_spec.rb @@ -0,0 +1,23 @@ +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 + + context 'when ZSH_AUTOSUGGEST_HISTORY_IGNORE is set to a pattern' do + let(:options) { ['ZSH_AUTOSUGGEST_HISTORY_IGNORE="* bar"'] } + + it 'does not make suggestions that match the pattern' do + with_history('ls foo', 'ls bar', 'echo baz') do + session.send_string('ls') + wait_for { session.content }.to eq('ls foo') + end + end + end + + include_examples 'special characters' +end diff --git a/spec/strategies/match_prev_cmd_spec.rb b/spec/strategies/match_prev_cmd_spec.rb index f1596ba..c435f16 100644 --- a/spec/strategies/match_prev_cmd_spec.rb +++ b/spec/strategies/match_prev_cmd_spec.rb @@ -1,21 +1,34 @@ require 'strategies/special_characters_helper' -describe 'the match_prev_cmd strategy' do +describe 'the `match_prev_cmd` strategy' do let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=match_prev_cmd'] } + let(:history) { [ + 'echo what', + 'ls foo', + 'echo what', + 'ls bar', + 'ls baz', + 'echo what' + ] } + 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 + with_history(*history) do session.send_string('ls') wait_for { session.content }.to eq('ls bar') end end + context 'when ZSH_AUTOSUGGEST_HISTORY_IGNORE is set to a pattern' do + let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=match_prev_cmd', 'ZSH_AUTOSUGGEST_HISTORY_IGNORE="* bar"'] } + + it 'does not make suggestions that match the pattern' do + with_history(*history) do + session.send_string('ls') + wait_for { session.content }.to eq('ls foo') + end + end + end + include_examples 'special characters' end diff --git a/spec/strategies/special_characters_helper.rb b/spec/strategies/special_characters_helper.rb index 8771861..eb1f0cd 100644 --- a/spec/strategies/special_characters_helper.rb +++ b/spec/strategies/special_characters_helper.rb @@ -1,58 +1,71 @@ shared_examples 'special characters' do - describe 'a special character in the buffer' do - it 'should be treated like any other character' do + describe 'a special character in the buffer should be treated like any other character' do + it 'asterisk' do with_history('echo "hello*"', 'echo "hello."') do session.send_string('echo "hello*') wait_for { session.content }.to eq('echo "hello*"') end + end + it 'question mark' do with_history('echo "hello?"', 'echo "hello."') do session.send_string('echo "hello?') wait_for { session.content }.to eq('echo "hello?"') end + end + it 'backslash' do with_history('echo "hello\nworld"') do session.send_string('echo "hello\\') wait_for { session.content }.to eq('echo "hello\nworld"') end + end + it 'double backslash' do with_history('echo "\\\\"') do session.send_string('echo "\\\\') wait_for { session.content }.to eq('echo "\\\\"') end + end + it 'tilde' do with_history('echo ~/foo') do session.send_string('echo ~') wait_for { session.content }.to eq('echo ~/foo') end + end + it 'parentheses' do with_history('echo "$(ls foo)"') do session.send_string('echo "$(') wait_for { session.content }.to eq('echo "$(ls foo)"') end + end + it 'square bracket' do 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 + end + it 'octothorpe' do with_history('echo "#yolo"') do session.send_string('echo "#') wait_for { session.content }.to eq('echo "#yolo"') end + end - with_history('echo "#foo"', 'echo $#abc') do - session.send_string('echo "#') - wait_for { session.content }.to eq('echo "#foo"') - end - + it 'caret' do with_history('echo "^A"', 'echo "^B"') do session.send_string('echo "^A') wait_for { session.content }.to eq('echo "^A"') end + end + it 'dash' do with_history('-foo() {}') do session.send_string('-') wait_for { session.content }.to eq('-foo() {}') diff --git a/src/async.zsh b/src/async.zsh index dd54c24..e179734 100644 --- a/src/async.zsh +++ b/src/async.zsh @@ -3,107 +3,75 @@ # Async # #--------------------------------------------------------------------# -# Zpty process is spawned running this function -_zsh_autosuggest_async_server() { - emulate -R zsh - - # There is a bug in zpty module (fixed in zsh/master) by which a - # zpty that exits will kill all zpty processes that were forked - # before it. Here we set up a zsh exit hook to SIGKILL the zpty - # process immediately, before it has a chance to kill any other - # zpty processes. - zshexit() { - kill -KILL $$ - sleep 1 # Block for long enough for the signal to come through - } - - # Don't add any extra carriage returns - stty -onlcr - - # Don't translate carriage returns to newlines - stty -icrnl - - # Silence any error messages - exec 2>/dev/null - - local last_pid - - while IFS='' read -r -d $'\0' query; do - # Kill last bg process - kill -KILL $last_pid &>/dev/null - - # Run suggestion search in the background - ( - local suggestion - _zsh_autosuggest_fetch_suggestion "$query" - echo -n -E "$suggestion"$'\0' - ) & - - last_pid=$! - done -} - _zsh_autosuggest_async_request() { - # Write the query to the zpty process to fetch a suggestion - zpty -w -n $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME "${1}"$'\0' + zmodload zsh/system 2>/dev/null # For `$sysparams` + + 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 + builtin exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&- + zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD + + # We won't know the pid unless the user has zsh/system module installed + if [[ -n "$_ZSH_AUTOSUGGEST_CHILD_PID" ]]; then + # 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 + fi + + # Fork a process to fetch a suggestion and open a pipe to read from it + builtin 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 + autoload -Uz is-at-least + is-at-least 5.8 || 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 pty +# 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() { - setopt LOCAL_OPTIONS EXTENDED_GLOB + emulate -L zsh local suggestion - zpty -rt $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME suggestion '*'$'\0' 2>/dev/null - zle autosuggest-suggest -- "${suggestion%%$'\0'##}" -} + 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" -_zsh_autosuggest_async_pty_create() { - # With newer versions of zsh, REPLY stores the fd to read from - typeset -h REPLY - - # If we won't get a fd back from zpty, try to guess it - if (( ! $_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD )); then - integer -l zptyfd - exec {zptyfd}>&1 # Open a new file descriptor (above 10). - exec {zptyfd}>&- # Close it so it's free to be used by zpty. + # Close the fd + builtin exec {1}<&- fi - # Fork a zpty process running the server function - zpty -b $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME _zsh_autosuggest_async_server - - # Store the fd so we can remove the handler later - if (( REPLY )); then - _ZSH_AUTOSUGGEST_PTY_FD=$REPLY - else - _ZSH_AUTOSUGGEST_PTY_FD=$zptyfd - fi - - # Set up input handler from the zpty - zle -F $_ZSH_AUTOSUGGEST_PTY_FD _zsh_autosuggest_async_response -} - -_zsh_autosuggest_async_pty_destroy() { - # Remove the input handler - zle -F $_ZSH_AUTOSUGGEST_PTY_FD &>/dev/null - - # Destroy the zpty - zpty -d $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME &>/dev/null -} - -_zsh_autosuggest_async_pty_recreate() { - _zsh_autosuggest_async_pty_destroy - _zsh_autosuggest_async_pty_create -} - -_zsh_autosuggest_async_start() { - typeset -g _ZSH_AUTOSUGGEST_PTY_FD - - _zsh_autosuggest_feature_detect_zpty_returns_fd - _zsh_autosuggest_async_pty_recreate - - # We recreate the pty to get a fresh list of history events - add-zsh-hook precmd _zsh_autosuggest_async_pty_recreate + # Always remove the handler + zle -F "$1" + _ZSH_AUTOSUGGEST_ASYNC_FD= } diff --git a/src/bind.zsh b/src/bind.zsh index bb41ef8..1dde137 100644 --- a/src/bind.zsh +++ b/src/bind.zsh @@ -4,21 +4,8 @@ #--------------------------------------------------------------------# _zsh_autosuggest_incr_bind_count() { - if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then - ((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]++)) - else - _ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=1 - fi - - typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1] -} - -_zsh_autosuggest_get_bind_count() { - if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then - typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1] - else - typeset -gi bind_count=0 - fi + 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 @@ -34,30 +21,30 @@ _zsh_autosuggest_bind_widget() { # Save a reference to the original widget case $widgets[$widget] in # Already bound - user:_zsh_autosuggest_(bound|orig)_*);; + 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]#*:} + 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 + 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]}" + eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}" ;; esac - _zsh_autosuggest_get_bind_count $widget - # 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 @@ -82,8 +69,7 @@ _zsh_autosuggest_bind_widgets() { ignore_widgets=( .\* _\* - zle-\* - autosuggest-\* + ${_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS/#/autosuggest-} $ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\* $ZSH_AUTOSUGGEST_IGNORE_WIDGETS ) diff --git a/src/config.zsh b/src/config.zsh index 9ac1484..32d32b2 100644 --- a/src/config.zsh +++ b/src/config.zsh @@ -6,68 +6,90 @@ # Color to use when highlighting suggestion # Uses format of `region_highlight` # More info: http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Zle-Widgets -: ${ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'} +(( ! ${+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=autosuggest-orig-} +(( ! ${+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} )) && ZSH_AUTOSUGGEST_STRATEGY=(history) +(( ! ${+ZSH_AUTOSUGGEST_STRATEGY} )) && { + typeset -ga ZSH_AUTOSUGGEST_STRATEGY + ZSH_AUTOSUGGEST_STRATEGY=(history) +} # Widgets that clear the suggestion -(( ! ${+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 -) +(( ! ${+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-beginning-search-forward-end + history-beginning-search-backward-end + 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} )) && ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=( - forward-char - end-of-line - vi-forward-char - vi-end-of-line - vi-add-eol -) +(( ! ${+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} )) && ZSH_AUTOSUGGEST_EXECUTE_WIDGETS=( -) +(( ! ${+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} )) && 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 -) +(( ! ${+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} )) && ZSH_AUTOSUGGEST_IGNORE_WIDGETS=( - orig-\* - beep - run-help - set-local-history - which-command - yank - yank-pop -) +(( ! ${+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-\* + ) +} -# Max size of buffer to trigger autosuggestion. Leave null for no upper bound. -: ${ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=} - -# Pty name for calculating autosuggestions asynchronously -: ${ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=zsh_autosuggest_pty} +# 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 diff --git a/src/features.zsh b/src/features.zsh deleted file mode 100644 index 7a5248f..0000000 --- a/src/features.zsh +++ /dev/null @@ -1,19 +0,0 @@ - -#--------------------------------------------------------------------# -# Feature Detection # -#--------------------------------------------------------------------# - -_zsh_autosuggest_feature_detect_zpty_returns_fd() { - typeset -g _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD - typeset -h REPLY - - zpty zsh_autosuggest_feature_detect '{ zshexit() { kill -KILL $$; sleep 1 } }' - - if (( REPLY )); then - _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=1 - else - _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=0 - fi - - zpty -d zsh_autosuggest_feature_detect -} diff --git a/src/fetch.zsh b/src/fetch.zsh index f94e66d..fef2715 100644 --- a/src/fetch.zsh +++ b/src/fetch.zsh @@ -9,6 +9,7 @@ _zsh_autosuggest_fetch_suggestion() { typeset -g suggestion local -a strategies + local strategy # Ensure we are working with an array strategies=(${=ZSH_AUTOSUGGEST_STRATEGY}) @@ -17,7 +18,10 @@ _zsh_autosuggest_fetch_suggestion() { # Try to get a suggestion from this strategy _zsh_autosuggest_strategy_$strategy "$1" - # Break once we've found a suggestion + # Ensure the suggestion matches the prefix + [[ "$suggestion" != "$1"* ]] && unset suggestion + + # Break once we've found a valid suggestion [[ -n "$suggestion" ]] && break done } diff --git a/src/setup.zsh b/src/setup.zsh deleted file mode 100644 index c74489f..0000000 --- a/src/setup.zsh +++ /dev/null @@ -1,10 +0,0 @@ - -#--------------------------------------------------------------------# -# Setup # -#--------------------------------------------------------------------# - -# Precmd hooks for initializing the library and starting pty's -autoload -Uz add-zsh-hook - -# Asynchronous suggestions are generated in a pty -zmodload zsh/zpty diff --git a/src/start.zsh b/src/start.zsh index 6f48ab6..5d4ee52 100644 --- a/src/start.zsh +++ b/src/start.zsh @@ -5,20 +5,29 @@ # Start the autosuggestion widgets _zsh_autosuggest_start() { - add-zsh-hook -d precmd _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 - - # Re-bind widgets on every precmd to ensure we wrap other wrappers. - # Specifically, highlighting breaks if our widgets are wrapped by - # zsh-syntax-highlighting widgets. This also allows modifications - # to the widget list variables to take effect on the next precmd. - add-zsh-hook precmd _zsh_autosuggest_bind_widgets - - if [[ -n "${ZSH_AUTOSUGGEST_USE_ASYNC+x}" ]]; then - _zsh_autosuggest_async_start - fi } +# Mark for auto-loading the functions that we use +autoload -Uz add-zsh-hook is-at-least + +# Automatically enable asynchronous mode in newer versions of zsh. Disable for +# older versions because there is a bug when using async mode where ^C does not +# work immediately after fetching a suggestion. +# See https://github.com/zsh-users/zsh-autosuggestions/issues/364 +if is-at-least 5.0.8; then + typeset -g ZSH_AUTOSUGGEST_USE_ASYNC= +fi + # Start the autosuggestion widgets on the next precmd add-zsh-hook precmd _zsh_autosuggest_start diff --git a/src/strategies/completion.zsh b/src/strategies/completion.zsh new file mode 100644 index 0000000..e2d114c --- /dev/null +++ b/src/strategies/completion.zsh @@ -0,0 +1,137 @@ + +#--------------------------------------------------------------------# +# 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() { + # 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] + function _complete() { + unset 'compstate[vared]' + _original_complete "$@" + } + + # Open zle with buffer set so we can capture completions for it + vared 1 +} + +_zsh_autosuggest_strategy_completion() { + # Reset options to defaults and enable LOCAL_OPTIONS + emulate -L zsh + + # Enable extended glob for completion ignore pattern + setopt EXTENDED_GLOB + + 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 + + # Exit if our search string matches the ignore pattern + [[ -n "$ZSH_AUTOSUGGEST_COMPLETION_IGNORE" ]] && [[ "$1" == $~ZSH_AUTOSUGGEST_COMPLETION_IGNORE ]] && 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="${${(@0)line}[2]}" + } always { + # Destroy the pty + zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME + } +} diff --git a/src/strategies/default.zsh b/src/strategies/history.zsh similarity index 65% rename from src/strategies/default.zsh rename to src/strategies/history.zsh index a2755a5..0672a13 100644 --- a/src/strategies/default.zsh +++ b/src/strategies/history.zsh @@ -10,7 +10,7 @@ _zsh_autosuggest_strategy_history() { # Reset options to defaults and enable LOCAL_OPTIONS emulate -L zsh - # Enable globbing flags so that we can use (#m) + # Enable globbing flags so that we can use (#m) and (x~y) glob operator setopt EXTENDED_GLOB # Escape backslashes and all of the glob operators so we can use @@ -19,7 +19,14 @@ _zsh_autosuggest_strategy_history() { # 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 + # Get the history items that match the prefix, excluding those that match + # the ignore pattern + local pattern="$prefix*" + if [[ -n $ZSH_AUTOSUGGEST_HISTORY_IGNORE ]]; then + pattern="($pattern)~($ZSH_AUTOSUGGEST_HISTORY_IGNORE)" + fi + + # Give the first history item matching the pattern as the suggestion # - (r) subscript flag makes the pattern match on values - typeset -g suggestion="${history[(r)${prefix}*]}" + typeset -g suggestion="${history[(r)$pattern]}" } diff --git a/src/strategies/match_prev_cmd.zsh b/src/strategies/match_prev_cmd.zsh index f76d3c1..b709783 100644 --- a/src/strategies/match_prev_cmd.zsh +++ b/src/strategies/match_prev_cmd.zsh @@ -24,16 +24,23 @@ _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) + # Enable globbing flags so that we can use (#m) and (x~y) glob operator 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 the history items that match the prefix, excluding those that match + # the ignore pattern + local pattern="$prefix*" + if [[ -n $ZSH_AUTOSUGGEST_HISTORY_IGNORE ]]; then + pattern="($pattern)~($ZSH_AUTOSUGGEST_HISTORY_IGNORE)" + fi + # Get all history event numbers that correspond to history - # entries that match pattern $prefix* + # entries that match the pattern local history_match_keys - history_match_keys=(${(k)history[(R)$prefix*]}) + history_match_keys=(${(k)history[(R)$~pattern]}) # By default we use the first history number (most recent history entry) local histkey="${history_match_keys[1]}" diff --git a/src/widgets.zsh b/src/widgets.zsh index 6a2be4a..7562897 100644 --- a/src/widgets.zsh +++ b/src/widgets.zsh @@ -20,7 +20,7 @@ _zsh_autosuggest_enable() { # Toggle suggestions (enable/disable) _zsh_autosuggest_toggle() { - if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then + if (( ${+_ZSH_AUTOSUGGEST_DISABLED} )); then _zsh_autosuggest_enable else _zsh_autosuggest_disable @@ -30,15 +30,13 @@ _zsh_autosuggest_toggle() { # Clear the suggestion _zsh_autosuggest_clear() { # Remove the suggestion - unset POSTDISPLAY + POSTDISPLAY= _zsh_autosuggest_invoke_original_widget $@ } # Modify the buffer and get a new suggestion _zsh_autosuggest_modify() { - emulate -L zsh - local -i retval # Only available in zsh >= 5.4 @@ -49,37 +47,28 @@ _zsh_autosuggest_modify() { local orig_postdisplay="$POSTDISPLAY" # Clear suggestion while waiting for next one - unset POSTDISPLAY + 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 + 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" + # Optimize if manually typing in the suggestion or if buffer hasn't changed + if [[ "$BUFFER" = "$orig_buffer"* && "$orig_postdisplay" = "${BUFFER:$#orig_buffer}"* ]]; then + POSTDISPLAY="${orig_postdisplay:$(($#BUFFER - $#orig_buffer))}" return $retval fi # Bail out if suggestions are disabled - if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then + if (( ${+_ZSH_AUTOSUGGEST_DISABLED} )); then return $? fi @@ -95,7 +84,7 @@ _zsh_autosuggest_modify() { # Fetch a new suggestion based on what's currently in the buffer _zsh_autosuggest_fetch() { - if zpty -t "$ZSH_AUTOSUGGEST_ASYNC_PTY_NAME" &>/dev/null; then + if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then _zsh_autosuggest_async_request "$BUFFER" else local suggestion @@ -113,13 +102,13 @@ _zsh_autosuggest_suggest() { if [[ -n "$suggestion" ]] && (( $#BUFFER )); then POSTDISPLAY="${suggestion#$BUFFER}" else - unset POSTDISPLAY + POSTDISPLAY= fi } # Accept the entire suggestion _zsh_autosuggest_accept() { - local -i max_cursor_pos=$#BUFFER + local -i retval max_cursor_pos=$#BUFFER # When vicmd keymap is active, the cursor can't move all the way # to the end of the buffer @@ -127,19 +116,33 @@ _zsh_autosuggest_accept() { 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} + # If we're not in a valid state to accept a suggestion, just run the + # original widget and bail out + if (( $CURSOR != $max_cursor_pos || !$#POSTDISPLAY )); then + _zsh_autosuggest_invoke_original_widget $@ + return fi + # Only accept if the cursor is at the end of the buffer + # Add the suggestion to the buffer + BUFFER="$BUFFER$POSTDISPLAY" + + # Remove the suggestion + POSTDISPLAY= + + # Run the original widget before manually moving the cursor so that the + # cursor movement doesn't make the widget do something unexpected _zsh_autosuggest_invoke_original_widget $@ + retval=$? + + # Move the cursor to the end of the buffer + if [[ "$KEYMAP" = "vicmd" ]]; then + CURSOR=$(($#BUFFER - 1)) + else + CURSOR=$#BUFFER + fi + + return $retval } # Accept the entire suggestion and execute it @@ -148,7 +151,7 @@ _zsh_autosuggest_execute() { BUFFER="$BUFFER$POSTDISPLAY" # Remove the suggestion - unset POSTDISPLAY + POSTDISPLAY= # Call the original `accept-line` to handle syntax highlighting or # other potential custom behavior @@ -190,28 +193,39 @@ _zsh_autosuggest_partial_accept() { return $retval } -for action in clear modify fetch suggest accept partial_accept execute enable disable toggle; do - eval "_zsh_autosuggest_widget_$action() { - local -i retval +() { + typeset -ga _ZSH_AUTOSUGGEST_BUILTIN_ACTIONS - _zsh_autosuggest_highlight_reset + _ZSH_AUTOSUGGEST_BUILTIN_ACTIONS=( + clear + fetch + suggest + accept + execute + enable + disable + toggle + ) - _zsh_autosuggest_$action \$@ - retval=\$? + local action + for action in $_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS modify partial_accept; do + eval "_zsh_autosuggest_widget_$action() { + local -i retval - _zsh_autosuggest_highlight_apply + _zsh_autosuggest_highlight_reset - zle -R + _zsh_autosuggest_$action \$@ + retval=\$? - return \$retval - }" -done + _zsh_autosuggest_highlight_apply -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 + zle -R + + return \$retval + }" + done + + for action in $_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS; do + zle -N autosuggest-$action _zsh_autosuggest_widget_$action + done +} diff --git a/zsh-autosuggestions.zsh b/zsh-autosuggestions.zsh index d8f0151..e780225 100644 --- a/zsh-autosuggestions.zsh +++ b/zsh-autosuggestions.zsh @@ -1,8 +1,8 @@ # Fish-like fast/unobtrusive autosuggestions for zsh. # https://github.com/zsh-users/zsh-autosuggestions -# v0.5.0 +# v0.7.1 # Copyright (c) 2013 Thiago de Arruda -# Copyright (c) 2016-2018 Eric Freese +# Copyright (c) 2016-2021 Eric Freese # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation @@ -25,16 +25,6 @@ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. -#--------------------------------------------------------------------# -# Setup # -#--------------------------------------------------------------------# - -# Precmd hooks for initializing the library and starting pty's -autoload -Uz add-zsh-hook - -# Asynchronous suggestions are generated in a pty -zmodload zsh/zpty - #--------------------------------------------------------------------# # Global Configuration Variables # #--------------------------------------------------------------------# @@ -42,71 +32,93 @@ zmodload zsh/zpty # Color to use when highlighting suggestion # Uses format of `region_highlight` # More info: http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Zle-Widgets -: ${ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE='fg=8'} +(( ! ${+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=autosuggest-orig-} +(( ! ${+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} )) && ZSH_AUTOSUGGEST_STRATEGY=(history) +(( ! ${+ZSH_AUTOSUGGEST_STRATEGY} )) && { + typeset -ga ZSH_AUTOSUGGEST_STRATEGY + ZSH_AUTOSUGGEST_STRATEGY=(history) +} # Widgets that clear the suggestion -(( ! ${+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 -) +(( ! ${+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-beginning-search-forward-end + history-beginning-search-backward-end + 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} )) && ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=( - forward-char - end-of-line - vi-forward-char - vi-end-of-line - vi-add-eol -) +(( ! ${+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} )) && ZSH_AUTOSUGGEST_EXECUTE_WIDGETS=( -) +(( ! ${+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} )) && 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 -) +(( ! ${+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} )) && ZSH_AUTOSUGGEST_IGNORE_WIDGETS=( - orig-\* - beep - run-help - set-local-history - which-command - yank - yank-pop -) +(( ! ${+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-\* + ) +} -# Max size of buffer to trigger autosuggestion. Leave null for no upper bound. -: ${ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=} - -# Pty name for calculating autosuggestions asynchronously -: ${ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=zsh_autosuggest_pty} +# 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 # @@ -119,45 +131,13 @@ _zsh_autosuggest_escape_command() { echo -E "${1//(#m)[\"\'\\()\[\]|*?~]/\\$MATCH}" } -#--------------------------------------------------------------------# -# Feature Detection # -#--------------------------------------------------------------------# - -_zsh_autosuggest_feature_detect_zpty_returns_fd() { - typeset -g _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD - typeset -h REPLY - - zpty zsh_autosuggest_feature_detect '{ zshexit() { kill -KILL $$; sleep 1 } }' - - if (( REPLY )); then - _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=1 - else - _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=0 - fi - - zpty -d zsh_autosuggest_feature_detect -} - #--------------------------------------------------------------------# # Widget Helpers # #--------------------------------------------------------------------# _zsh_autosuggest_incr_bind_count() { - if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then - ((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]++)) - else - _ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=1 - fi - - typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1] -} - -_zsh_autosuggest_get_bind_count() { - if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then - typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1] - else - typeset -gi bind_count=0 - fi + 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 @@ -173,30 +153,30 @@ _zsh_autosuggest_bind_widget() { # Save a reference to the original widget case $widgets[$widget] in # Already bound - user:_zsh_autosuggest_(bound|orig)_*);; + 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]#*:} + 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 + 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]}" + eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}" ;; esac - _zsh_autosuggest_get_bind_count $widget - # 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 @@ -221,8 +201,7 @@ _zsh_autosuggest_bind_widgets() { ignore_widgets=( .\* _\* - zle-\* - autosuggest-\* + ${_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS/#/autosuggest-} $ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\* $ZSH_AUTOSUGGEST_IGNORE_WIDGETS ) @@ -305,7 +284,7 @@ _zsh_autosuggest_enable() { # Toggle suggestions (enable/disable) _zsh_autosuggest_toggle() { - if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then + if (( ${+_ZSH_AUTOSUGGEST_DISABLED} )); then _zsh_autosuggest_enable else _zsh_autosuggest_disable @@ -315,15 +294,13 @@ _zsh_autosuggest_toggle() { # Clear the suggestion _zsh_autosuggest_clear() { # Remove the suggestion - unset POSTDISPLAY + POSTDISPLAY= _zsh_autosuggest_invoke_original_widget $@ } # Modify the buffer and get a new suggestion _zsh_autosuggest_modify() { - emulate -L zsh - local -i retval # Only available in zsh >= 5.4 @@ -334,37 +311,28 @@ _zsh_autosuggest_modify() { local orig_postdisplay="$POSTDISPLAY" # Clear suggestion while waiting for next one - unset POSTDISPLAY + 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 + 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" + # Optimize if manually typing in the suggestion or if buffer hasn't changed + if [[ "$BUFFER" = "$orig_buffer"* && "$orig_postdisplay" = "${BUFFER:$#orig_buffer}"* ]]; then + POSTDISPLAY="${orig_postdisplay:$(($#BUFFER - $#orig_buffer))}" return $retval fi # Bail out if suggestions are disabled - if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then + if (( ${+_ZSH_AUTOSUGGEST_DISABLED} )); then return $? fi @@ -380,7 +348,7 @@ _zsh_autosuggest_modify() { # Fetch a new suggestion based on what's currently in the buffer _zsh_autosuggest_fetch() { - if zpty -t "$ZSH_AUTOSUGGEST_ASYNC_PTY_NAME" &>/dev/null; then + if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then _zsh_autosuggest_async_request "$BUFFER" else local suggestion @@ -398,13 +366,13 @@ _zsh_autosuggest_suggest() { if [[ -n "$suggestion" ]] && (( $#BUFFER )); then POSTDISPLAY="${suggestion#$BUFFER}" else - unset POSTDISPLAY + POSTDISPLAY= fi } # Accept the entire suggestion _zsh_autosuggest_accept() { - local -i max_cursor_pos=$#BUFFER + local -i retval max_cursor_pos=$#BUFFER # When vicmd keymap is active, the cursor can't move all the way # to the end of the buffer @@ -412,19 +380,33 @@ _zsh_autosuggest_accept() { 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} + # If we're not in a valid state to accept a suggestion, just run the + # original widget and bail out + if (( $CURSOR != $max_cursor_pos || !$#POSTDISPLAY )); then + _zsh_autosuggest_invoke_original_widget $@ + return fi + # Only accept if the cursor is at the end of the buffer + # Add the suggestion to the buffer + BUFFER="$BUFFER$POSTDISPLAY" + + # Remove the suggestion + POSTDISPLAY= + + # Run the original widget before manually moving the cursor so that the + # cursor movement doesn't make the widget do something unexpected _zsh_autosuggest_invoke_original_widget $@ + retval=$? + + # Move the cursor to the end of the buffer + if [[ "$KEYMAP" = "vicmd" ]]; then + CURSOR=$(($#BUFFER - 1)) + else + CURSOR=$#BUFFER + fi + + return $retval } # Accept the entire suggestion and execute it @@ -433,7 +415,7 @@ _zsh_autosuggest_execute() { BUFFER="$BUFFER$POSTDISPLAY" # Remove the suggestion - unset POSTDISPLAY + POSTDISPLAY= # Call the original `accept-line` to handle syntax highlighting or # other potential custom behavior @@ -475,31 +457,179 @@ _zsh_autosuggest_partial_accept() { return $retval } -for action in clear modify fetch suggest accept partial_accept execute enable disable toggle; do - eval "_zsh_autosuggest_widget_$action() { - local -i retval +() { + typeset -ga _ZSH_AUTOSUGGEST_BUILTIN_ACTIONS - _zsh_autosuggest_highlight_reset + _ZSH_AUTOSUGGEST_BUILTIN_ACTIONS=( + clear + fetch + suggest + accept + execute + enable + disable + toggle + ) - _zsh_autosuggest_$action \$@ - retval=\$? + local action + for action in $_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS modify partial_accept; do + eval "_zsh_autosuggest_widget_$action() { + local -i retval - _zsh_autosuggest_highlight_apply + _zsh_autosuggest_highlight_reset - zle -R + _zsh_autosuggest_$action \$@ + retval=\$? - return \$retval - }" -done + _zsh_autosuggest_highlight_apply -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 + zle -R + + return \$retval + }" + done + + for action in $_ZSH_AUTOSUGGEST_BUILTIN_ACTIONS; do + zle -N autosuggest-$action _zsh_autosuggest_widget_$action + done +} + +#--------------------------------------------------------------------# +# 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() { + # 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] + function _complete() { + unset 'compstate[vared]' + _original_complete "$@" + } + + # Open zle with buffer set so we can capture completions for it + vared 1 +} + +_zsh_autosuggest_strategy_completion() { + # Reset options to defaults and enable LOCAL_OPTIONS + emulate -L zsh + + # Enable extended glob for completion ignore pattern + setopt EXTENDED_GLOB + + 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 + + # Exit if our search string matches the ignore pattern + [[ -n "$ZSH_AUTOSUGGEST_COMPLETION_IGNORE" ]] && [[ "$1" == $~ZSH_AUTOSUGGEST_COMPLETION_IGNORE ]] && 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="${${(@0)line}[2]}" + } always { + # Destroy the pty + zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME + } +} #--------------------------------------------------------------------# # History Suggestion Strategy # @@ -512,7 +642,7 @@ _zsh_autosuggest_strategy_history() { # Reset options to defaults and enable LOCAL_OPTIONS emulate -L zsh - # Enable globbing flags so that we can use (#m) + # Enable globbing flags so that we can use (#m) and (x~y) glob operator setopt EXTENDED_GLOB # Escape backslashes and all of the glob operators so we can use @@ -521,9 +651,16 @@ _zsh_autosuggest_strategy_history() { # 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 + # Get the history items that match the prefix, excluding those that match + # the ignore pattern + local pattern="$prefix*" + if [[ -n $ZSH_AUTOSUGGEST_HISTORY_IGNORE ]]; then + pattern="($pattern)~($ZSH_AUTOSUGGEST_HISTORY_IGNORE)" + fi + + # Give the first history item matching the pattern as the suggestion # - (r) subscript flag makes the pattern match on values - typeset -g suggestion="${history[(r)${prefix}*]}" + typeset -g suggestion="${history[(r)$pattern]}" } #--------------------------------------------------------------------# @@ -551,16 +688,23 @@ _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) + # Enable globbing flags so that we can use (#m) and (x~y) glob operator 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 the history items that match the prefix, excluding those that match + # the ignore pattern + local pattern="$prefix*" + if [[ -n $ZSH_AUTOSUGGEST_HISTORY_IGNORE ]]; then + pattern="($pattern)~($ZSH_AUTOSUGGEST_HISTORY_IGNORE)" + fi + # Get all history event numbers that correspond to history - # entries that match pattern $prefix* + # entries that match the pattern local history_match_keys - history_match_keys=(${(k)history[(R)$prefix*]}) + history_match_keys=(${(k)history[(R)$~pattern]}) # By default we use the first history number (most recent history entry) local histkey="${history_match_keys[1]}" @@ -595,6 +739,7 @@ _zsh_autosuggest_strategy_match_prev_cmd() { _zsh_autosuggest_fetch_suggestion() { typeset -g suggestion local -a strategies + local strategy # Ensure we are working with an array strategies=(${=ZSH_AUTOSUGGEST_STRATEGY}) @@ -603,7 +748,10 @@ _zsh_autosuggest_fetch_suggestion() { # Try to get a suggestion from this strategy _zsh_autosuggest_strategy_$strategy "$1" - # Break once we've found a suggestion + # Ensure the suggestion matches the prefix + [[ "$suggestion" != "$1"* ]] && unset suggestion + + # Break once we've found a valid suggestion [[ -n "$suggestion" ]] && break done } @@ -612,109 +760,77 @@ _zsh_autosuggest_fetch_suggestion() { # Async # #--------------------------------------------------------------------# -# Zpty process is spawned running this function -_zsh_autosuggest_async_server() { - emulate -R zsh - - # There is a bug in zpty module (fixed in zsh/master) by which a - # zpty that exits will kill all zpty processes that were forked - # before it. Here we set up a zsh exit hook to SIGKILL the zpty - # process immediately, before it has a chance to kill any other - # zpty processes. - zshexit() { - kill -KILL $$ - sleep 1 # Block for long enough for the signal to come through - } - - # Don't add any extra carriage returns - stty -onlcr - - # Don't translate carriage returns to newlines - stty -icrnl - - # Silence any error messages - exec 2>/dev/null - - local last_pid - - while IFS='' read -r -d $'\0' query; do - # Kill last bg process - kill -KILL $last_pid &>/dev/null - - # Run suggestion search in the background - ( - local suggestion - _zsh_autosuggest_fetch_suggestion "$query" - echo -n -E "$suggestion"$'\0' - ) & - - last_pid=$! - done -} - _zsh_autosuggest_async_request() { - # Write the query to the zpty process to fetch a suggestion - zpty -w -n $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME "${1}"$'\0' + zmodload zsh/system 2>/dev/null # For `$sysparams` + + 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 + builtin exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&- + zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD + + # We won't know the pid unless the user has zsh/system module installed + if [[ -n "$_ZSH_AUTOSUGGEST_CHILD_PID" ]]; then + # 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 + fi + + # Fork a process to fetch a suggestion and open a pipe to read from it + builtin 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 + autoload -Uz is-at-least + is-at-least 5.8 || 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 pty +# 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() { - setopt LOCAL_OPTIONS EXTENDED_GLOB + emulate -L zsh local suggestion - zpty -rt $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME suggestion '*'$'\0' 2>/dev/null - zle autosuggest-suggest -- "${suggestion%%$'\0'##}" -} + 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" -_zsh_autosuggest_async_pty_create() { - # With newer versions of zsh, REPLY stores the fd to read from - typeset -h REPLY - - # If we won't get a fd back from zpty, try to guess it - if (( ! $_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD )); then - integer -l zptyfd - exec {zptyfd}>&1 # Open a new file descriptor (above 10). - exec {zptyfd}>&- # Close it so it's free to be used by zpty. + # Close the fd + builtin exec {1}<&- fi - # Fork a zpty process running the server function - zpty -b $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME _zsh_autosuggest_async_server - - # Store the fd so we can remove the handler later - if (( REPLY )); then - _ZSH_AUTOSUGGEST_PTY_FD=$REPLY - else - _ZSH_AUTOSUGGEST_PTY_FD=$zptyfd - fi - - # Set up input handler from the zpty - zle -F $_ZSH_AUTOSUGGEST_PTY_FD _zsh_autosuggest_async_response -} - -_zsh_autosuggest_async_pty_destroy() { - # Remove the input handler - zle -F $_ZSH_AUTOSUGGEST_PTY_FD &>/dev/null - - # Destroy the zpty - zpty -d $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME &>/dev/null -} - -_zsh_autosuggest_async_pty_recreate() { - _zsh_autosuggest_async_pty_destroy - _zsh_autosuggest_async_pty_create -} - -_zsh_autosuggest_async_start() { - typeset -g _ZSH_AUTOSUGGEST_PTY_FD - - _zsh_autosuggest_feature_detect_zpty_returns_fd - _zsh_autosuggest_async_pty_recreate - - # We recreate the pty to get a fresh list of history events - add-zsh-hook precmd _zsh_autosuggest_async_pty_recreate + # Always remove the handler + zle -F "$1" + _ZSH_AUTOSUGGEST_ASYNC_FD= } #--------------------------------------------------------------------# @@ -723,20 +839,29 @@ _zsh_autosuggest_async_start() { # Start the autosuggestion widgets _zsh_autosuggest_start() { - add-zsh-hook -d precmd _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 - - # Re-bind widgets on every precmd to ensure we wrap other wrappers. - # Specifically, highlighting breaks if our widgets are wrapped by - # zsh-syntax-highlighting widgets. This also allows modifications - # to the widget list variables to take effect on the next precmd. - add-zsh-hook precmd _zsh_autosuggest_bind_widgets - - if [[ -n "${ZSH_AUTOSUGGEST_USE_ASYNC+x}" ]]; then - _zsh_autosuggest_async_start - fi } +# Mark for auto-loading the functions that we use +autoload -Uz add-zsh-hook is-at-least + +# Automatically enable asynchronous mode in newer versions of zsh. Disable for +# older versions because there is a bug when using async mode where ^C does not +# work immediately after fetching a suggestion. +# See https://github.com/zsh-users/zsh-autosuggestions/issues/364 +if is-at-least 5.0.8; then + typeset -g ZSH_AUTOSUGGEST_USE_ASYNC= +fi + # Start the autosuggestion widgets on the next precmd add-zsh-hook precmd _zsh_autosuggest_start