0.16.3

https://github.com/junegunn/fzf.vim/issues/296

CHANGELOG.md

@@ -1,6 +1,38 @@
 CHANGELOG
 =========
 
+0.16.3
+------
+- Fixed a bug where fzf incorrectly display the lines when straddling tab
+  characters are trimmed
+- Placeholder expression used in `--preview` and `execute` action can
+  optionally take `+` flag to be used with multiple selections
+    - e.g. `git log --oneline | fzf --multi --preview 'git show {+1}'`
+- Added `execute-silent` action for executing a command silently without
+  switching to the alternate screen. This is useful when the process is
+  short-lived and you're not interested in its output.
+    - e.g. `fzf --bind 'ctrl-y:execute!(echo -n {} | pbcopy)'`
+- `ctrl-space` is allowed in `--bind`
+
+0.16.2
+------
+- Dropped ncurses dependency
+- Binaries for freebsd, openbsd, arm5, arm6, arm7, and arm8
+- Official 24-bit color support
+- Added support for composite actions in `--bind`. Multiple actions can be
+  chained using `+` separator.
+    - e.g. `fzf --bind 'ctrl-y:execute(echo -n {} | pbcopy)+abort'`
+- `--preview-window` with size 0 is allowed. This is used to make fzf execute
+  preview command in the background without displaying the result.
+- Minor bug fixes and improvements
+
+0.16.1
+------
+- Fixed `--height` option to properly fill the window with the background
+  color
+- Added `half-page-up` and `half-page-down` actions
+- Added `-L` flag to the default find command
+
 0.16.0
 ------
 - *Added `--height HEIGHT[%]` option*

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.16.0
+version=0.16.3
 auto_completion=
 key_bindings=
 update_config=2
@@ -160,10 +160,18 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ x86_64) download fzf-$version-darwin_${binary_arch:-amd64} ;;
+  Darwin\ *64)   download fzf-$version-darwin_${binary_arch:-amd64}  ;;
-  Darwin\ i*86)   download fzf-$version-darwin_${binary_arch:-386}   ;;
+  Darwin\ *86)   download fzf-$version-darwin_${binary_arch:-386}    ;;
-  Linux\ x86_64)  download fzf-$version-linux_${binary_arch:-amd64}  ;;
+  Linux\ *64)    download fzf-$version-linux_${binary_arch:-amd64}   ;;
-  Linux\ i*86)    download fzf-$version-linux_${binary_arch:-386}    ;;
+  Linux\ *86)    download fzf-$version-linux_${binary_arch:-386}     ;;
+  Linux\ armv5*) download fzf-$version-linux_${binary_arch:-arm5}    ;;
+  Linux\ armv6*) download fzf-$version-linux_${binary_arch:-arm6}    ;;
+  Linux\ armv7*) download fzf-$version-linux_${binary_arch:-arm7}    ;;
+  Linux\ armv8*) download fzf-$version-linux_${binary_arch:-arm8}    ;;
+  FreeBSD\ *64)  download fzf-$version-freebsd_${binary_arch:-amd64} ;;
+  FreeBSD\ *86)  download fzf-$version-freebsd_${binary_arch:-386}   ;;
+  OpenBSD\ *64)  download fzf-$version-openbsd_${binary_arch:-amd64} ;;
+  OpenBSD\ *86)  download fzf-$version-openbsd_${binary_arch:-386}   ;;
   *)              binary_available=0 binary_error=1  ;;
 esac
 

man/man1/fzf-tmux.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "Jan 2017" "fzf 0.16.0" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Jan 2017" "fzf 0.16.3" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane

man/man1/fzf.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Jan 2017" "fzf 0.16.0" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Jan 2017" "fzf 0.16.3" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -209,8 +209,7 @@ Number of spaces for a tab character (default: 8)
 Color configuration. The name of the base color scheme is followed by custom
 color mappings. Ansi color code of -1 denotes terminal default
 foreground/background color. You can also specify 24-bit color in \fB#rrggbb\fR
-format, but the support for 24-bit colors is experimental and only works when
+format.
-\fB--height\fR option is used.
 
 .RS
 e.g. \fBfzf --color=bg+:24\fR
@@ -263,13 +262,21 @@ Execute the given command for the current line and display the result on the
 preview window. \fB{}\fR in the command is the placeholder that is replaced to
 the single-quoted string of the current line. To transform the replacement
 string, specify field index expressions between the braces (See \fBFIELD INDEX
-EXPRESSION\fR for the details). Also, \fB{q}\fR is replaced to the current
+EXPRESSION\fR for the details).
-query string.
 
 .RS
 e.g. \fBfzf --preview="head -$LINES {}"\fR
      \fBls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
 
+A placeholder expression starting with \fB+\fR flag will be replaced to the
+space-separated list of the selected lines (or the current line if no selection
+was made) individually quoted.
+
+e.g. \fBfzf --multi --preview="head -10 {+}"\fR
+     \fBgit log --oneline | fzf --multi --preview 'git show {+1}'\fR
+
+Also, \fB{q}\fR is replaced to the current query string.
+
 Note that you can escape a placeholder pattern by prepending a backslash.
 .RE
 .TP
@@ -279,6 +286,9 @@ Determine the layout of the preview window. If the argument ends with
 \fBtoggle-preview\fR action is triggered. Long lines are truncated by default.
 Line wrap can be enabled with \fB:wrap\fR flag.
 
+If size is given as 0, preview window will not be visible, but fzf will still
+execute the command in the background.
+
 .RS
 .B POSITION: (default: right)
     \fBup
@@ -321,10 +331,10 @@ e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s,f1,f2,~,@\fR
 .RE
 .TP
 .B "--read0"
-Read input delimited by ASCII NUL character instead of newline character
+Read input delimited by ASCII NUL characters instead of newline characters
 .TP
 .B "--print0"
-Print output delimited by ASCII NUL character instead of newline character
+Print output delimited by ASCII NUL characters instead of newline characters
 .TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
@@ -416,6 +426,7 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
 
 .B AVAILABLE KEYS:    (SYNONYMS)
     \fIctrl-[a-z]\fR
+    \fIctrl-space\fR
     \fIalt-[a-z]\fR
     \fIalt-[0-9]\fR
     \fIf[1-12]\fR
@@ -459,7 +470,8 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBdown\fR                  \fIctrl-j  ctrl-n  down\fR
     \fBend-of-line\fR           \fIctrl-e  end\fR
     \fBexecute(...)\fR          (see below for the details)
-    \fBexecute-multi(...)\fR    (see below for the details)
+    \fBexecute-silent(...)\fR   (see below for the details)
+    \fRexecute-multi(...)\fR    (deprecated in favor of \fB{+}\fR expression)
     \fBforward-char\fR          \fIctrl-f  right\fR
     \fBforward-word\fR          \fIalt-f   shift-right\fR
     \fBignore\fR
@@ -470,6 +482,8 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBnext-history\fR          (\fIctrl-n\fR on \fB--history\fR)
     \fBpage-down\fR             \fIpgdn\fR
     \fBpage-up\fR               \fIpgup\fR
+    \fBhalf-page-down\fR
+    \fBhalf-page-up\fR
     \fBpreview-down\fR
     \fBpreview-up\fR
     \fBpreview-page-down\fR
@@ -479,17 +493,21 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBselect-all\fR
     \fBtoggle\fR
     \fBtoggle-all\fR
-    \fBtoggle-down\fR           \fIctrl-i  (tab)\fR
+    \fBtoggle+down\fR           \fIctrl-i  (tab)\fR
-    \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle-up\fR : \fBtoggle-down\fR)
+    \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)
-    \fBtoggle-out\fR            (\fB--reverse\fR ? \fBtoggle-down\fR : \fBtoggle-up\fR)
+    \fBtoggle-out\fR            (\fB--reverse\fR ? \fBtoggle+down\fR : \fBtoggle+up\fR)
     \fBtoggle-preview\fR
-    \fBtoggle-sort\fR           (equivalent to \fB--toggle-sort\fR)
+    \fBtoggle-sort\fR
-    \fBtoggle-up\fR             \fIbtab    (shift-tab)\fR
+    \fBtoggle+up\fR             \fIbtab    (shift-tab)\fR
     \fBunix-line-discard\fR     \fIctrl-u\fR
     \fBunix-word-rubout\fR      \fIctrl-w\fR
     \fBup\fR                    \fIctrl-k  ctrl-p  up\fR
     \fByank\fR                  \fIctrl-y\fR
 
+Multiple actions can be chained using \fB+\fR separator.
+
+    \fBfzf --bind 'ctrl-a:select-all+accept'\fR
+
 With \fBexecute(...)\fR action, you can execute arbitrary commands without
 leaving fzf. For example, you can turn fzf into a simple file browser by
 binding \fBenter\fR key to \fBless\fR command like follows.
@@ -522,10 +540,12 @@ the closing character. The catch is that it should be the last one in the
 comma-separated list of key-action pairs.
 .RE
 
-\fBexecute-multi(...)\fR is an alternative action that executes the command
+fzf switches to the alternate screen when executing a command. However, if the
-with the selected entries when multi-select is enabled (\fB--multi\fR). With
+command is expected to complete quickly, and you are not interested in its
-this action, \fB{}\fR is replaced with the quoted strings of the selected
+output, you might want to use \fBexecute-silent\fR instead, which silently
-entries separated by spaces.
+executes the command without the switching. Note that fzf will not be
+responsible until the command is complete. For asynchronous execution, start
+your command as a background process (i.e. appending \fB&\fR).
 
 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2016 Junegunn Choi
+" Copyright (c) 2017 Junegunn Choi
 "
 " MIT License
 "
@@ -167,9 +167,12 @@ function! s:common_sink(action, lines) abort
 endfunction
 
 function! s:get_color(attr, ...)
+  let gui = has('termguicolors') && &termguicolors
+  let fam = gui ? 'gui' : 'cterm'
+  let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$'
   for group in a:000
-    let code = synIDattr(synIDtrans(hlID(group)), a:attr, 'cterm')
+    let code = synIDattr(synIDtrans(hlID(group)), a:attr, fam)
-    if code =~ '^[0-9]\+$'
+    if code =~? pat
       return code
     endif
   endfor
@@ -298,23 +301,28 @@ try
     let prefix = ''
   endif
 
+  let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0)
   let use_height = has_key(dict, 'down') &&
         \ !(has('nvim') || has('win32') || has('win64') || s:present(dict, 'up', 'left', 'right')) &&
         \ executable('tput') && filereadable('/dev/tty')
-  let tmux = !use_height && (!has('nvim') || get(g:, 'fzf_prefer_tmux', 0)) && s:tmux_enabled() && s:splittable(dict)
+  let use_term = has('nvim')
-  let term = has('nvim') && !tmux
+  let use_tmux = (!use_height && !use_term || prefer_tmux) && s:tmux_enabled() && s:splittable(dict)
+  if prefer_tmux && use_tmux
+    let use_height = 0
+    let use_term = 0
+  endif
   if use_height
     let optstr .= ' --height='.s:calc_size(&lines, dict.down, dict)
-  elseif term
+  elseif use_term
     let optstr .= ' --no-height'
   endif
-  let command = prefix.(tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
+  let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
-  if term
+  if use_term
     return s:execute_term(dict, command, temps)
   endif
 
-  let lines = tmux ? s:execute_tmux(dict, command, temps)
+  let lines = use_tmux ? s:execute_tmux(dict, command, temps)
                  \ : s:execute(dict, command, use_height, temps)
   call s:callback(dict, lines)
   return lines

shell/key-bindings.bash

@@ -56,7 +56,7 @@ __fzf_history__() (
   shopt -u nocaseglob nocasematch
   line=$(
     HISTTIMEFORMAT= history |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS +s --tac --no-reverse -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS +m" $(__fzfcmd) |
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS +s --tac -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m" $(__fzfcmd) |
     command grep '^ *[0-9]') &&
     if [[ $- =~ H ]]; then
       sed 's/^ *\([0-9]*\)\** .*/!\1/' <<< "$line"

shell/key-bindings.fish

@@ -45,7 +45,7 @@ function fzf_key_bindings
   function fzf-history-widget -d "Show command history"
     set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
     begin
-      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS +s --no-reverse --tiebreak=index $FZF_CTRL_R_OPTS +m"
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS +s --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m"
       history | eval (__fzfcmd) -q '(commandline)' | read -l result
       and commandline -- $result
     end

shell/key-bindings.zsh

@@ -55,7 +55,7 @@ fzf-history-widget() {
   local selected num
   setopt localoptions noglobsubst pipefail 2> /dev/null
   selected=( $(fc -l 1 |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS +s --tac --no-reverse -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS +m --query=${(q)LBUFFER}" $(__fzfcmd)) )
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS +s --tac -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS --query=${(q)LBUFFER} +m" $(__fzfcmd)) )
   local ret=$?
   if [ -n "$selected" ]; then
     num=$selected[1]

src/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2017 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/Makefile

@@ -15,18 +15,35 @@ SRCDIR      := $(GOPATH)/src/github.com/junegunn/fzf/src
 DOCKEROPTS  := -i -t -v $(ROOTDIR):/fzf/src
 BINARY32    := fzf-$(GOOS)_386
 BINARY64    := fzf-$(GOOS)_amd64
+BINARYARM5  := fzf-$(GOOS)_arm5
+BINARYARM6  := fzf-$(GOOS)_arm6
 BINARYARM7  := fzf-$(GOOS)_arm7
+BINARYARM8  := fzf-$(GOOS)_arm8
 VERSION     := $(shell awk -F= '/version =/ {print $$2}' constants.go | tr -d "\" ")
 RELEASE32   := fzf-$(VERSION)-$(GOOS)_386
 RELEASE64   := fzf-$(VERSION)-$(GOOS)_amd64
+RELEASEARM5 := fzf-$(VERSION)-$(GOOS)_arm5
+RELEASEARM6 := fzf-$(VERSION)-$(GOOS)_arm6
 RELEASEARM7 := fzf-$(VERSION)-$(GOOS)_arm7
+RELEASEARM8 := fzf-$(VERSION)-$(GOOS)_arm8
 export GOPATH
 
+# https://en.wikipedia.org/wiki/Uname
 UNAME_M := $(shell uname -m)
 ifeq ($(UNAME_M),x86_64)
 	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),amd64)
+	BINARY := $(BINARY64)
 else ifeq ($(UNAME_M),i686)
 	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),i386)
+	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),armv5l)
+	BINARY := $(BINARYARM5)
+else ifeq ($(UNAME_M),armv6l)
+	BINARY := $(BINARYARM6)
+else ifeq ($(UNAME_M),armv7l)
+	BINARY := $(BINARYARM7)
 else
 $(error "Build on $(UNAME_M) is not supported, yet.")
 endif
@@ -35,22 +52,39 @@ all: fzf/$(BINARY)
 
 ifeq ($(GOOS),windows)
 release: fzf/$(BINARY32) fzf/$(BINARY64)
-	-cd fzf && cp $(BINARY32) $(RELEASE32).exe && zip $(RELEASE32).zip $(RELEASE32).exe
+	cd fzf && cp $(BINARY32) $(RELEASE32).exe && zip $(RELEASE32).zip $(RELEASE32).exe
-	cd fzf && cp $(BINARY64) $(RELEASE64).exe && zip $(RELEASE64).zip $(RELEASE64).exe && \
+	cd fzf && cp $(BINARY64) $(RELEASE64).exe && zip $(RELEASE64).zip $(RELEASE64).exe
-	rm -f $(RELEASE32).exe $(RELEASE64).exe
+	cd fzf && rm -f $(RELEASE32).exe $(RELEASE64).exe
+else ifeq ($(GOOS),linux)
+release: fzf/$(BINARY32) fzf/$(BINARY64) fzf/$(BINARYARM5) fzf/$(BINARYARM6) fzf/$(BINARYARM7) fzf/$(BINARYARM8)
+	cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
+	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64)
+	cd fzf && cp $(BINARYARM5) $(RELEASEARM5) && tar -czf $(RELEASEARM5).tgz $(RELEASEARM5)
+	cd fzf && cp $(BINARYARM6) $(RELEASEARM6) && tar -czf $(RELEASEARM6).tgz $(RELEASEARM6)
+	cd fzf && cp $(BINARYARM7) $(RELEASEARM7) && tar -czf $(RELEASEARM7).tgz $(RELEASEARM7)
+	cd fzf && cp $(BINARYARM8) $(RELEASEARM8) && tar -czf $(RELEASEARM8).tgz $(RELEASEARM8)
+	cd fzf && rm -f $(RELEASE32) $(RELEASE64) $(RELEASEARM5) $(RELEASEARM6) $(RELEASEARM7) $(RELEASEARM8)
 else
-release: test fzf/$(BINARY32) fzf/$(BINARY64)
+release: fzf/$(BINARY32) fzf/$(BINARY64)
-	-cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
+	cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
-	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
+	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64)
-	rm -f $(RELEASE32) $(RELEASE64)
+	cd fzf && rm -f $(RELEASE32) $(RELEASE64)
 endif
 
+release-all: clean test
+	GOOS=darwin  make release
+	GOOS=linux   make release
+	GOOS=freebsd make release
+	GOOS=openbsd make release
+	GOOS=windows make release
+
 $(SRCDIR):
 	mkdir -p $(shell dirname $(SRCDIR))
 	ln -s $(ROOTDIR) $(SRCDIR)
 
 deps: $(SRCDIR) $(SOURCES)
 	cd $(SRCDIR) && go get -tags "$(TAGS)"
+	./deps
 
 android-build: $(SRCDIR)
 	cd $(SRCDIR) && GOARCH=arm GOARM=7 CGO_ENABLED=1 go get
@@ -59,7 +93,7 @@ android-build: $(SRCDIR)
 	rm -f $(RELEASEARM7)
 
 test: deps
-	SHELL=/bin/sh GOOS=$(GOOS) go test -v -tags "$(TAGS)" ./...
+	SHELL=/bin/sh GOOS= go test -v -tags "$(TAGS)" ./...
 
 install: $(BINDIR)/fzf
 
@@ -70,10 +104,23 @@ clean:
 	cd fzf && rm -f fzf-*
 
 fzf/$(BINARY32): deps
-	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY32)
+	cd fzf && GOARCH=386 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY32)
 
 fzf/$(BINARY64): deps
-	cd fzf && go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY64)
+	cd fzf && GOARCH=amd64 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARY64)
+
+# https://github.com/golang/go/wiki/GoArm
+fzf/$(BINARYARM5): deps
+	cd fzf && GOARCH=arm GOARM=5 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARYARM5)
+
+fzf/$(BINARYARM6): deps
+	cd fzf && GOARCH=arm GOARM=6 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARYARM6)
+
+fzf/$(BINARYARM7): deps
+	cd fzf && GOARCH=arm GOARM=7 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARYARM7)
+
+fzf/$(BINARYARM8): deps
+	cd fzf && GOARCH=arm64 go build -a -ldflags "-w -extldflags=$(LDFLAGS)" -tags "$(TAGS)" -o $(BINARYARM8)
 
 $(BINDIR)/fzf: fzf/$(BINARY) | $(BINDIR)
 	cp -f fzf/$(BINARY) $(BINDIR)

src/README.md

@@ -59,20 +59,31 @@ Unit tests can be run with `make test`. Integration tests are written in Ruby
 script that should be run on tmux.
 
 ```sh
+cd src
+
 # Unit tests
 make test
 
+# Integration tests
+ruby ../test/test_go.rb
+
+# Build binary for the platform
+make
+
 # Install the executable to ../bin directory
 make install
 
-# Integration tests
+# Make release archives
-ruby ../test/test_go.rb
+make release
+
+# Make release archives for all supported platforms
+make release-all
 ```
 
 Third-party libraries used
 --------------------------
 
-- [ncurses][ncurses]
+- ~[ncurses][ncurses]~
 - [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
     - Licensed under [MIT](http://mattn.mit-license.org)
 - [mattn/go-shellwords](https://github.com/mattn/go-shellwords)

src/constants.go

@@ -8,7 +8,7 @@ import (
 
 const (
 	// Current version
-	version = "0.16.0"
+	version = "0.16.3"
 
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond

src/constants_unix.go

@@ -4,5 +4,5 @@ package fzf
 
 const (
 	// Reader
-	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
+	defaultCommand = `find -L . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
 )

src/core.go

@@ -3,7 +3,7 @@ Package fzf implements fzf, a command-line fuzzy finder.
 
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2017 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/deps

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+if [ -z "$GOPATH" ]; then
+  echo '$GOPATH not defined'
+  exit 1
+fi
+
+reset() (
+  cd "$GOPATH/src/$1"
+  export GIT_DIR="$(pwd)/.git"
+  [ "$(git rev-parse HEAD)" = "$2" ] ||
+    (git fetch && git reset --hard "$2")
+)
+
+reset github.com/junegunn/go-isatty     66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8
+reset github.com/junegunn/go-runewidth  63c378b851290989b19ca955468386485f118c65
+reset github.com/junegunn/go-shellwords 33bd8f1ebe16d6e5eb688cc885749a63059e9167
+reset golang.org/x/crypto               abc5fa7ad02123a41f02bf1391c9760f7586e608

src/options.go

@@ -82,6 +82,8 @@ const usage = `usage: fzf [options]
     -f, --filter=STR      Filter mode. Do not start interactive finder.
     --print-query         Print query as the first line
     --expect=KEYS         Comma-separated list of keys to complete fzf
+    --read0               Read input delimited by ASCII NUL characters
+    --print0              Print output delimited by ASCII NUL characters
     --sync                Synchronous search for multi-staged filtering
 
   Environment variables
@@ -171,8 +173,7 @@ type Options struct {
 	Filter      *string
 	ToggleSort  bool
 	Expect      map[int]string
-	Keymap      map[int]actionType
+	Keymap      map[int][]action
-	Execmap     map[int]string
 	Preview     previewOpts
 	PrintQuery  bool
 	ReadZero    bool
@@ -220,8 +221,7 @@ func defaultOptions() *Options {
 		Filter:      nil,
 		ToggleSort:  false,
 		Expect:      make(map[int]string),
-		Keymap:      make(map[int]actionType),
+		Keymap:      make(map[int][]action),
-		Execmap:     make(map[int]string),
 		Preview:     previewOpts{"", posRight, sizeSpec{50, true}, false, false},
 		PrintQuery:  false,
 		ReadZero:    false,
@@ -393,6 +393,8 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = tui.AltZ + int(' ')
 		case "bspace", "bs":
 			chord = tui.BSpace
+		case "ctrl-space":
+			chord = tui.CtrlSpace
 		case "alt-enter", "alt-return":
 			chord = tui.AltEnter
 		case "alt-space":
@@ -578,23 +580,32 @@ func firstKey(keymap map[int]string) int {
 const (
 	escapedColon = 0
 	escapedComma = 1
+	escapedPlus  = 2
 )
 
-func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string) {
+func init() {
-	if executeRegexp == nil {
 	// Backreferences are not supported.
 	// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
 	executeRegexp = regexp.MustCompile(
-			"(?s):execute(-multi)?:.*|:execute(-multi)?(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
+		"(?si):(execute(?:-multi|-silent)?):.+|:(execute(?:-multi|-silent)?)(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
 }
+
+func parseKeymap(keymap map[int][]action, str string) {
 	masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string {
-		if strings.HasPrefix(src, ":execute-multi") {
+		prefix := ":execute"
-			return ":execute-multi(" + strings.Repeat(" ", len(src)-len(":execute-multi()")) + ")"
+		if src[len(prefix)] == '-' {
+			c := src[len(prefix)+1]
+			if c == 's' || c == 'S' {
+				prefix += "-silent"
+			} else {
+				prefix += "-multi"
 			}
-		return ":execute(" + strings.Repeat(" ", len(src)-len(":execute()")) + ")"
+		}
+		return prefix + "(" + strings.Repeat(" ", len(src)-len(prefix)-2) + ")"
 	})
 	masked = strings.Replace(masked, "::", string([]rune{escapedColon, ':'}), -1)
 	masked = strings.Replace(masked, ",:", string([]rune{escapedComma, ':'}), -1)
+	masked = strings.Replace(masked, "+:", string([]rune{escapedPlus, ':'}), -1)
 
 	idx := 0
 	for _, pairStr := range strings.Split(masked, ",") {
@@ -610,147 +621,174 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string)
 			key = ':' + tui.AltZ
 		} else if len(pair[0]) == 1 && pair[0][0] == escapedComma {
 			key = ',' + tui.AltZ
+		} else if len(pair[0]) == 1 && pair[0][0] == escapedPlus {
+			key = '+' + tui.AltZ
 		} else {
 			keys := parseKeyChords(pair[0], "key name required")
 			key = firstKey(keys)
 		}
 
-		act := origPairStr[len(pair[0])+1 : len(origPairStr)]
+		idx2 := len(pair[0]) + 1
-		actLower := strings.ToLower(act)
+		specs := strings.Split(pair[1], "+")
-		switch actLower {
+		actions := make([]action, 0, len(specs))
+		appendAction := func(types ...actionType) {
+			actions = append(actions, toActions(types...)...)
+		}
+		prevSpec := ""
+		for specIndex, maskedSpec := range specs {
+			spec := origPairStr[idx2 : idx2+len(maskedSpec)]
+			idx2 += len(maskedSpec) + 1
+			spec = prevSpec + spec
+			specLower := strings.ToLower(spec)
+			switch specLower {
 			case "ignore":
-			keymap[key] = actIgnore
+				appendAction(actIgnore)
 			case "beginning-of-line":
-			keymap[key] = actBeginningOfLine
+				appendAction(actBeginningOfLine)
 			case "abort":
-			keymap[key] = actAbort
+				appendAction(actAbort)
 			case "accept":
-			keymap[key] = actAccept
+				appendAction(actAccept)
 			case "print-query":
-			keymap[key] = actPrintQuery
+				appendAction(actPrintQuery)
 			case "backward-char":
-			keymap[key] = actBackwardChar
+				appendAction(actBackwardChar)
 			case "backward-delete-char":
-			keymap[key] = actBackwardDeleteChar
+				appendAction(actBackwardDeleteChar)
 			case "backward-word":
-			keymap[key] = actBackwardWord
+				appendAction(actBackwardWord)
 			case "clear-screen":
-			keymap[key] = actClearScreen
+				appendAction(actClearScreen)
 			case "delete-char":
-			keymap[key] = actDeleteChar
+				appendAction(actDeleteChar)
 			case "delete-char/eof":
-			keymap[key] = actDeleteCharEOF
+				appendAction(actDeleteCharEOF)
 			case "end-of-line":
-			keymap[key] = actEndOfLine
+				appendAction(actEndOfLine)
 			case "cancel":
-			keymap[key] = actCancel
+				appendAction(actCancel)
 			case "forward-char":
-			keymap[key] = actForwardChar
+				appendAction(actForwardChar)
 			case "forward-word":
-			keymap[key] = actForwardWord
+				appendAction(actForwardWord)
 			case "jump":
-			keymap[key] = actJump
+				appendAction(actJump)
 			case "jump-accept":
-			keymap[key] = actJumpAccept
+				appendAction(actJumpAccept)
 			case "kill-line":
-			keymap[key] = actKillLine
+				appendAction(actKillLine)
 			case "kill-word":
-			keymap[key] = actKillWord
+				appendAction(actKillWord)
 			case "unix-line-discard", "line-discard":
-			keymap[key] = actUnixLineDiscard
+				appendAction(actUnixLineDiscard)
 			case "unix-word-rubout", "word-rubout":
-			keymap[key] = actUnixWordRubout
+				appendAction(actUnixWordRubout)
 			case "yank":
-			keymap[key] = actYank
+				appendAction(actYank)
 			case "backward-kill-word":
-			keymap[key] = actBackwardKillWord
+				appendAction(actBackwardKillWord)
 			case "toggle-down":
-			keymap[key] = actToggleDown
+				appendAction(actToggle, actDown)
 			case "toggle-up":
-			keymap[key] = actToggleUp
+				appendAction(actToggle, actUp)
 			case "toggle-in":
-			keymap[key] = actToggleIn
+				appendAction(actToggleIn)
 			case "toggle-out":
-			keymap[key] = actToggleOut
+				appendAction(actToggleOut)
 			case "toggle-all":
-			keymap[key] = actToggleAll
+				appendAction(actToggleAll)
 			case "select-all":
-			keymap[key] = actSelectAll
+				appendAction(actSelectAll)
 			case "deselect-all":
-			keymap[key] = actDeselectAll
+				appendAction(actDeselectAll)
 			case "toggle":
-			keymap[key] = actToggle
+				appendAction(actToggle)
 			case "down":
-			keymap[key] = actDown
+				appendAction(actDown)
 			case "up":
-			keymap[key] = actUp
+				appendAction(actUp)
 			case "page-up":
-			keymap[key] = actPageUp
+				appendAction(actPageUp)
 			case "page-down":
-			keymap[key] = actPageDown
+				appendAction(actPageDown)
+			case "half-page-up":
+				appendAction(actHalfPageUp)
+			case "half-page-down":
+				appendAction(actHalfPageDown)
 			case "previous-history":
-			keymap[key] = actPreviousHistory
+				appendAction(actPreviousHistory)
 			case "next-history":
-			keymap[key] = actNextHistory
+				appendAction(actNextHistory)
 			case "toggle-preview":
-			keymap[key] = actTogglePreview
+				appendAction(actTogglePreview)
 			case "toggle-sort":
-			keymap[key] = actToggleSort
+				appendAction(actToggleSort)
 			case "preview-up":
-			keymap[key] = actPreviewUp
+				appendAction(actPreviewUp)
 			case "preview-down":
-			keymap[key] = actPreviewDown
+				appendAction(actPreviewDown)
 			case "preview-page-up":
-			keymap[key] = actPreviewPageUp
+				appendAction(actPreviewPageUp)
 			case "preview-page-down":
-			keymap[key] = actPreviewPageDown
+				appendAction(actPreviewPageDown)
 			default:
-			if isExecuteAction(actLower) {
+				t := isExecuteAction(specLower)
-				var offset int
+				if t == actIgnore {
-				if strings.HasPrefix(actLower, "execute-multi") {
+					errorExit("unknown action: " + spec)
-					keymap[key] = actExecuteMulti
-					offset = len("execute-multi")
 				} else {
-					keymap[key] = actExecute
+					var offset int
+					switch t {
+					case actExecuteSilent:
+						offset = len("execute-silent")
+					case actExecuteMulti:
+						offset = len("execute-multi")
+					default:
 						offset = len("execute")
 					}
-				if act[offset] == ':' {
+					if spec[offset] == ':' {
-					execmap[key] = act[offset+1:]
+						if specIndex == len(specs)-1 {
+							actions = append(actions, action{t: t, a: spec[offset+1:]})
 						} else {
-					execmap[key] = act[offset+1 : len(act)-1]
+							prevSpec = spec + "+"
+							continue
 						}
 					} else {
-				errorExit("unknown action: " + act)
+						actions = append(actions, action{t: t, a: spec[offset+1 : len(spec)-1]})
 					}
 				}
 			}
+			prevSpec = ""
+		}
+		keymap[key] = actions
+	}
 }
 
-func isExecuteAction(str string) bool {
+func isExecuteAction(str string) actionType {
-	if !strings.HasPrefix(str, "execute") || len(str) < len("execute()") {
+	matches := executeRegexp.FindAllStringSubmatch(":"+str, -1)
-		return false
+	if matches == nil || len(matches) != 1 {
+		return actIgnore
 	}
-	b := str[len("execute")]
+	prefix := matches[0][1]
-	if strings.HasPrefix(str, "execute-multi") {
+	if len(prefix) == 0 {
-		if len(str) < len("execute-multi()") {
+		prefix = matches[0][2]
-			return false
 	}
-		b = str[len("execute-multi")]
+	switch prefix {
+	case "execute":
+		return actExecute
+	case "execute-silent":
+		return actExecuteSilent
+	case "execute-multi":
+		return actExecuteMulti
 	}
-	e := str[len(str)-1]
+	return actIgnore
-	if b == ':' || b == '(' && e == ')' || b == '[' && e == ']' ||
-		b == e && strings.ContainsAny(string(b), "~!@#$%^&*;/|") {
-		return true
-	}
-	return false
 }
 
-func parseToggleSort(keymap map[int]actionType, str string) {
+func parseToggleSort(keymap map[int][]action, str string) {
 	keys := parseKeyChords(str, "key name required")
 	if len(keys) != 1 {
 		errorExit("multiple keys specified")
 	}
-	keymap[firstKey(keys)] = actToggleSort
+	keymap[firstKey(keys)] = toActions(actToggleSort)
 }
 
 func strLines(str string) []string {
@@ -797,7 +835,7 @@ func parsePreviewWindow(opts *previewOpts, input string) {
 	opts.wrap = false
 
 	tokens := strings.Split(input, ":")
-	sizeRegex := regexp.MustCompile("^[1-9][0-9]*%?$")
+	sizeRegex := regexp.MustCompile("^[0-9]+%?$")
 	for _, token := range tokens {
 		switch token {
 		case "hidden":
@@ -915,7 +953,7 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--tiebreak":
 			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
-			parseKeymap(opts.Keymap, opts.Execmap, nextString(allArgs, &i, "bind expression required"))
+			parseKeymap(opts.Keymap, nextString(allArgs, &i, "bind expression required"))
 		case "--color":
 			spec := optionalNextString(allArgs, &i)
 			if len(spec) == 0 {
@@ -1085,7 +1123,7 @@ func parseOptions(opts *Options, allArgs []string) {
 			} else if match, value := optString(arg, "--color="); match {
 				opts.Theme = parseTheme(opts.Theme, value)
 			} else if match, value := optString(arg, "--bind="); match {
-				parseKeymap(opts.Keymap, opts.Execmap, value)
+				parseKeymap(opts.Keymap, value)
 			} else if match, value := optString(arg, "--history="); match {
 				setHistory(value)
 			} else if match, value := optString(arg, "--history-size="); match {
@@ -1141,20 +1179,22 @@ func postProcessOptions(opts *Options) {
 	// Default actions for CTRL-N / CTRL-P when --history is set
 	if opts.History != nil {
 		if _, prs := opts.Keymap[tui.CtrlP]; !prs {
-			opts.Keymap[tui.CtrlP] = actPreviousHistory
+			opts.Keymap[tui.CtrlP] = toActions(actPreviousHistory)
 		}
 		if _, prs := opts.Keymap[tui.CtrlN]; !prs {
-			opts.Keymap[tui.CtrlN] = actNextHistory
+			opts.Keymap[tui.CtrlN] = toActions(actNextHistory)
 		}
 	}
 
 	// Extend the default key map
 	keymap := defaultKeymap()
-	for key, act := range opts.Keymap {
+	for key, actions := range opts.Keymap {
-		if act == actToggleSort {
+		for _, act := range actions {
+			if act.t == actToggleSort {
 				opts.ToggleSort = true
 			}
-		keymap[key] = act
+		}
+		keymap[key] = actions
 	}
 	opts.Keymap = keymap
 

src/options_test.go

@@ -225,49 +225,51 @@ func TestParseKeysWithComma(t *testing.T) {
 }
 
 func TestBind(t *testing.T) {
-	check := func(action actionType, expected actionType) {
-		if action != expected {
-			t.Errorf("%d != %d", action, expected)
-		}
-	}
-	checkString := func(action string, expected string) {
-		if action != expected {
-			t.Errorf("%d != %d", action, expected)
-		}
-	}
 	keymap := defaultKeymap()
-	execmap := make(map[int]string)
+	check := func(keyName int, arg1 string, types ...actionType) {
-	check(actBeginningOfLine, keymap[tui.CtrlA])
+		if len(keymap[keyName]) != len(types) {
-	parseKeymap(keymap, execmap,
+			t.Errorf("invalid number of actions (%d != %d)", len(types), len(keymap[keyName]))
-		"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
+			return
-			"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+		}
-			"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
+		for idx, action := range keymap[keyName] {
-			",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
+			if types[idx] != action.t {
-	check(actKillLine, keymap[tui.CtrlA])
+				t.Errorf("invalid action type (%d != %d)", types[idx], action.t)
-	check(actToggleSort, keymap[tui.CtrlB])
+			}
-	check(actPageUp, keymap[tui.AltZ+'c'])
+		}
-	check(actAbort, keymap[tui.AltZ+','])
+		if len(arg1) > 0 && keymap[keyName][0].a != arg1 {
-	check(actAccept, keymap[tui.AltZ+':'])
+			t.Errorf("invalid action argument: (%s != %s)", arg1, keymap[keyName][0].a)
-	check(actPageDown, keymap[tui.AltZ])
+		}
-	check(actExecute, keymap[tui.F1])
+	}
-	check(actExecute, keymap[tui.F2])
+	check(tui.CtrlA, "", actBeginningOfLine)
-	check(actExecute, keymap[tui.F3])
+	parseKeymap(keymap,
-	check(actExecute, keymap[tui.F4])
+		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-	checkString("ls {}", execmap[tui.F1])
+			"f1:execute(ls {})+abort,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
-	checkString("echo {}, {}, {}", execmap[tui.F2])
+			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
-	checkString("echo '({})'", execmap[tui.F3])
+			"x:Execute(foo+bar),X:execute/bar+baz/"+
-	checkString("less {}", execmap[tui.F4])
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
-	checkString("echo (,),[,],/,:,;,%,{}", execmap[tui.AltA])
+	check(tui.CtrlA, "", actKillLine)
-	checkString("echo (,),[,],/,:,@,%,{}", execmap[tui.AltB])
+	check(tui.CtrlB, "", actToggleSort, actUp, actDown)
-	checkString("\nfoobar,Y:execute(baz)", execmap[tui.AltZ+'X'])
+	check(tui.AltZ+'c', "", actPageUp)
+	check(tui.AltZ+',', "", actAbort)
+	check(tui.AltZ+':', "", actAccept)
+	check(tui.AltZ, "", actPageDown)
+	check(tui.F1, "ls {}", actExecute, actAbort)
+	check(tui.F2, "echo {}, {}, {}", actExecute)
+	check(tui.F3, "echo '({})'", actExecute)
+	check(tui.F4, "less {}", actExecute)
+	check(tui.AltZ+'x', "foo+bar", actExecute)
+	check(tui.AltZ+'X', "bar+baz", actExecute)
+	check(tui.AltA, "echo (,),[,],/,:,;,%,{}", actExecuteMulti)
+	check(tui.AltB, "echo (,),[,],/,:,@,%,{}", actExecute)
+	check(tui.AltZ+'+', "++\nfoobar,Y:execute(baz)+up", actExecute)
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		parseKeymap(keymap, execmap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
-		checkString("foobar", execmap[tui.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
+		check(tui.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
 	}
 
-	parseKeymap(keymap, execmap, "f1:abort")
+	parseKeymap(keymap, "f1:abort")
-	check(actAbort, keymap[tui.F1])
+	check(tui.F1, "", actAbort)
 }
 
 func TestColorSpec(t *testing.T) {
@@ -327,7 +329,7 @@ func TestDefaultCtrlNP(t *testing.T) {
 		opts := defaultOptions()
 		parseOptions(opts, words)
 		postProcessOptions(opts)
-		if opts.Keymap[key] != expected {
+		if opts.Keymap[key][0].t != expected {
 			t.Error()
 		}
 	}

src/terminal.go

@@ -24,7 +24,7 @@ import (
 var placeholder *regexp.Regexp
 
 func init() {
-	placeholder = regexp.MustCompile("\\\\?(?:{[0-9,-.]*}|{q})")
+	placeholder = regexp.MustCompile("\\\\?(?:{\\+?[0-9,-.]*}|{q})")
 }
 
 type jumpMode int
@@ -72,8 +72,7 @@ type Terminal struct {
 	toggleSort bool
 	delimiter  Delimiter
 	expect     map[int]string
-	keymap     map[int]actionType
+	keymap     map[int][]action
-	execmap    map[int]string
 	pressed    string
 	printQuery bool
 	history    *History
@@ -148,6 +147,11 @@ const (
 	reqQuit
 )
 
+type action struct {
+	t actionType
+	a string
+}
+
 type actionType int
 
 const (
@@ -186,6 +190,8 @@ const (
 	actUp
 	actPageUp
 	actPageDown
+	actHalfPageUp
+	actHalfPageDown
 	actJump
 	actJumpAccept
 	actPrintQuery
@@ -198,57 +204,66 @@ const (
 	actPreviousHistory
 	actNextHistory
 	actExecute
-	actExecuteMulti
+	actExecuteSilent
+	actExecuteMulti // Deprecated
 )
 
-func defaultKeymap() map[int]actionType {
+func toActions(types ...actionType) []action {
-	keymap := make(map[int]actionType)
+	actions := make([]action, len(types))
-	keymap[tui.Invalid] = actInvalid
+	for idx, t := range types {
-	keymap[tui.Resize] = actClearScreen
+		actions[idx] = action{t: t, a: ""}
-	keymap[tui.CtrlA] = actBeginningOfLine
+	}
-	keymap[tui.CtrlB] = actBackwardChar
+	return actions
-	keymap[tui.CtrlC] = actAbort
+}
-	keymap[tui.CtrlG] = actAbort
-	keymap[tui.CtrlQ] = actAbort
-	keymap[tui.ESC] = actAbort
-	keymap[tui.CtrlD] = actDeleteCharEOF
-	keymap[tui.CtrlE] = actEndOfLine
-	keymap[tui.CtrlF] = actForwardChar
-	keymap[tui.CtrlH] = actBackwardDeleteChar
-	keymap[tui.BSpace] = actBackwardDeleteChar
-	keymap[tui.Tab] = actToggleDown
-	keymap[tui.BTab] = actToggleUp
-	keymap[tui.CtrlJ] = actDown
-	keymap[tui.CtrlK] = actUp
-	keymap[tui.CtrlL] = actClearScreen
-	keymap[tui.CtrlM] = actAccept
-	keymap[tui.CtrlN] = actDown
-	keymap[tui.CtrlP] = actUp
-	keymap[tui.CtrlU] = actUnixLineDiscard
-	keymap[tui.CtrlW] = actUnixWordRubout
-	keymap[tui.CtrlY] = actYank
 
-	keymap[tui.AltB] = actBackwardWord
+func defaultKeymap() map[int][]action {
-	keymap[tui.SLeft] = actBackwardWord
+	keymap := make(map[int][]action)
-	keymap[tui.AltF] = actForwardWord
+	keymap[tui.Invalid] = toActions(actInvalid)
-	keymap[tui.SRight] = actForwardWord
+	keymap[tui.Resize] = toActions(actClearScreen)
-	keymap[tui.AltD] = actKillWord
+	keymap[tui.CtrlA] = toActions(actBeginningOfLine)
-	keymap[tui.AltBS] = actBackwardKillWord
+	keymap[tui.CtrlB] = toActions(actBackwardChar)
+	keymap[tui.CtrlC] = toActions(actAbort)
+	keymap[tui.CtrlG] = toActions(actAbort)
+	keymap[tui.CtrlQ] = toActions(actAbort)
+	keymap[tui.ESC] = toActions(actAbort)
+	keymap[tui.CtrlD] = toActions(actDeleteCharEOF)
+	keymap[tui.CtrlE] = toActions(actEndOfLine)
+	keymap[tui.CtrlF] = toActions(actForwardChar)
+	keymap[tui.CtrlH] = toActions(actBackwardDeleteChar)
+	keymap[tui.BSpace] = toActions(actBackwardDeleteChar)
+	keymap[tui.Tab] = toActions(actToggleDown)
+	keymap[tui.BTab] = toActions(actToggleUp)
+	keymap[tui.CtrlJ] = toActions(actDown)
+	keymap[tui.CtrlK] = toActions(actUp)
+	keymap[tui.CtrlL] = toActions(actClearScreen)
+	keymap[tui.CtrlM] = toActions(actAccept)
+	keymap[tui.CtrlN] = toActions(actDown)
+	keymap[tui.CtrlP] = toActions(actUp)
+	keymap[tui.CtrlU] = toActions(actUnixLineDiscard)
+	keymap[tui.CtrlW] = toActions(actUnixWordRubout)
+	keymap[tui.CtrlY] = toActions(actYank)
 
-	keymap[tui.Up] = actUp
+	keymap[tui.AltB] = toActions(actBackwardWord)
-	keymap[tui.Down] = actDown
+	keymap[tui.SLeft] = toActions(actBackwardWord)
-	keymap[tui.Left] = actBackwardChar
+	keymap[tui.AltF] = toActions(actForwardWord)
-	keymap[tui.Right] = actForwardChar
+	keymap[tui.SRight] = toActions(actForwardWord)
+	keymap[tui.AltD] = toActions(actKillWord)
+	keymap[tui.AltBS] = toActions(actBackwardKillWord)
 
-	keymap[tui.Home] = actBeginningOfLine
+	keymap[tui.Up] = toActions(actUp)
-	keymap[tui.End] = actEndOfLine
+	keymap[tui.Down] = toActions(actDown)
-	keymap[tui.Del] = actDeleteChar
+	keymap[tui.Left] = toActions(actBackwardChar)
-	keymap[tui.PgUp] = actPageUp
+	keymap[tui.Right] = toActions(actForwardChar)
-	keymap[tui.PgDn] = actPageDown
 
-	keymap[tui.Rune] = actRune
+	keymap[tui.Home] = toActions(actBeginningOfLine)
-	keymap[tui.Mouse] = actMouse
+	keymap[tui.End] = toActions(actEndOfLine)
-	keymap[tui.DoubleClick] = actAccept
+	keymap[tui.Del] = toActions(actDeleteChar)
+	keymap[tui.PgUp] = toActions(actPageUp)
+	keymap[tui.PgDn] = toActions(actPageDown)
+
+	keymap[tui.Rune] = toActions(actRune)
+	keymap[tui.Mouse] = toActions(actMouse)
+	keymap[tui.DoubleClick] = toActions(actAccept)
 	return keymap
 }
 
@@ -291,8 +306,11 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 			return util.Max(maxHeight, minHeight)
 		}
 		renderer = tui.NewLightRenderer(opts.Theme, opts.Black, opts.Mouse, opts.Tabstop, maxHeightFunc)
-	} else {
+	} else if tui.HasFullscreenRenderer() {
 		renderer = tui.NewFullscreenRenderer(opts.Theme, opts.Black, opts.Mouse)
+	} else {
+		renderer = tui.NewLightRenderer(opts.Theme, opts.Black, opts.Mouse, opts.Tabstop,
+			func(h int) int { return h })
 	}
 	wordRubout := "[^[:alnum:]][[:alnum:]]"
 	wordNext := "[[:alnum:]][^[:alnum:]]|(.$)"
@@ -321,7 +339,6 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		delimiter:  opts.Delimiter,
 		expect:     opts.Expect,
 		keymap:     opts.Keymap,
-		execmap:    opts.Execmap,
 		pressed:    "",
 		printQuery: opts.PrintQuery,
 		history:    opts.History,
@@ -420,9 +437,9 @@ func (t *Terminal) output() bool {
 	}
 	found := len(t.selected) > 0
 	if !found {
-		cnt := t.merger.Length()
+		current := t.currentItem()
-		if cnt > 0 && cnt > t.cy {
+		if current != nil {
-			t.printer(t.current())
+			t.printer(current.AsString(t.ansi))
 			found = true
 		}
 	} else {
@@ -493,9 +510,11 @@ func (t *Terminal) resizeWindows() {
 			}
 		}
 	}
+
+	previewVisible := t.isPreviewEnabled() && t.preview.size.size > 0
 	minAreaWidth := minWidth
 	minAreaHeight := minHeight
-	if t.isPreviewEnabled() {
+	if previewVisible {
 		switch t.preview.position {
 		case posUp, posDown:
 			minAreaHeight *= 2
@@ -515,7 +534,7 @@ func (t *Terminal) resizeWindows() {
 
 	width := screenWidth - marginInt[1] - marginInt[3]
 	height := screenHeight - marginInt[0] - marginInt[2]
-	if t.isPreviewEnabled() {
+	if previewVisible {
 		createPreviewWindow := func(y int, x int, w int, h int) {
 			t.bwindow = t.tui.NewWindow(y, x, w, h, true)
 			pwidth := w - 4
@@ -556,6 +575,11 @@ func (t *Terminal) resizeWindows() {
 			width,
 			height, false)
 	}
+	if !t.tui.IsOptimized() && t.theme != nil && t.theme.HasBg() {
+		for i := 0; i < t.window.Height(); i++ {
+			t.window.MoveAndClear(i, 0)
+		}
+	}
 }
 
 func (t *Terminal) move(y int, x int, clear bool) {
@@ -824,6 +848,7 @@ func (t *Terminal) printHighlighted(result *Result, attr tui.Attr, col1 tui.Colo
 				offsets[idx].offset[1] = util.Min32(offset.offset[1], int32(maxWidth))
 			}
 		}
+		displayWidth = t.displayWidthWithLimit(text, 0, displayWidth)
 	}
 
 	var index int32
@@ -868,7 +893,7 @@ func numLinesMax(str string, max int) int {
 }
 
 func (t *Terminal) printPreview() {
-	if !t.isPreviewEnabled() {
+	if !t.hasPreviewWindow() {
 		return
 	}
 	t.pwindow.Erase()
@@ -953,7 +978,7 @@ func (t *Terminal) printAll() {
 
 func (t *Terminal) refresh() {
 	if !t.suppress {
-		if t.isPreviewEnabled() {
+		if t.hasPreviewWindow() {
 			t.tui.RefreshWindows([]tui.Window{t.bwindow, t.pwindow, t.window})
 		} else {
 			t.tui.RefreshWindows([]tui.Window{t.window})
@@ -1020,7 +1045,27 @@ func quoteEntry(entry string) string {
 	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
 }
 
-func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, query string, items []*Item) string {
+func hasPlusFlag(template string) bool {
+	for _, match := range placeholder.FindAllString(template, -1) {
+		if match[0] == '\\' {
+			continue
+		}
+		if match[1] == '+' {
+			return true
+		}
+	}
+	return false
+}
+
+func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, forcePlus bool, query string, allItems []*Item) string {
+	current := allItems[:1]
+	selected := allItems[1:]
+	if current[0] == nil {
+		current = []*Item{}
+	}
+	if selected[0] == nil {
+		selected = []*Item{}
+	}
 	return placeholder.ReplaceAllStringFunc(template, func(match string) string {
 		// Escaped pattern
 		if match[0] == '\\' {
@@ -1032,6 +1077,16 @@ func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, qu
 			return quoteEntry(query)
 		}
 
+		plusFlag := forcePlus
+		if match[1] == '+' {
+			match = "{" + match[2:]
+			plusFlag = true
+		}
+		items := current
+		if plusFlag {
+			items = selected
+		}
+
 		replacements := make([]string, len(items))
 
 		if match == "{}" {
@@ -1072,34 +1127,60 @@ func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, qu
 	})
 }
 
-func (t *Terminal) executeCommand(template string, items []*Item) {
+func (t *Terminal) executeCommand(template string, forcePlus bool, background bool) {
-	command := replacePlaceholder(template, t.ansi, t.delimiter, string(t.input), items)
+	valid, list := t.buildPlusList(template, forcePlus)
+	if !valid {
+		return
+	}
+	command := replacePlaceholder(template, t.ansi, t.delimiter, forcePlus, string(t.input), list)
 	cmd := util.ExecCommand(command)
+	if !background {
 		cmd.Stdin = os.Stdin
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		t.tui.Pause()
 		cmd.Run()
 		if t.tui.Resume() {
+			t.tui.Clear()
 			t.printAll()
 		}
 		t.refresh()
+	} else {
+		cmd.Run()
+	}
 }
 
-func (t *Terminal) hasPreviewWindow() bool {
+func (t *Terminal) hasPreviewer() bool {
 	return t.previewBox != nil
 }
 
 func (t *Terminal) isPreviewEnabled() bool {
-	return t.previewBox != nil && t.previewer.enabled
+	return t.hasPreviewer() && t.previewer.enabled
+}
+
+func (t *Terminal) hasPreviewWindow() bool {
+	return t.pwindow != nil && t.isPreviewEnabled()
 }
 
 func (t *Terminal) currentItem() *Item {
+	cnt := t.merger.Length()
+	if cnt > 0 && cnt > t.cy {
 		return t.merger.Get(t.cy).item
 	}
+	return nil
+}
 
-func (t *Terminal) current() string {
+func (t *Terminal) buildPlusList(template string, forcePlus bool) (bool, []*Item) {
-	return t.currentItem().AsString(t.ansi)
+	current := t.currentItem()
+	if !forcePlus && !hasPlusFlag(template) || len(t.selected) == 0 {
+		return current != nil, []*Item{current, current}
+	}
+	sels := make([]*Item, len(t.selected)+1)
+	sels[0] = current
+	for i, sel := range t.sortSelected() {
+		sels[i+1] = sel.item
+	}
+	return true, sels
 }
 
 // Loop is called to start Terminal I/O
@@ -1153,22 +1234,23 @@ func (t *Terminal) Loop() {
 		}()
 	}
 
-	if t.hasPreviewWindow() {
+	if t.hasPreviewer() {
 		go func() {
 			for {
-				var request *Item
+				var request []*Item
 				t.previewBox.Wait(func(events *util.Events) {
 					for req, value := range *events {
 						switch req {
 						case reqPreviewEnqueue:
-							request = value.(*Item)
+							request = value.([]*Item)
 						}
 					}
 					events.Clear()
 				})
-				if request != nil {
+				// We don't display preview window if no match
+				if request[0] != nil {
 					command := replacePlaceholder(t.preview.command,
-						t.ansi, t.delimiter, string(t.input), []*Item{request})
+						t.ansi, t.delimiter, false, string(t.input), request)
 					cmd := util.ExecCommand(command)
 					out, _ := cmd.CombinedOutput()
 					t.reqBox.Set(reqPreviewDisplay, string(out))
@@ -1204,17 +1286,12 @@ func (t *Terminal) Loop() {
 						t.printInfo()
 					case reqList:
 						t.printList()
-						cnt := t.merger.Length()
+						currentFocus := t.currentItem()
-						var currentFocus *Item
-						if cnt > 0 && cnt > t.cy {
-							currentFocus = t.currentItem()
-						} else {
-							currentFocus = nil
-						}
 						if currentFocus != focused {
 							focused = currentFocus
 							if t.isPreviewEnabled() {
-								t.previewBox.Set(reqPreviewEnqueue, focused)
+								_, list := t.buildPlusList(t.preview.command, false)
+								t.previewBox.Set(reqPreviewEnqueue, list)
 							}
 						}
 					case reqJump:
@@ -1307,34 +1384,35 @@ func (t *Terminal) Loop() {
 			}
 		}
 
-		var doAction func(actionType, int) bool
+		var doAction func(action, int) bool
-		doAction = func(action actionType, mapkey int) bool {
+		doActions := func(actions []action, mapkey int) bool {
-			switch action {
+			for _, action := range actions {
+				if !doAction(action, mapkey) {
+					return false
+				}
+			}
+			return true
+		}
+		doAction = func(a action, mapkey int) bool {
+			switch a.t {
 			case actIgnore:
-			case actExecute:
+			case actExecute, actExecuteSilent:
-				if t.cy >= 0 && t.cy < t.merger.Length() {
+				t.executeCommand(a.a, false, a.t == actExecuteSilent)
-					t.executeCommand(t.execmap[mapkey], []*Item{t.currentItem()})
-				}
 			case actExecuteMulti:
-				if len(t.selected) > 0 {
+				t.executeCommand(a.a, true, false)
-					sels := make([]*Item, len(t.selected))
-					for i, sel := range t.sortSelected() {
-						sels[i] = sel.item
-					}
-					t.executeCommand(t.execmap[mapkey], sels)
-				} else {
-					return doAction(actExecute, mapkey)
-				}
 			case actInvalid:
 				t.mutex.Unlock()
 				return false
 			case actTogglePreview:
-				if t.hasPreviewWindow() {
+				if t.hasPreviewer() {
 					t.previewer.enabled = !t.previewer.enabled
+					t.tui.Clear()
 					t.resizeWindows()
-					cnt := t.merger.Length()
+					if t.previewer.enabled {
-					if t.previewer.enabled && cnt > 0 && cnt > t.cy {
+						valid, list := t.buildPlusList(t.preview.command, false)
-						t.previewBox.Set(reqPreviewEnqueue, t.currentItem())
+						if valid {
+							t.previewBox.Set(reqPreviewEnqueue, list)
+						}
 					}
 					req(reqList, reqInfo, reqHeader)
 				}
@@ -1344,19 +1422,19 @@ func (t *Terminal) Loop() {
 				t.mutex.Unlock()
 				return false
 			case actPreviewUp:
-				if t.isPreviewEnabled() {
+				if t.hasPreviewWindow() {
 					scrollPreview(-1)
 				}
 			case actPreviewDown:
-				if t.isPreviewEnabled() {
+				if t.hasPreviewWindow() {
 					scrollPreview(1)
 				}
 			case actPreviewPageUp:
-				if t.isPreviewEnabled() {
+				if t.hasPreviewWindow() {
 					scrollPreview(-t.pwindow.Height())
 				}
 			case actPreviewPageDown:
-				if t.isPreviewEnabled() {
+				if t.hasPreviewWindow() {
 					scrollPreview(t.pwindow.Height())
 				}
 			case actBeginningOfLine:
@@ -1424,14 +1502,14 @@ func (t *Terminal) Loop() {
 				}
 			case actToggleIn:
 				if t.reverse {
-					return doAction(actToggleUp, mapkey)
+					return doAction(action{t: actToggleUp}, mapkey)
 				}
-				return doAction(actToggleDown, mapkey)
+				return doAction(action{t: actToggleDown}, mapkey)
 			case actToggleOut:
 				if t.reverse {
-					return doAction(actToggleDown, mapkey)
+					return doAction(action{t: actToggleDown}, mapkey)
 				}
-				return doAction(actToggleUp, mapkey)
+				return doAction(action{t: actToggleUp}, mapkey)
 			case actToggleDown:
 				if t.multi && t.merger.Length() > 0 {
 					toggle()
@@ -1478,6 +1556,12 @@ func (t *Terminal) Loop() {
 			case actPageDown:
 				t.vmove(-(t.maxItems() - 1))
 				req(reqList)
+			case actHalfPageUp:
+				t.vmove(t.maxItems() / 2)
+				req(reqList)
+			case actHalfPageDown:
+				t.vmove(-(t.maxItems() / 2))
+				req(reqList)
 			case actJump:
 				t.jumping = jumpEnabled
 				req(reqJump)
@@ -1527,7 +1611,7 @@ func (t *Terminal) Loop() {
 						}
 						t.vmove(me.S)
 						req(reqList)
-					} else if t.isPreviewEnabled() && t.pwindow.Enclose(my, mx) {
+					} else if t.hasPreviewWindow() && t.pwindow.Enclose(my, mx) {
 						scrollPreview(-me.S)
 					}
 				} else if t.window.Enclose(my, mx) {
@@ -1545,7 +1629,7 @@ func (t *Terminal) Loop() {
 						// Double-click
 						if my >= min {
 							if t.vset(t.offset+my-min) && t.cy < t.merger.Length() {
-								return doAction(t.keymap[tui.DoubleClick], tui.DoubleClick)
+								return doActions(t.keymap[tui.DoubleClick], tui.DoubleClick)
 							}
 						}
 					} else if me.Down {
@@ -1567,14 +1651,14 @@ func (t *Terminal) Loop() {
 		changed := false
 		mapkey := event.Type
 		if t.jumping == jumpDisabled {
-			action := t.keymap[mapkey]
+			actions := t.keymap[mapkey]
 			if mapkey == tui.Rune {
 				mapkey = int(event.Char) + int(tui.AltZ)
 				if act, prs := t.keymap[mapkey]; prs {
-					action = act
+					actions = act
 				}
 			}
-			if !doAction(action, mapkey) {
+			if !doActions(actions, mapkey) {
 				continue
 			}
 			// Truncate the query if it's too long

src/terminal_test.go

@@ -14,8 +14,10 @@ func newItem(str string) *Item {
 }
 
 func TestReplacePlaceholder(t *testing.T) {
-	items1 := []*Item{newItem("  foo'bar \x1b[31mbaz\x1b[m")}
+	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
+	items1 := []*Item{item1, item1}
 	items2 := []*Item{
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
 		newItem("foo'bar \x1b[31mbaz\x1b[m"),
 		newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}
 
@@ -27,47 +29,65 @@ func TestReplacePlaceholder(t *testing.T) {
 	}
 
 	// {}, preserve ansi
-	result = replacePlaceholder("echo {}", false, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {}", false, Delimiter{}, false, "query", items1)
 	check("echo '  foo'\\''bar \x1b[31mbaz\x1b[m'")
 
 	// {}, strip ansi
-	result = replacePlaceholder("echo {}", true, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, false, "query", items1)
 	check("echo '  foo'\\''bar baz'")
 
 	// {}, with multiple items
-	result = replacePlaceholder("echo {}", true, Delimiter{}, "query", items2)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, false, "query", items2)
-	check("echo 'foo'\\''bar baz' 'FOO'\\''BAR BAZ'")
+	check("echo 'foo'\\''bar baz'")
 
 	// {..}, strip leading whitespaces, preserve ansi
-	result = replacePlaceholder("echo {..}", false, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, false, "query", items1)
 	check("echo 'foo'\\''bar \x1b[31mbaz\x1b[m'")
 
 	// {..}, strip leading whitespaces, strip ansi
-	result = replacePlaceholder("echo {..}", true, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, false, "query", items1)
 	check("echo 'foo'\\''bar baz'")
 
 	// {q}
-	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, false, "query", items1)
 	check("echo '  foo'\\''bar baz' 'query'")
 
 	// {q}, multiple items
-	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, "query 'string'", items2)
+	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, false, "query 'string'", items2)
 	check("echo 'foo'\\''bar baz' 'FOO'\\''BAR BAZ''query '\\''string'\\''''foo'\\''bar baz' 'FOO'\\''BAR BAZ'")
 
-	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, "query", items1)
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, false, "query 'string'", items2)
+	check("echo 'foo'\\''bar baz''query '\\''string'\\''''foo'\\''bar baz'")
+
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, false, "query", items1)
 	check("echo 'foo'\\''bar'/'baz'/'bazfoo'\\''bar'/'baz'/'foo'\\''bar'/'  foo'\\''bar baz'/'foo'\\''bar baz'/{n.t}/{}/{1}/{q}/''")
 
-	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, false, "query", items2)
+	check("echo 'foo'\\''bar'/'baz'/'baz'/'foo'\\''bar'/'foo'\\''bar baz'/{n.t}/{}/{1}/{q}/''")
+
+	result = replacePlaceholder("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, false, "query", items2)
 	check("echo 'foo'\\''bar' 'FOO'\\''BAR'/'baz' 'BAZ'/'baz' 'BAZ'/'foo'\\''bar' 'FOO'\\''BAR'/'foo'\\''bar baz' 'FOO'\\''BAR BAZ'/{n.t}/{}/{1}/{q}/'' ''")
 
+	// forcePlus
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, true, "query", items2)
+	check("echo 'foo'\\''bar' 'FOO'\\''BAR'/'baz' 'BAZ'/'baz' 'BAZ'/'foo'\\''bar' 'FOO'\\''BAR'/'foo'\\''bar baz' 'FOO'\\''BAR BAZ'/{n.t}/{}/{1}/{q}/'' ''")
+
+	// No match
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, false, "query", []*Item{nil, nil})
+	check("echo /")
+
+	// No match, but with selections
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, false, "query", []*Item{nil, item1})
+	check("echo /'  foo'\\''bar baz'")
+
 	// String delimiter
 	delim := "'"
-	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, false, "query", items1)
 	check("echo '  foo'\\''bar baz'/'foo'/'bar baz'")
 
 	// Regex delimiter
 	regex := regexp.MustCompile("[oa]+")
 	// foo'bar baz
-	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, false, "query", items1)
 	check("echo '  foo'\\''bar baz'/'f'/'r b'/''\\''bar b'")
 }

src/tui/dummy.go

@@ -0,0 +1,45 @@
+// +build !ncurses
+// +build !tcell
+// +build !windows
+
+package tui
+
+type Attr int
+
+func HasFullscreenRenderer() bool {
+	return false
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+const (
+	AttrRegular Attr = Attr(0)
+	Bold             = Attr(1)
+	Dim              = Attr(1 << 1)
+	Italic           = Attr(1 << 2)
+	Underline        = Attr(1 << 3)
+	Blink            = Attr(1 << 4)
+	Blink2           = Attr(1 << 5)
+	Reverse          = Attr(1 << 6)
+)
+
+func (r *FullscreenRenderer) Init()    {}
+func (r *FullscreenRenderer) Pause()   {}
+func (r *FullscreenRenderer) Clear()   {}
+func (r *FullscreenRenderer) Refresh() {}
+func (r *FullscreenRenderer) Close()   {}
+
+func (r *FullscreenRenderer) Resume() bool       { return false }
+func (r *FullscreenRenderer) DoesAutoWrap() bool { return false }
+func (r *FullscreenRenderer) IsOptimized() bool  { return false }
+func (r *FullscreenRenderer) GetChar() Event     { return Event{} }
+func (r *FullscreenRenderer) MaxX() int          { return 0 }
+func (r *FullscreenRenderer) MaxY() int          { return 0 }
+
+func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}
+
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, border bool) Window {
+	return nil
+}

src/tui/light.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"regexp"
 	"strconv"
 	"strings"
 	"syscall"
@@ -19,11 +20,15 @@ const (
 	defaultWidth  = 80
 	defaultHeight = 24
 
+	defaultEscDelay = 100
 	escPollInterval = 5
+	offsetPollTries = 10
 )
 
 const consoleDevice string = "/dev/tty"
 
+var offsetRegexp *regexp.Regexp = regexp.MustCompile("\x1b\\[([0-9]+);([0-9]+)R")
+
 func openTtyIn() *os.File {
 	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
 	if err != nil {
@@ -79,6 +84,7 @@ type LightRenderer struct {
 	yoffset       int
 	tabstop       int
 	escDelay      int
+	fullscreen    bool
 	upOneLine     bool
 	queued        string
 	y             int
@@ -106,8 +112,9 @@ func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop in
 		forceBlack:    forceBlack,
 		mouse:         mouse,
 		ttyin:         openTtyIn(),
-		yoffset:       -1,
+		yoffset:       0,
 		tabstop:       tabstop,
+		fullscreen:    false,
 		upOneLine:     false,
 		maxHeightFunc: maxHeightFunc}
 	return &r
@@ -131,18 +138,14 @@ func (r *LightRenderer) defaultTheme() *ColorTheme {
 func (r *LightRenderer) findOffset() (row int, col int) {
 	r.csi("6n")
 	r.flush()
-	bytes := r.getBytesInternal([]byte{})
+	bytes := []byte{}
-
+	for tries := 0; tries < offsetPollTries; tries++ {
-	// ^[[*;*R
+		bytes = r.getBytesInternal(bytes, tries > 0)
-	if len(bytes) > 5 && bytes[0] == 27 && bytes[1] == 91 && bytes[len(bytes)-1] == 'R' {
+		offsets := offsetRegexp.FindSubmatch(bytes)
-		nums := strings.Split(string(bytes[2:len(bytes)-1]), ";")
+		if len(offsets) > 2 {
-		if len(nums) == 2 {
+			return atoi(string(offsets[1]), 0) - 1, atoi(string(offsets[2]), 0) - 1
-			return atoi(nums[0], 0) - 1, atoi(nums[1], 0) - 1
 		}
-		return -1, -1
 	}
-
-	// No idea
 	return -1, -1
 }
 
@@ -162,15 +165,7 @@ func atoi(s string, defaultValue int) int {
 }
 
 func (r *LightRenderer) Init() {
-	delay := 100
+	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)
-	delayEnv := os.Getenv("ESCDELAY")
-	if len(delayEnv) > 0 {
-		num, err := strconv.Atoi(delayEnv)
-		if err == nil && num >= 0 {
-			delay = num
-		}
-	}
-	r.escDelay = delay
 
 	fd := r.fd()
 	origState, err := terminal.GetState(fd)
@@ -179,17 +174,26 @@ func (r *LightRenderer) Init() {
 	}
 	r.origState = origState
 	terminal.MakeRaw(fd)
-	r.updateTerminalSize()
+	terminalHeight, capHeight := r.updateTerminalSize()
+	if capHeight == terminalHeight {
+		r.fullscreen = true
+		r.height = terminalHeight
+	}
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
 
-	_, x := r.findOffset()
+	if r.fullscreen {
+		r.smcup()
+	} else {
+		r.csi("J")
+		y, x := r.findOffset()
+		r.mouse = r.mouse && y >= 0
 		if x > 0 {
 			r.upOneLine = true
-		r.stderr("\n")
+			r.makeSpace()
 		}
 		for i := 1; i < r.MaxY(); i++ {
-		r.stderr("\n")
+			r.makeSpace()
-		r.csi("G")
+		}
 	}
 
 	if r.mouse {
@@ -197,12 +201,18 @@ func (r *LightRenderer) Init() {
 	}
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
+	r.csi("K")
 	// r.csi("s")
-	if r.mouse {
+	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
 }
 
+func (r *LightRenderer) makeSpace() {
+	r.stderr("\n")
+	r.csi("G")
+}
+
 func (r *LightRenderer) move(y int, x int) {
 	// w.csi("u")
 	if r.y < y {
@@ -230,15 +240,20 @@ func getEnv(name string, defaultValue int) int {
 	return atoi(env, defaultValue)
 }
 
-func (r *LightRenderer) updateTerminalSize() {
+func (r *LightRenderer) updateTerminalSize() (int, int) {
 	width, height, err := terminal.GetSize(r.fd())
 	if err == nil {
 		r.width = width
+		if r.fullscreen {
+			r.height = height
+		} else {
 			r.height = r.maxHeightFunc(height)
+		}
 	} else {
 		r.width = getEnv("COLUMNS", defaultWidth)
 		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
 	}
+	return height, r.height
 }
 
 func (r *LightRenderer) getch(nonblock bool) (int, bool) {
@@ -252,18 +267,18 @@ func (r *LightRenderer) getch(nonblock bool) (int, bool) {
 }
 
 func (r *LightRenderer) getBytes() []byte {
-	return r.getBytesInternal(r.buffer)
+	return r.getBytesInternal(r.buffer, false)
 }
 
-func (r *LightRenderer) getBytesInternal(buffer []byte) []byte {
+func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
-	c, ok := r.getch(false)
+	c, ok := r.getch(nonblock)
-	if !ok {
+	if !nonblock && !ok {
 		r.Close()
 		errorExit("Failed to read " + consoleDevice)
 	}
 
 	retries := 0
-	if c == ESC {
+	if c == ESC || nonblock {
 		retries = r.escDelay / escPollInterval
 	}
 	buffer = append(buffer, byte(c))
@@ -307,6 +322,8 @@ func (r *LightRenderer) GetChar() Event {
 		return Event{CtrlQ, 0, nil}
 	case 127:
 		return Event{BSpace, 0, nil}
+	case 0:
+		return Event{CtrlSpace, 0, nil}
 	case ESC:
 		ev := r.escSequence(&sz)
 		// Second chance
@@ -464,7 +481,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 }
 
 func (r *LightRenderer) mouseSequence(sz *int) Event {
-	if len(r.buffer) < 6 || r.yoffset < 0 {
+	if len(r.buffer) < 6 || !r.mouse {
 		return Event{Invalid, 0, nil}
 	}
 	*sz = 6
@@ -503,15 +520,32 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {
 	return Event{Invalid, 0, nil}
 }
 
+func (r *LightRenderer) smcup() {
+	r.csi("?1049h")
+}
+
+func (r *LightRenderer) rmcup() {
+	r.csi("?1049l")
+}
+
 func (r *LightRenderer) Pause() {
 	terminal.Restore(r.fd(), r.origState)
-	r.csi("?1049h")
+	if r.fullscreen {
+		r.rmcup()
+	} else {
+		r.smcup()
+		r.csi("H")
+	}
 	r.flush()
 }
 
 func (r *LightRenderer) Resume() bool {
 	terminal.MakeRaw(r.fd())
-	r.csi("?1049l")
+	if r.fullscreen {
+		r.smcup()
+	} else {
+		r.rmcup()
+	}
 	r.flush()
 	// Should redraw
 	return true
@@ -534,14 +568,18 @@ func (r *LightRenderer) Refresh() {
 
 func (r *LightRenderer) Close() {
 	// r.csi("u")
+	if r.fullscreen {
+		r.rmcup()
+	} else {
 		r.origin()
-	r.csi("J")
-	if r.mouse {
-		r.csi("?1000l")
-	}
 		if r.upOneLine {
 			r.csi("A")
 		}
+		r.csi("J")
+	}
+	if r.mouse {
+		r.csi("?1000l")
+	}
 	r.flush()
 	terminal.Restore(r.fd(), r.origState)
 }

src/tui/ncurses.go

@@ -1,3 +1,4 @@
+// +build ncurses
 // +build !windows
 // +build !tcell
 
@@ -32,6 +33,10 @@ import (
 	"unicode/utf8"
 )
 
+func HasFullscreenRenderer() bool {
+	return true
+}
+
 type Attr C.uint
 
 type CursesWindow struct {
@@ -470,6 +475,8 @@ func (r *FullscreenRenderer) GetChar() Event {
 		return escSequence()
 	case 127:
 		return Event{BSpace, 0, nil}
+	case 0:
+		return Event{CtrlSpace, 0, nil}
 	}
 	// CTRL-A ~ CTRL-Z
 	if c >= CtrlA && c <= CtrlZ {

src/tui/tcell.go

@@ -15,6 +15,10 @@ import (
 	"github.com/junegunn/go-runewidth"
 )
 
+func HasFullscreenRenderer() bool {
+	return true
+}
+
 func (p ColorPair) style() tcell.Style {
 	style := tcell.StyleDefault
 	return style.Foreground(tcell.Color(p.Fg())).Background(tcell.Color(p.Bg()))
@@ -266,6 +270,8 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{CtrlY, 0, nil}
 		case tcell.KeyCtrlZ:
 			return Event{CtrlZ, 0, nil}
+		case tcell.KeyCtrlSpace:
+			return Event{CtrlSpace, 0, nil}
 		case tcell.KeyBackspace, tcell.KeyBackspace2:
 			if alt {
 				return Event{AltBS, 0, nil}

src/tui/tui.go

@@ -38,6 +38,7 @@ const (
 	CtrlY
 	CtrlZ
 	ESC
+	CtrlSpace
 
 	Invalid
 	Resize
@@ -175,6 +176,10 @@ type ColorTheme struct {
 	Border       Color
 }
 
+func (t *ColorTheme) HasBg() bool {
+	return t.Bg != colDefault
+}
+
 type Event struct {
 	Type       int
 	Char       rune

src/update_assets.rb

@@ -23,7 +23,8 @@ end
 # List assets
 assets = Hash[rel['assets'].map { |a| a.values_at *%w[name id] }]
 
-files.select { |f| File.exists? f }.each do |file|
+files.select { |f| File.exists? f }.map do |file|
+  Thread.new do
     name = File.basename file
 
     if asset_id = assets[name]
@@ -41,3 +42,4 @@ files.select { |f| File.exists? f }.each do |file|
       :authorization => "token #{token}",
       :content_type  => "application/octet-stream")
   end
+end.each(&:join)

test/test_go.rb

@@ -111,7 +111,7 @@ class Tmux
     File.read(TEMPNAME).split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
   end
 
-  def until pane = 0
+  def until refresh = false, pane = 0
     lines = nil
     begin
       wait do
@@ -141,7 +141,9 @@ class Tmux
             self.select { |line| line.send method, val }.first
           end
         end
-        yield lines
+        yield(lines).tap do |ok|
+          send_keys 'C-l' if refresh && !ok
+        end
       end
     rescue Exception
       puts $!.backtrace
@@ -877,7 +879,7 @@ class TestGoFZF < TestBase
 
   def test_execute_multi
     output = '/tmp/fzf-test-execute-multi'
-    opts = %[--multi --bind \\"alt-a:execute-multi(echo {}/{} >> #{output}; sync)\\"]
+    opts = %[--multi --bind \\"alt-a:execute-multi(echo {}/{+} >> #{output}; sync)\\"]
     writelines tempname, %w[foo'bar foo"bar foo$bar foobar]
     tmux.send_keys "cat #{tempname} | #{fzf opts}", :Enter
     tmux.until { |lines| lines[-2].include? '4/4' }
@@ -900,6 +902,43 @@ class TestGoFZF < TestBase
     File.unlink output rescue nil
   end
 
+  def test_execute_plus_flag
+    output = tempname + ".tmp"
+    File.unlink output rescue nil
+    writelines tempname, ["foo bar", "123 456"]
+
+    tmux.send_keys "cat #{tempname} | #{FZF} --multi --bind 'x:execute(echo {+}/{}/{+2}/{2} >> #{output})'", :Enter
+
+    execute = lambda do
+      tmux.send_keys 'x', 'y'
+      tmux.until { |lines| lines[-2].include? '0/2' }
+      tmux.send_keys :BSpace
+      tmux.until { |lines| lines[-2].include? '2/2' }
+    end
+
+    tmux.until { |lines| lines[-2].include? '2/2' }
+    execute.call
+
+    tmux.send_keys :Up
+    tmux.send_keys :Tab
+    execute.call
+
+    tmux.send_keys :Tab
+    execute.call
+
+    tmux.send_keys :Enter
+    tmux.prepare
+    readonce
+
+    assert_equal [
+      %[foo bar/foo bar/bar/bar],
+      %[123 456/foo bar/456/bar],
+      %[123 456 foo bar/foo bar/456 bar/bar]
+    ], File.readlines(output).map(&:chomp)
+  rescue
+    File.unlink output rescue nil
+  end
+
   def test_execute_shell
     # Custom script to use as $SHELL
     output = tempname + '.out'
@@ -1067,7 +1106,7 @@ class TestGoFZF < TestBase
     }.each do |ts, exp|
       tmux.prepare
       tmux.send_keys %[cat #{tempname} | fzf --tabstop=#{ts}], :Enter
-      tmux.until { |lines| exp.start_with? lines[-3].to_s.strip.sub(/\.\.$/, '') }
+      tmux.until(true) { |lines| exp.start_with? lines[-3].to_s.strip.sub(/\.\.$/, '') }
       tmux.send_keys :Enter
     end
   end
@@ -1093,12 +1132,6 @@ class TestGoFZF < TestBase
     assert_equal 1, $?.exitstatus
   end
 
-  def test_invalid_term
-    lines = `TERM=xxx #{FZF} 2>&1`
-    assert_equal 2, $?.exitstatus
-    assert lines.include?('Invalid $TERM: xxx') || lines.include?('terminal entry not found')
-  end
-
   def test_invalid_option
     lines = `#{FZF} --foobar 2>&1`
     assert_equal 2, $?.exitstatus
@@ -1202,7 +1235,7 @@ class TestGoFZF < TestBase
   end
 
   def test_preview
-    tmux.send_keys %[seq 1000 | sed s/^2$// | #{FZF} --preview 'sleep 0.2; echo {{}-{}}' --bind ?:toggle-preview], :Enter
+    tmux.send_keys %[seq 1000 | sed s/^2$// | #{FZF} -m --preview 'sleep 0.2; echo {{}-{+}}' --bind ?:toggle-preview], :Enter
     tmux.until { |lines| lines[1].include?(' {1-1}') }
     tmux.send_keys :Up
     tmux.until { |lines| lines[1].include?(' {-}') }
@@ -1216,6 +1249,17 @@ class TestGoFZF < TestBase
     tmux.until { |lines| lines[-2].start_with? '  28/1000' }
     tmux.send_keys 'foobar'
     tmux.until { |lines| !lines[1].include?('{') }
+    tmux.send_keys 'C-u'
+    tmux.until { |lines| lines.match_count == 1000 }
+    tmux.until { |lines| lines[1].include?(' {1-1}') }
+    tmux.send_keys :BTab
+    tmux.until { |lines| lines[1].include?(' {-1}') }
+    tmux.send_keys :BTab
+    tmux.until { |lines| lines[1].include?(' {3-1 }') }
+    tmux.send_keys :BTab
+    tmux.until { |lines| lines[1].include?(' {4-1  3}') }
+    tmux.send_keys :BTab
+    tmux.until { |lines| lines[1].include?(' {5-1  3 4}') }
   end
 
   def test_preview_hidden
@@ -1228,6 +1272,19 @@ class TestGoFZF < TestBase
     tmux.send_keys '?'
     tmux.until { |lines| lines[-1] == '> 555' }
   end
+
+  def test_preview_size_0
+    File.unlink tempname rescue nil
+    tmux.send_keys %[seq 100 | #{FZF} --reverse --preview 'echo {} >> #{tempname}; echo ' --preview-window 0], :Enter
+    tmux.until { |lines| lines.item_count == 100 && lines[1] == '  100/100' && lines[2] == '> 1' }
+    tmux.until { |_|  %w[1] == File.readlines(tempname).map(&:chomp) }
+    tmux.send_keys :Down
+    tmux.until { |lines| lines[3] == '> 2' }
+    tmux.until { |_|  %w[1 2] == File.readlines(tempname).map(&:chomp) }
+    tmux.send_keys :Down
+    tmux.until { |lines| lines[4] == '> 3' }
+    tmux.until { |_|  %w[1 2 3] == File.readlines(tempname).map(&:chomp) }
+  end
 end
 
 module TestShell
@@ -1375,8 +1432,7 @@ module CompletionTest
     tmux.send_keys :Tab, :Tab
     tmux.until { |lines| lines.select_count == 2 }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) do |lines|
-      tmux.send_keys 'C-L'
       lines[-1].include?('/tmp/fzf-test/10') &&
       lines[-1].include?('/tmp/fzf-test/100')
     end
@@ -1388,20 +1444,16 @@ module CompletionTest
     tmux.send_keys "'.fzf-home"
     tmux.until { |lines| lines.select { |l| l.include? '.fzf-home' }.count > 1 }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) do |lines|
-      tmux.send_keys 'C-L'
       lines[-1].end_with?('.fzf-home')
     end
 
     # ~INVALID_USERNAME**<TAB>
     tmux.send_keys 'C-u'
     tmux.send_keys "cat ~such**", :Tab
-    tmux.until { |lines| lines.any_include? 'no~such~user' }
+    tmux.until(true) { |lines| lines.any_include? 'no~such~user' }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines[-1].end_with?('no~such~user') }
-      tmux.send_keys 'C-L'
-      lines[-1].end_with?('no~such~user')
-    end
 
     # /tmp/fzf\ test**<TAB>
     tmux.send_keys 'C-u'
@@ -1410,19 +1462,13 @@ module CompletionTest
     tmux.send_keys 'foobar$'
     tmux.until { |lines| lines.match_count == 1 }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines[-1].end_with?('/tmp/fzf\ test/foobar') }
-      tmux.send_keys 'C-L'
-      lines[-1].end_with?('/tmp/fzf\ test/foobar')
-    end
 
     # Should include hidden files
     (1..100).each { |i| FileUtils.touch "/tmp/fzf-test/.hidden-#{i}" }
     tmux.send_keys 'C-u'
     tmux.send_keys 'cat /tmp/fzf-test/hidden**', :Tab
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines.match_count == 100 && lines.any_include?('/tmp/fzf-test/.hidden-') }
-      tmux.send_keys 'C-L'
-      lines.match_count == 100 && lines.any_include?('/tmp/fzf-test/.hidden-')
-    end
     tmux.send_keys :Enter
   ensure
     ['/tmp/fzf-test', '/tmp/fzf test', '~/.fzf-home', 'no~such~user'].each do |f|
@@ -1448,10 +1494,7 @@ module CompletionTest
     tmux.send_keys 55
     tmux.until { |lines| lines.match_count == 1 }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' }
-      tmux.send_keys 'C-L'
-      lines[-1] == 'cd /tmp/fzf-test/d55/'
-    end
     tmux.send_keys :xx
     tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
 
@@ -1479,10 +1522,7 @@ module CompletionTest
     tmux.send_keys 'sleep12345'
     tmux.until { |lines| lines.any_include? 'sleep 12345' }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines[-1].include? "kill #{pid}" }
-      tmux.send_keys 'C-L'
-      lines[-1].include? "kill #{pid}"
-    end
   ensure
     Process.kill 'KILL', pid.to_i rescue nil if pid
   end
@@ -1495,10 +1535,7 @@ module CompletionTest
     tmux.send_keys :Tab, :Tab, :Tab
     tmux.until { |lines| lines.select_count == 3 }
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines[-1] == "ls /tmp 1 2" }
-      tmux.send_keys 'C-L'
-      lines[-1] == "ls /tmp 1 2"
-    end
   end
 
   def test_unset_completion
@@ -1515,7 +1552,7 @@ module CompletionTest
     # FZF_TMUX=1
     new_shell
     tmux.send_keys 'unset FZFFO**', :Tab, pane: 0
-    tmux.until(1) { |lines| lines.match_count == 1 }
+    tmux.until(false, 1) { |lines| lines.match_count == 1 }
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1].include? 'unset FZFFOOBAR' }
   end
@@ -1541,10 +1578,7 @@ module CompletionTest
     tmux.until { |lines| lines.select_count == 2 }
 
     tmux.send_keys :Enter
-    tmux.until do |lines|
+    tmux.until(true) { |lines| lines.any_include? 'cat' }
-      tmux.send_keys 'C-l'
-      lines.any_include? 'cat'
-    end
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1].include? 'test3test4' }
   end