Merge pull request #613 from zsh-users/develop

v0.7.0

.circleci/config.yml

@@ -0,0 +1,15 @@
+version: 2
+jobs:
+  build:
+    parallelism: 4
+    shell: /bin/bash --login
+    docker:
+    - image: ericfreese/zsh-autosuggestions-test:latest
+    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

.github/workflows/integration.yml

@@ -1,51 +0,0 @@
-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

Dockerfile

@@ -1,8 +1,5 @@
 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
@@ -14,8 +11,10 @@ RUN apk add --no-cache tmux
 
 WORKDIR /zsh-autosuggestions
 
-ADD install_test_zsh.sh ./
+ADD ZSH_VERSIONS /zsh-autosuggestions/ZSH_VERSIONS
+ADD install_test_zsh.sh /zsh-autosuggestions/install_test_zsh.sh
 RUN ./install_test_zsh.sh
 
-ADD Gemfile Gemfile.lock ./
+ADD Gemfile /zsh-autosuggestions/Gemfile
+ADD Gemfile.lock /zsh-autosuggestions/Gemfile.lock
 RUN bundle install

README.md

@@ -170,16 +170,18 @@ 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`).
 
-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 `<version>` below is substituted with the contents of a line from the [`ZSH_VERSIONS`](ZSH_VERSIONS) file), run:
+A docker image for testing is available [on docker hub](https://hub.docker.com/r/ericfreese/zsh-autosuggestions-test). It comes with ruby, the bundler dependencies, and all supported versions of zsh installed.
+
+Pull the docker image with:
 
 ```sh
-docker build --build-arg TEST_ZSH_VERSION=<version> -t zsh-autosuggestions-test .
+docker pull ericfreese/zsh-autosuggestions-test
 ```
 
-After building the image, run the tests via:
+To run the tests for a specific version of zsh (where `<version>` below is substituted with the contents of a line from the [`ZSH_VERSIONS`](ZSH_VERSIONS) file):
 
 ```sh
-docker run -it -v $PWD:/zsh-autosuggestions zsh-autosuggestions-test make test
+docker run -it -e TEST_ZSH_BIN=zsh-<version> -v $PWD:/zsh-autosuggestions zsh-autosuggestions-test make test
 ```
 
 

ZSH_VERSIONS

@@ -1,5 +1,9 @@
 # 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
@@ -10,5 +14,4 @@
 5.5.1
 5.6.2
 5.7.1
-5.8.1
-5.9
+5.8

install_test_zsh.sh

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

src/async.zsh

@@ -15,20 +15,31 @@ _zsh_autosuggest_async_request() {
 		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
 
 		# We won't know the pid unless the user has zsh/system module installed
-		if (( _ZSH_AUTOSUGGEST_CHILD_PID )); then
-			kill -TERM -- $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		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
 	exec {_ZSH_AUTOSUGGEST_ASYNC_FD}< <(
-		# Tell parent process our pid if we can
-		echo ${sysparams[pid]:-}
+		# Tell parent process our pid
+		echo $sysparams[pid]
 
 		# Fetch and print the suggestion
 		local suggestion
 		_zsh_autosuggest_fetch_suggestion "$1"
-		echo -nE - "$suggestion"
+		echo -nE "$suggestion"
 	)
 
 	# There's a weird bug here where ^C stops working unless we force a fork
@@ -39,15 +50,6 @@ _zsh_autosuggest_async_request() {
 	# Read the pid from the child process
 	read _ZSH_AUTOSUGGEST_CHILD_PID <&$_ZSH_AUTOSUGGEST_ASYNC_FD
 
-	# Zsh will make a new process group for the child process only if job
-	# control is enabled (MONITOR option)
-	if [[ -o MONITOR ]]; then
-		# If we need to kill the background process in the future, we'll send
-		# SIGTERM to the process group to kill any processes that may have been
-		# forked by the suggestion strategy
-		_ZSH_AUTOSUGGEST_CHILD_PID=${_ZSH_AUTOSUGGEST_CHILD_PID:+-$_ZSH_AUTOSUGGEST_CHILD_PID}
-	fi
-
 	# When the fd is readable, call the response handler
 	zle -F "$_ZSH_AUTOSUGGEST_ASYNC_FD" _zsh_autosuggest_async_response
 }
@@ -58,20 +60,17 @@ _zsh_autosuggest_async_request() {
 _zsh_autosuggest_async_response() {
 	emulate -L zsh
 
-	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
 	local suggestion
 
-	if [[ $# == 1 || "$2" == "hup" ]]; then
+	if [[ -z "$2" || "$2" == "hup" ]]; then
 		# Read everything from the fd and give it as a suggestion
 		IFS='' read -rd '' -u $1 suggestion
 		zle autosuggest-suggest -- "$suggestion"
 
 		# Close the fd
 		exec {1}<&-
-		_ZSH_AUTOSUGGEST_ASYNC_FD=
-		_ZSH_AUTOSUGGEST_ASYNC_PID=
 	fi
 
 	# Always remove the handler
-	zle -F $1
+	zle -F "$1"
 }

zsh-autosuggestions.zsh

@@ -770,20 +770,31 @@ _zsh_autosuggest_async_request() {
 		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
 
 		# We won't know the pid unless the user has zsh/system module installed
-		if (( _ZSH_AUTOSUGGEST_CHILD_PID )); then
-			kill -TERM -- $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
+		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
 	exec {_ZSH_AUTOSUGGEST_ASYNC_FD}< <(
-		# Tell parent process our pid if we can
-		echo ${sysparams[pid]:-}
+		# Tell parent process our pid
+		echo $sysparams[pid]
 
 		# Fetch and print the suggestion
 		local suggestion
 		_zsh_autosuggest_fetch_suggestion "$1"
-		echo -nE - "$suggestion"
+		echo -nE "$suggestion"
 	)
 
 	# There's a weird bug here where ^C stops working unless we force a fork
@@ -794,15 +805,6 @@ _zsh_autosuggest_async_request() {
 	# Read the pid from the child process
 	read _ZSH_AUTOSUGGEST_CHILD_PID <&$_ZSH_AUTOSUGGEST_ASYNC_FD
 
-	# Zsh will make a new process group for the child process only if job
-	# control is enabled (MONITOR option)
-	if [[ -o MONITOR ]]; then
-		# If we need to kill the background process in the future, we'll send
-		# SIGTERM to the process group to kill any processes that may have been
-		# forked by the suggestion strategy
-		_ZSH_AUTOSUGGEST_CHILD_PID=${_ZSH_AUTOSUGGEST_CHILD_PID:+-$_ZSH_AUTOSUGGEST_CHILD_PID}
-	fi
-
 	# When the fd is readable, call the response handler
 	zle -F "$_ZSH_AUTOSUGGEST_ASYNC_FD" _zsh_autosuggest_async_response
 }
@@ -813,22 +815,19 @@ _zsh_autosuggest_async_request() {
 _zsh_autosuggest_async_response() {
 	emulate -L zsh
 
-	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
 	local suggestion
 
-	if [[ $# == 1 || "$2" == "hup" ]]; then
+	if [[ -z "$2" || "$2" == "hup" ]]; then
 		# Read everything from the fd and give it as a suggestion
 		IFS='' read -rd '' -u $1 suggestion
 		zle autosuggest-suggest -- "$suggestion"
 
 		# Close the fd
 		exec {1}<&-
-		_ZSH_AUTOSUGGEST_ASYNC_FD=
-		_ZSH_AUTOSUGGEST_ASYNC_PID=
 	fi
 
 	# Always remove the handler
-	zle -F $1
+	zle -F "$1"
 }
 
 #--------------------------------------------------------------------#