0.23.0

e.g. --preview-window sharp --preview-window cycle

.github/ISSUE_TEMPLATE.md

@@ -1,30 +1,22 @@
+<!-- ISSUES NOT FOLLOWING THIS TEMPLATE WILL BE CLOSED AND DELETED -->
+
 <!-- Check all that apply [x] -->
-- Category
+
-    - [ ] fzf binary
+- [ ] I have read through the manual page (`man fzf`)
-    - [ ] fzf-tmux script
+- [ ] I have the latest version of fzf
-    - [ ] Key bindings
+- [ ] I have searched through the existing issues
-    - [ ] Completion
+
-    - [ ] Vim
+## Info
-    - [ ] Neovim
+
-    - [ ] Etc.
 - OS
     - [ ] Linux
     - [ ] Mac OS X
     - [ ] Windows
-    - [ ] Windows Subsystem for Linux
     - [ ] Etc.
 - Shell
     - [ ] bash
     - [ ] zsh
     - [ ] fish
     
-<!--
+## Problem / Steps to reproduce
-### Before submitting
-
-- Make sure that you have the latest version of fzf
-- If you use tmux, make sure $TERM starts with "screen"
-- For more Vim stuff, check out https://github.com/junegunn/fzf.vim
-
-Describe your problem or suggestion from here ...
--->
 

.gitignore

@@ -7,3 +7,5 @@ Gemfile.lock
 doc/tags
 vendor
 gopath
+*.zwc
+fzf

.rubocop.yml

@@ -0,0 +1,24 @@
+Layout/LineLength:
+  Enabled: false
+Metrics:
+  Enabled: false
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  IgnoredMethods:
+    - assert
+    - exit
+    - paste
+    - puts
+    - raise
+    - refute
+    - require
+    - send_keys
+  IgnoredPatterns:
+    - ^assert_
+    - ^refute_
+Style/NumericPredicate:
+  Enabled: false
+Style/WordArray:
+  MinSize: 1

.travis.yml

@@ -1,20 +1,28 @@
-language: ruby
+language: go
-dist: trusty
+go:
-sudo: required
+  - "1.14"
-matrix:
+env: GO111MODULE=on
-  include:
+os:
-    - env: TAGS=
+  - linux
-      rvm: 2.3.3
+  - osx
-#   - env: TAGS=tcell
+dist: bionic
-#     rvm: 2.3.3
+addons:
-
+  apt:
-install:
+    packages:
-- sudo add-apt-repository -y ppa:pi-rho/dev
+      - fish
-- sudo apt-add-repository -y ppa:fish-shell/release-2
+      - zsh
-- sudo apt-get update
+    sources:
-- sudo apt-get install -y tmux zsh fish
+      sourceline: ppa:fish-shell/release-3
-
+  homebrew:
-script: |
+    packages:
-  make test install &&
+      - fish
-  ./install --all &&
+      - tmux
-  tmux new "ruby test/test_go.rb > out && touch ok" && cat out && [ -e ok ]
+    update: true
+install: gem install minitest rubocop rubocop-minitest rubocop-performance
+script:
+  - make test
+  # LC_ALL=C to avoid escape codes in
+  # printf %q $'\355\205\214\354\212\244\355\212\270' on macOS. Bash on
+  # macOS is built without HANDLE_MULTIBYTE?
+  - make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose
+  - rubocop --require rubocop-minitest --require rubocop-performance

BUILD.md

@@ -6,12 +6,10 @@ Build instructions
 
 ### Prerequisites
 
-- `go` executable in $PATH
+- Go 1.11 or above
 
 ### Using Makefile
 
-Makefile will set up and use its own `$GOPATH` under the project root.
-
 ```sh
 # Build fzf binary for your platform in target
 make

CHANGELOG.md

@@ -1,6 +1,252 @@
 CHANGELOG
 =========
 
+0.23.0
+------
+- Support preview scroll offset relative to window height
+  ```sh
+  git grep --line-number '' |
+    fzf --delimiter : \
+        --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \
+        --preview-window +{2}-/2
+  ```
+- Added `--preview-window` option for sharp edges (`--preview-window sharp`)
+- Added `--preview-window` option for cyclic scrolling (`--preview-window cycle`)
+- Reduced vertical padding around the preview window when `--preview-window
+  noborder` is used
+- Added actions for preview window
+    - `preview-half-page-up`
+    - `preview-half-page-down`
+- Vim
+    - Popup width and height can be given in absolute integer values
+    - Added `fzf#exec()` function for getting the path of fzf executable
+        - It also downloads the latest binary if it's not available by running
+          `./install --bin`
+- Built with Go 1.15.2
+    - We no longer provide 32-bit binaries
+
+0.22.0
+------
+- Added more options for `--bind`
+    - `backward-eof` event
+      ```sh
+      # Aborts when you delete backward when the query prompt is already empty
+      fzf --bind backward-eof:abort
+      ```
+    - `refresh-preview` action
+      ```sh
+      # Rerun preview command when you hit '?'
+      fzf --preview 'echo $RANDOM' --bind '?:refresh-preview'
+      ```
+    - `preview` action
+      ```sh
+      # Default preview command with an extra preview binding
+      fzf --preview 'file {}' --bind '?:preview:cat {}'
+
+      # A preview binding with no default preview command
+      # (Preview window is initially empty)
+      fzf --bind '?:preview:cat {}'
+
+      # Preview window hidden by default, it appears when you first hit '?'
+      fzf --bind '?:preview:cat {}' --preview-window hidden
+      ```
+- Added preview window option for setting the initial scroll offset
+  ```sh
+  # Initial scroll offset is set to the line number of each line of
+  # git grep output *minus* 5 lines
+  git grep --line-number '' |
+    fzf --delimiter : --preview 'nl {1}' --preview-window +{2}-5
+  ```
+- Added support for ANSI colors in `--prompt` string
+- Smart match of accented characters
+    - An unaccented character in the query string will match both accented and
+      unaccented characters, while an accented character will only match
+      accented characters. This is similar to how "smart-case" match works.
+- Vim plugin
+    - `tmux` layout option for using fzf-tmux
+      ```vim
+      let g:fzf_layout = { 'tmux': '-p90%,60%' }
+      ```
+
+0.21.1
+------
+- Shell extension
+    - CTRL-R will remove duplicate commands
+- fzf-tmux
+    - Supports tmux popup window (require tmux 3.2 or above)
+        - ```sh
+          # 50% width and height
+          fzf-tmux -p
+
+          # 80% width and height
+          fzf-tmux -p 80%
+
+          # 80% width and 40% height
+          fzf-tmux -p 80%,40%
+          fzf-tmux -w 80% -h 40%
+
+          # Window position
+          fzf-tmux -w 80% -h 40% -x 0 -y 0
+          fzf-tmux -w 80% -h 40% -y 1000
+
+          # Write ordinary fzf options after --
+          fzf-tmux -p -- --reverse --info=inline --margin 2,4 --border
+          ```
+        - On macOS, you can build the latest tmux from the source with
+          `brew install tmux --HEAD`
+- Bug fixes
+    - Fixed Windows file traversal not to include directories
+    - Fixed ANSI colors with `--keep-right`
+    - Fixed _fzf_complete for zsh
+- Built with Go 1.14.1
+
+0.21.0
+------
+- `--height` option is now available on Windows as well (@kelleyma49)
+- Added `--pointer` and `--marker` options
+- Added `--keep-right` option that keeps the right end of the line visible
+  when it's too long
+- Style changes
+    - `--border` will now print border with rounded corners around the
+      finder instead of printing horizontal lines above and below it.
+      The previous style is available via `--border=horizontal`
+    - Unicode spinner
+- More keys and actions for `--bind`
+- Added PowerShell script for downloading Windows binary
+- Vim plugin: Built-in floating windows support
+  ```vim
+  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+  ```
+- bash: Various improvements in key bindings (CTRL-T, CTRL-R, ALT-C)
+    - CTRL-R will start with the current command-line as the initial query
+    - CTRL-R properly supports multi-line commands
+- Fuzzy completion API changed
+  ```sh
+  # Previous: fzf arguments given as a single string argument
+  # - This style is still supported, but it's deprecated
+  _fzf_complete "--multi --reverse --prompt=\"doge> \"" "$@" < <(
+    echo foo
+  )
+
+  # New API: multiple fzf arguments before "--"
+  # - Easier to write multiple options
+  _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <(
+    echo foo
+  )
+  ```
+- Bug fixes and improvements
+
+0.20.0
+------
+- Customizable preview window color (`preview-fg` and `preview-bg` for `--color`)
+  ```sh
+  fzf --preview 'cat {}' \
+      --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899' \
+      --border --height 20 --layout reverse --info inline
+  ```
+- Removed the immediate flicking of the screen on `reload` action.
+  ```sh
+  : | fzf --bind 'change:reload:seq {q}' --phony
+  ```
+- Added `clear-query` and `clear-selection` actions for `--bind`
+- It is now possible to split a composite bind action over multiple `--bind`
+  expressions by prefixing the later ones with `+`.
+  ```sh
+  fzf --bind 'ctrl-a:up+up'
+
+  # Can be now written as
+  fzf --bind 'ctrl-a:up' --bind 'ctrl-a:+up'
+
+  # This is useful when you need to write special execute/reload form (i.e. `execute:...`)
+  # to avoid parse errors and add more actions to the same key
+  fzf --multi --bind 'ctrl-l:select-all+execute:less {+f}' --bind 'ctrl-l:+deselect-all'
+  ```
+- Fixed parse error of `--bind` expression where concatenated execute/reload
+  action contains `+` character.
+  ```sh
+  fzf --multi --bind 'ctrl-l:select-all+execute(less {+f})+deselect-all'
+  ```
+- Fixed bugs of reload action
+    - Not triggered when there's no match even when the command doesn't have
+      any placeholder expressions
+    - Screen not properly cleared when `--header-lines` not filled on reload
+
+0.19.0
+------
+
+- Added `--phony` option which completely disables search functionality.
+  Useful when you want to use fzf only as a selector interface. See below.
+- Added "reload" action for dynamically updating the input list without
+  restarting fzf. See https://github.com/junegunn/fzf/issues/1750 to learn
+  more about it.
+  ```sh
+  # Using fzf as the selector interface for ripgrep
+  RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+  INITIAL_QUERY="foo"
+  FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY' || true" \
+    fzf --bind "change:reload:$RG_PREFIX {q} || true" \
+        --ansi --phony --query "$INITIAL_QUERY"
+  ```
+- `--multi` now takes an optional integer argument which indicates the maximum
+  number of items that can be selected
+  ```sh
+  seq 100 | fzf --multi 3 --reverse --height 50%
+  ```
+- If a placeholder expression for `--preview` and `execute` action (and the
+  new `reload` action) contains `f` flag, it is replaced to the
+  path of a temporary file that holds the evaluated list. This is useful
+  when you multi-select a large number of items and the length of the
+  evaluated string may exceed [`ARG_MAX`][argmax].
+  ```sh
+  # Press CTRL-A to select 100K items and see the sum of all the numbers
+  seq 100000 | fzf --multi --bind ctrl-a:select-all \
+                   --preview "awk '{sum+=\$1} END {print sum}' {+f}"
+  ```
+- `deselect-all` no longer deselects unmatched items. It is now consistent
+  with `select-all` and `toggle-all` in that it only affects matched items.
+- Due to the limitation of bash, fuzzy completion is enabled by default for
+  a fixed set of commands. A helper function for easily setting up fuzzy
+  completion for any command is now provided.
+  ```sh
+  # usage: _fzf_setup_completion path|dir COMMANDS...
+  _fzf_setup_completion path git kubectl
+  ```
+- Info line style can be changed by `--info=STYLE`
+    - `--info=default`
+    - `--info=inline` (same as old `--inline-info`)
+    - `--info=hidden`
+- Preview window border can be disabled by adding `noborder` to
+  `--preview-window`.
+- When you transform the input with `--with-nth`, the trailing white spaces
+  are removed.
+- `ctrl-\`, `ctrl-]`, `ctrl-^`, and `ctrl-/` can now be used with `--bind`
+- See https://github.com/junegunn/fzf/milestone/15?closed=1 for more details
+
+[argmax]: https://unix.stackexchange.com/questions/120642/what-defines-the-maximum-size-for-a-command-single-argument
+
+0.18.0
+------
+
+- Added placeholder expression for zero-based item index: `{n}` and `{+n}`
+    - `fzf --preview 'echo {n}: {}'`
+- Added color option for the gutter: `--color gutter:-1`
+- Added `--no-unicode` option for drawing borders in non-Unicode, ASCII
+  characters
+- `FZF_PREVIEW_LINES` and `FZF_PREVIEW_COLUMNS` are exported to preview process
+    - fzf still overrides `LINES` and `COLUMNS` as before, but they may be
+      reset by the default shell.
+- Bug fixes and improvements
+    - See https://github.com/junegunn/fzf/milestone/14?closed=1
+- Built with Go 1.12.1
+
+0.17.5
+------
+
+- Bug fixes and improvements
+    - See https://github.com/junegunn/fzf/milestone/13?closed=1
+- Search query longer than the screen width is allowed (up to 300 chars)
+- Built with Go 1.11.1
+
 0.17.4
 ------
 

Dockerfile

@@ -1,6 +1,6 @@
 FROM archlinux/base:latest
-RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make
+RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make gcc
-RUN gem install --no-ri --no-rdoc minitest
+RUN gem install --no-document minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile
 

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2013-2020 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

Makefile

@@ -1,34 +1,26 @@
-ifndef GOOS
+GO             ?= go
-GOOS        := $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
+GOOS           ?= $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
-endif
 
 MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
 ROOT_DIR       := $(shell dirname $(MAKEFILE))
-GOPATH      := $(ROOT_DIR)/gopath
+SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)
-SRC_LINK    := $(GOPATH)/src/github.com/junegunn/fzf/src
-VENDOR_LINK := $(GOPATH)/src/github.com/junegunn/fzf/vendor
-export GOPATH
-
-GLIDE_YAML  := glide.yaml
-GLIDE_LOCK  := glide.lock
-SOURCES     := $(wildcard *.go src/*.go src/*/*.go) $(SRC_LINK) $(VENDOR_LINK) $(GLIDE_LOCK) $(MAKEFILE)
 
 REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES))
-BUILD_FLAGS := -a -ldflags "-X main.revision=$(REVISION) -w -extldflags=$(LDFLAGS)" -tags "$(TAGS)"
+BUILD_FLAGS    := -a -ldflags "-X main.revision=$(REVISION) -w '-extldflags=$(LDFLAGS)'" -tags "$(TAGS)"
 
-BINARY32    := fzf-$(GOOS)_386
 BINARY64       := fzf-$(GOOS)_amd64
 BINARYARM5     := fzf-$(GOOS)_arm5
 BINARYARM6     := fzf-$(GOOS)_arm6
 BINARYARM7     := fzf-$(GOOS)_arm7
 BINARYARM8     := fzf-$(GOOS)_arm8
+BINARYPPC64LE  := fzf-$(GOOS)_ppc64le
 VERSION        := $(shell awk -F= '/version =/ {print $$2}' src/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
+RELEASEPPC64LE := fzf-$(VERSION)-$(GOOS)_ppc64le
 
 # https://en.wikipedia.org/wiki/Uname
 UNAME_M := $(shell uname -m)
@@ -36,16 +28,18 @@ 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 ifeq ($(UNAME_M),armv8l)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),aarch64)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),ppc64le)
+	BINARY := $(BINARYPPC64LE)
 else
 $(error "Build on $(UNAME_M) is not supported, yet.")
 endif
@@ -56,22 +50,20 @@ target:
 	mkdir -p $@
 
 ifeq ($(GOOS),windows)
-release: target/$(BINARY32) target/$(BINARY64)
+release: target/$(BINARY64)
-	cd target && cp -f $(BINARY32) fzf.exe && zip $(RELEASE32).zip fzf.exe
 	cd target && cp -f $(BINARY64) fzf.exe && zip $(RELEASE64).zip fzf.exe
 	cd target && rm -f fzf.exe
 else ifeq ($(GOOS),linux)
-release: target/$(BINARY32) target/$(BINARY64) target/$(BINARYARM5) target/$(BINARYARM6) target/$(BINARYARM7) target/$(BINARYARM8)
+release: target/$(BINARY64) target/$(BINARYARM5) target/$(BINARYARM6) target/$(BINARYARM7) target/$(BINARYARM8) target/$(BINARYPPC64LE)
-	cd target && cp -f $(BINARY32) fzf && tar -czf $(RELEASE32).tgz fzf
 	cd target && cp -f $(BINARY64) fzf && tar -czf $(RELEASE64).tgz fzf
 	cd target && cp -f $(BINARYARM5) fzf && tar -czf $(RELEASEARM5).tgz fzf
 	cd target && cp -f $(BINARYARM6) fzf && tar -czf $(RELEASEARM6).tgz fzf
 	cd target && cp -f $(BINARYARM7) fzf && tar -czf $(RELEASEARM7).tgz fzf
 	cd target && cp -f $(BINARYARM8) fzf && tar -czf $(RELEASEARM8).tgz fzf
+	cd target && cp -f $(BINARYPPC64LE) fzf && tar -czf $(RELEASEPPC64LE).tgz fzf
 	cd target && rm -f fzf
 else
-release: target/$(BINARY32) target/$(BINARY64)
+release: target/$(BINARY64)
-	cd target && cp -f $(BINARY32) fzf && tar -czf $(RELEASE32).tgz fzf
 	cd target && cp -f $(BINARY64) fzf && tar -czf $(RELEASE64).tgz fzf
 	cd target && rm -f fzf
 endif
@@ -83,19 +75,8 @@ release-all: clean test
 	GOOS=openbsd make release
 	GOOS=windows make release
 
-$(SRC_LINK):
+test: $(SOURCES)
-	mkdir -p $(shell dirname $(SRC_LINK))
+	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
-	ln -sf $(ROOT_DIR)/src $(SRC_LINK)
-
-$(VENDOR_LINK):
-	mkdir -p $(shell dirname $(VENDOR_LINK))
-	ln -sf $(ROOT_DIR)/vendor $(VENDOR_LINK)
-
-vendor: $(GLIDE_YAML)
-	go get -u github.com/Masterminds/glide && $(GOPATH)/bin/glide install && touch $@
-
-test: $(SOURCES) vendor
-	SHELL=/bin/sh GOOS= go test -v -tags "$(TAGS)" \
 				github.com/junegunn/fzf/src \
 				github.com/junegunn/fzf/src/algo \
 				github.com/junegunn/fzf/src/tui \
@@ -104,26 +85,26 @@ test: $(SOURCES) vendor
 install: bin/fzf
 
 clean:
-	rm -rf target
+	$(RM) -r target
 
-target/$(BINARY32): $(SOURCES) vendor
+target/$(BINARY64): $(SOURCES)
-	GOARCH=386 go build $(BUILD_FLAGS) -o $@
+	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@
-
-target/$(BINARY64): $(SOURCES) vendor
-	GOARCH=amd64 go build $(BUILD_FLAGS) -o $@
 
 # https://github.com/golang/go/wiki/GoArm
-target/$(BINARYARM5): $(SOURCES) vendor
+target/$(BINARYARM5): $(SOURCES)
-	GOARCH=arm GOARM=5 go build $(BUILD_FLAGS) -o $@
+	GOARCH=arm GOARM=5 $(GO) build $(BUILD_FLAGS) -o $@
 
-target/$(BINARYARM6): $(SOURCES) vendor
+target/$(BINARYARM6): $(SOURCES)
-	GOARCH=arm GOARM=6 go build $(BUILD_FLAGS) -o $@
+	GOARCH=arm GOARM=6 $(GO) build $(BUILD_FLAGS) -o $@
 
-target/$(BINARYARM7): $(SOURCES) vendor
+target/$(BINARYARM7): $(SOURCES)
-	GOARCH=arm GOARM=7 go build $(BUILD_FLAGS) -o $@
+	GOARCH=arm GOARM=7 $(GO) build $(BUILD_FLAGS) -o $@
 
-target/$(BINARYARM8): $(SOURCES) vendor
+target/$(BINARYARM8): $(SOURCES)
-	GOARCH=arm64 go build $(BUILD_FLAGS) -o $@
+	GOARCH=arm64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYPPC64LE): $(SOURCES)
+	GOARCH=ppc64le $(GO) build $(BUILD_FLAGS) -o $@
 
 bin/fzf: target/$(BINARY) | bin
 	cp -f target/$(BINARY) bin/fzf
@@ -136,4 +117,8 @@ docker-test:
 	docker build -t fzf-arch .
 	docker run -it fzf-arch
 
-.PHONY: all release release-all test install clean docker docker-test
+update:
+	$(GO) get -u
+	$(GO) mod tidy
+
+.PHONY: all release release-all test install clean docker docker-test update

README-VIM.md

@@ -1,16 +1,77 @@
 FZF Vim integration
 ===================
 
-This repository only enables basic integration with Vim. If you're looking for
+Installation
-more, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
+------------
 
-(Note: To use fzf in GVim, an external terminal emulator is required.)
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to `&runtimepath` in your Vim configuration file. The path may
+differ depending on the package manager.
+
+```vim
+" If installed using Homebrew
+set rtp+=/usr/local/opt/fzf
+
+" If installed using git
+set rtp+=~/.fzf
+```
+
+If you use [vim-plug](https://github.com/junegunn/vim-plug), the same can be
+written as:
+
+```vim
+" If installed using Homebrew
+Plug '/usr/local/opt/fzf'
+
+" If installed using git
+Plug '~/.fzf'
+```
+
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+
+```vim
+Plug 'junegunn/fzf'
+```
+
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+```vim
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+```
+
+Summary
+-------
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+1. **`fzf#run([spec dict])`**
+    - Starts fzf inside Vim with the given spec
+    - `:call fzf#run({'source': 'ls'})`
+2. **`fzf#wrap([spec dict]) -> (dict)`**
+    - Takes a spec for `fzf#run` and returns an extended version of it with
+      additional options for addressing global preferences (`g:fzf_xxx`)
+        - `:echo fzf#wrap({'source': 'ls'})`
+    - We usually *wrap* a spec with `fzf#wrap` before passing it to `fzf#run`
+        - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+3. **`:FZF [fzf_options string] [path string]`**
+    - Basic fuzzy file selector
+    - A reference implementation for those who don't want to write VimScript
+      to implement custom commands
+    - If you're looking for more such commands, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
 
 `:FZF[!]`
 ---------
 
-If you have set up fzf for Vim, `:FZF` command will be added.
-
 ```vim
 " Look for files under current directory
 :FZF
@@ -18,8 +79,8 @@ If you have set up fzf for Vim, `:FZF` command will be added.
 " Look for files under your home directory
 :FZF ~
 
-" With options
+" With fzf command-line options
-:FZF --no-sort --reverse --inline-info /tmp
+:FZF --reverse --info=inline /tmp
 
 " Bang version starts fzf in fullscreen mode
 :FZF!
@@ -42,9 +103,6 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
     - Customizes fzf colors to match the current color scheme
 - `g:fzf_history_dir`
     - Enables history feature
-- `g:fzf_launcher`
-    - (Only in GVim) Terminal emulator to open fzf with
-    - `g:Fzf_launcher` for function reference
 
 #### Examples
 
@@ -69,15 +127,17 @@ let g:fzf_action = {
   \ 'ctrl-v': 'vsplit' }
 
 " Default fzf layout
-" - down / up / left / right
+" - down / up / left / right / window
-let g:fzf_layout = { 'down': '~40%' }
+let g:fzf_layout = { 'down': '40%' }
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
 " You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
 let g:fzf_layout = { 'window': 'enew' }
 let g:fzf_layout = { 'window': '-tabnew' }
-let g:fzf_layout = { 'window': '10split enew' }
+let g:fzf_layout = { 'window': '10new' }
 
 " Customize fzf colors to match your color scheme
+" - fzf#wrap translates this to a set of `--color` options
 let g:fzf_colors =
 \ { 'fg':      ['fg', 'Normal'],
   \ 'bg':      ['bg', 'Normal'],
@@ -93,18 +153,117 @@ let g:fzf_colors =
   \ 'spinner': ['fg', 'Label'],
   \ 'header':  ['fg', 'Comment'] }
 
-" Enable per-command history.
+" Enable per-command history
-" CTRL-N and CTRL-P will be automatically bound to next-history and
+" - History files will be stored in the specified directory
-" previous-history instead of down and up. If you don't like the change,
+" - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
-" explicitly bind the keys to down and up in your $FZF_DEFAULT_OPTS.
+"   'previous-history' instead of 'down' and 'up'.
 let g:fzf_history_dir = '~/.local/share/fzf-history'
 ```
 
+##### Explanation of `g:fzf_colors`
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+
+    element: [ component, group1 [, group2, ...] ]
+
+- `element` is an fzf element to apply a color to:
+
+  | Element               | Description                                           |
+  | ---                   | ---                                                   |
+  | `fg`  / `bg`  / `hl`  | Item (foreground / background / highlight)            |
+  | `fg+` / `bg+` / `hl+` | Current item (foreground / background / highlight)    |
+  | `hl`  / `hl+`         | Highlighted substrings (normal / current)             |
+  | `gutter`              | Background of the gutter on the left                  |
+  | `pointer`             | Pointer to the current line (`>`)                     |
+  | `marker`              | Multi-select marker (`>`)                             |
+  | `border`              | Border around the window (`--border` and `--preview`) |
+  | `header`              | Header (`--header` or `--header-lines`)               |
+  | `info`                | Info line (match counters)                            |
+  | `spinner`             | Streaming input indicator                             |
+  | `prompt`              | Prompt before query (`> `)                            |
+
+- `component` specifies the component (`fg` / `bg`) from which to extract the
+  color when considering each of the following highlight groups
+
+- `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+  order) for a matching color definition
+
+For example, consider the following specification:
+
+```vim
+  'prompt':  ['fg', 'Conditional', 'Comment'],
+```
+
+This means we color the **prompt**
+- using the `fg` attribute of the `Conditional` if it exists,
+- otherwise use the `fg` attribute of the `Comment` highlight group if it exists,
+- otherwise fall back to the default color settings for the **prompt**.
+
+You can examine the color option generated according the setting by printing
+the result of `fzf#wrap()` function like so:
+
+```vim
+:echo fzf#wrap()
+```
+
 `fzf#run`
 ---------
 
-For more advanced uses, you can use `fzf#run([options])` function with the
+`fzf#run()` function is the core of Vim integration. It takes a single
-following options.
+dictionary argument, *a spec*, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+
+```vim
+call fzf#run({'sink': 'e'})
+```
+
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
+
+```vim
+call fzf#run({'sink': 'tabedit'})
+```
+
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
+
+```vim
+call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+```
+
+fzf options can be specified as `options` entry in spec dictionary.
+
+```vim
+call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+```
+
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+
+```vim
+" up / down / left / right / window are allowed
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+```
+
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color
+schemes as the source to implement a color scheme selector.
+
+```vim
+call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+            \               'fnamemodify(v:val, ":t:r")'),
+            \ 'sink': 'colo', 'left': '25%'})
+```
+
+The following table summarizes the available options.
 
 | Option name                | Type          | Description                                                           |
 | -------------------------- | ------------- | ----------------------------------------------------------------      |
@@ -115,82 +274,163 @@ following options.
 | `sink*`                    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
 | `options`                  | string/list   | Options to fzf                                                        |
 | `dir`                      | string        | Working directory                                                     |
-| `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
+| `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
-| `window` (Vim 8 / Neovim)  | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
+| `tmux`                     | string        | (Layout) fzf-tmux options (e.g. `-p90%,60%`)                          |
-| `launcher`                 | string        | External terminal emulator to start fzf with (GVim only)         |
+| `window` (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g. `vertical aboveleft 30new`) |
-| `launcher`                 | funcref       | Function for generating `launcher` string (GVim only)            |
+| `window` (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g. `{'width': 0.9, 'height': 0.6}`) |
 
 `options` entry can be either a string or a list. For simple cases, string
-should suffice, but prefer to use list type if you're concerned about escaping
+should suffice, but prefer to use list type to avoid escaping issues.
-issues on different platforms.
 
 ```vim
 call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
 call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
 ```
 
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
+
+- Required:
+    - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+    - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+- Optional:
+    - `yoffset` [float default 0.5 range [0 ~ 1]]
+    - `xoffset` [float default 0.5 range [0 ~ 1]]
+    - `highlight` [string default `'Comment'`]: Highlight group for border
+    - `border` [string default `rounded`]: Border style
+        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right`
+
 `fzf#wrap`
 ----------
 
-`fzf#wrap([name string,] [opts dict,] [fullscreen boolean])` is a helper
+We have seen that several aspects of `:FZF` command can be configured with
-function that decorates the options dictionary so that it understands
+a set of global option variables; different ways to open files
-`g:fzf_layout`, `g:fzf_action`, `g:fzf_colors`, and `g:fzf_history_dir` like
+(`g:fzf_action`), window position and size (`g:fzf_layout`), color palette
-`:FZF`.
+(`g:fzf_colors`), etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by *"wrapping"* the spec dictionary with `fzf#wrap` before passing it
+to `fzf#run`.
+
+- **`fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`**
+    - All arguments are optional. Usually we only need to pass a spec dictionary.
+    - `name` is for managing history files. It is ignored if
+      `g:fzf_history_dir` is not defined.
+    - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also
+a dictionary) with additional options for addressing global preferences. You
+can examine the return value of it like so:
 
 ```vim
-command! -bang MyStuff
+echo fzf#wrap({'source': 'ls'})
-  \ call fzf#run(fzf#wrap('my-stuff', {'dir': '~/my-stuff'}, <bang>0))
 ```
 
-fzf inside terminal buffer
+After we *"wrap"* our spec, we pass it to `fzf#run`.
---------------------------
+
+```vim
+call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Now it supports `CTRL-T`, `CTRL-V`, and `CTRL-X` key bindings and it opens fzf
+window according to `g:fzf_layout` setting.
+
+To make it easier to use, let's define `LS` command.
+
+```vim
+command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use `<bang>` value to set
+the last `fullscreen` argument of `fzf#wrap` (see `:help <bang>`).
+
+```vim
+" On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+```
+
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+
+```vim
+command! -bang -complete=dir -nargs=* LS
+    \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign
+a unique name to our command and pass it as the first argument to `fzf#wrap`.
+
+```vim
+" The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+" The name is ignored if g:fzf_history_dir is not defined.
+command! -bang -complete=dir -nargs=* LS
+    \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+Tips
+----
+
+### fzf inside terminal buffer
 
 The latest versions of Vim and Neovim include builtin terminal emulator
 (`:terminal`) and fzf will start in a terminal buffer in the following cases:
 
 - On Neovim
 - On GVim
-- On Terminal Vim with the non-default layout
+- On Terminal Vim with a non-default layout
     - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
 
-### Hide statusline
+#### Starting fzf in a popup window
-
-When fzf starts in a terminal buffer, you may want to hide the statusline of
-the containing buffer.
 
 ```vim
-autocmd! FileType fzf
+" Required:
-autocmd  FileType fzf set laststatus=0 noshowmode noruler
+" - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
+" - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
+"
+" Optional:
+" - xoffset [float default 0.5 range [0 ~ 1]]
+" - yoffset [float default 0.5 range [0 ~ 1]]
+" - highlight [string default 'Comment']: Highlight group for border
+" - border [string default 'rounded']: Border style
+"   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+```
+
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting fzf-tmux options in `tmux` key.
+
+```vim
+" See `man fzf-tmux` for available options
+if exists('$TMUX')
+  let g:fzf_layout = { 'tmux': '-p90%,60%' }
+else
+  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+endif
+```
+
+#### Hide statusline
+
+When fzf starts in a terminal buffer, the file type of the buffer is set to
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you use a non-popup layout (e.g. `{'down': '40%'}`) on Neovim,
+you might want to temporarily disable the statusline for a cleaner look.
+
+```vim
+if has('nvim') && !exists('g:fzf_layout')
+  autocmd! FileType fzf
+  autocmd  FileType fzf set laststatus=0 noshowmode noruler
     \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+endif
 ```
 
-GVim
-----
-
-With the latest version of GVim, fzf will start inside the builtin terminal
-emulator of Vim. Please note that this terminal feature of Vim is still young
-and unstable and you may run into some issues.
-
-If you have an older version of GVim, you need an external terminal emulator
-to start fzf with. `xterm` command is used by default, but you can customize
-it with `g:fzf_launcher`.
-
-```vim
-" This is the default. %s is replaced with fzf command
-let g:fzf_launcher = 'xterm -e bash -ic %s'
-
-" Use urxvt instead
-let g:fzf_launcher = 'urxvt -geometry 120x30 -e sh -c %s'
-```
-
-If you're running MacVim on OSX, I recommend you to use iTerm2 as the
-launcher. Refer to the [this wiki page][macvim-iterm2] to see how to set up.
-
-[macvim-iterm2]: https://github.com/junegunn/fzf/wiki/On-MacVim-with-iTerm2
-
 [License](LICENSE)
 ------------------
 
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 Junegunn Choi

README.md

@@ -22,41 +22,50 @@ Pros
 Table of Contents
 -----------------
 
-   * [Installation](#installation)
+<!-- vim-markdown-toc GFM -->
+
+* [Installation](#installation)
   * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
   * [Using git](#using-git)
-      * [As Vim plugin](#as-vim-plugin)
+  * [Using Linux package managers](#using-linux-package-managers)
-      * [Arch Linux](#arch-linux)
-      * [Fedora](#fedora)
   * [Windows](#windows)
-   * [Upgrading fzf](#upgrading-fzf)
+  * [As Vim plugin](#as-vim-plugin)
-   * [Building fzf](#building-fzf)
+* [Upgrading fzf](#upgrading-fzf)
-   * [Usage](#usage)
+* [Building fzf](#building-fzf)
+* [Usage](#usage)
     * [Using the finder](#using-the-finder)
     * [Layout](#layout)
     * [Search syntax](#search-syntax)
     * [Environment variables](#environment-variables)
     * [Options](#options)
-   * [Examples](#examples)
+    * [Demo](#demo)
-   * [fzf-tmux script](#fzf-tmux-script)
+* [Examples](#examples)
-   * [Key bindings for command line](#key-bindings-for-command-line)
+* [`fzf-tmux` script](#fzf-tmux-script)
-   * [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
+* [Key bindings for command-line](#key-bindings-for-command-line)
+* [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
     * [Files and directories](#files-and-directories)
     * [Process IDs](#process-ids)
     * [Host names](#host-names)
     * [Environment variables / Aliases](#environment-variables--aliases)
     * [Settings](#settings)
     * [Supported commands](#supported-commands)
-   * [Vim plugin](#vim-plugin)
+    * [Custom fuzzy completion](#custom-fuzzy-completion)
-   * [Advanced topics](#advanced-topics)
+* [Vim plugin](#vim-plugin)
+* [Advanced topics](#advanced-topics)
   * [Performance](#performance)
   * [Executing external programs](#executing-external-programs)
+  * [Reloading the candidate list](#reloading-the-candidate-list)
+    * [1. Update the list of processes by pressing CTRL-R](#1-update-the-list-of-processes-by-pressing-ctrl-r)
+    * [2. Switch between sources by pressing CTRL-D or CTRL-F](#2-switch-between-sources-by-pressing-ctrl-d-or-ctrl-f)
+    * [3. Interactive ripgrep integration](#3-interactive-ripgrep-integration)
   * [Preview window](#preview-window)
-   * [Tips](#tips)
+* [Tips](#tips)
-      * [Respecting .gitignore](#respecting-gitignore)
+    * [Respecting `.gitignore`](#respecting-gitignore)
-      * [git ls-tree for fast traversal](#git-ls-tree-for-fast-traversal)
     * [Fish shell](#fish-shell)
-   * [<a href="LICENSE">License</a>](#license)
+* [Related projects](#related-projects)
+* [License](#license)
+
+<!-- vim-markdown-toc -->
 
 Installation
 ------------
@@ -87,6 +96,10 @@ brew install fzf
 $(brew --prefix)/opt/fzf/install
 ```
 
+fzf is also available [via MacPorts][portfile]: `sudo port install fzf`
+
+[portfile]: https://github.com/macports/macports-ports/blob/master/sysutils/fzf/Portfile
+
 ### Using git
 
 Alternatively, you can "git clone" this repository to any directory and run
@@ -97,78 +110,57 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-### As Vim plugin
+### Using Linux package managers
 
-Once you have fzf installed, you can enable it inside Vim simply by adding the
+| Package Manager | Linux Distribution      | Command                            |
-directory to `&runtimepath` in your Vim configuration file as follows:
+| ---             | ---                     | ---                                |
+| APK             | Alpine Linux            | `sudo apk add fzf`                 |
+| APT             | Debian 9+/Ubuntu 19.10+ | `sudo apt-get install fzf`         |
+| Conda           |                         | `conda install -c conda-forge fzf` |
+| DNF             | Fedora                  | `sudo dnf install fzf`             |
+| Nix             | NixOS, etc.             | `nix-env -iA nixpkgs.fzf`          |
+| Pacman          | Arch Linux              | `sudo pacman -S fzf`               |
+| pkg             | FreeBSD                 | `pkg install fzf`                  |
+| pkg_add         | OpenBSD                 | `pkg_add fzf`                      |
+| XBPS            | Void Linux              | `sudo xbps-install -S fzf`         |
+| Zypper          | openSUSE                | `sudo zypper install fzf`          |
 
-```vim
+Shell extensions (key bindings and fuzzy auto-completion) and Vim/Neovim
-" If installed using Homebrew
+plugin may or may not be enabled by default depending on the package manager.
-set rtp+=/usr/local/opt/fzf
+Refer to the package documentation for more information.
-
-" If installed using git
-set rtp+=~/.fzf
-```
-
-If you use [vim-plug](https://github.com/junegunn/vim-plug), the same can be
-written as:
-
-```vim
-" If installed using Homebrew
-Plug '/usr/local/opt/fzf'
-
-" If installed using git
-Plug '~/.fzf'
-```
-
-But instead of separately installing fzf on your system (using Homebrew or
-"git clone") and enabling it on Vim (adding it to `&runtimepath`), you can use
-vim-plug to do both.
-
-```vim
-" PlugInstall and PlugUpdate will clone fzf in ~/.fzf and run install script
-Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
-  " Both options are optional. You don't have to install fzf in ~/.fzf
-  " and you don't have to run install script if you use fzf only in Vim.
-```
-
-### Arch Linux
-
-```sh
-sudo pacman -S fzf
-```
-
-### Fedora
-
-fzf is available in Fedora 26 and above, and can be installed using the usual
-method:
-
-```sh
-sudo dnf install fzf
-```
-
-Shell completion and plugins for vim or neovim are enabled by default. Shell
-key bindings are installed but not enabled by default. See Fedora's package
-documentation (/usr/share/doc/fzf/README.Fedora) for more information.
 
 ### Windows
 
 Pre-built binaries for Windows can be downloaded [here][bin]. fzf is also
-available as a [Chocolatey package][choco].
+available via [Chocolatey][choco] and [Scoop][scoop]:
+
+| Package manager | Command             |
+| ---             | ---                 |
+| Chocolatey      | `choco install fzf` |
+| Scoop           | `scoop install fzf` |
 
 [choco]: https://chocolatey.org/packages/fzf
+[scoop]: https://github.com/ScoopInstaller/Main/blob/master/bucket/fzf.json
 
-```sh
+Known issues and limitations on Windows can be found on [the wiki
-choco install fzf
+page][windows-wiki].
-```
-
-However, other components of the project may not work on Windows. Known issues
-and limitations can be found on [the wiki page][windows-wiki]. You might want
-to consider installing fzf on [Windows Subsystem for Linux][wsl] where
-everything runs flawlessly.
 
 [windows-wiki]: https://github.com/junegunn/fzf/wiki/Windows
-[wsl]: https://blogs.msdn.microsoft.com/wsl/
+
+### As Vim plugin
+
+If you use
+[vim-plug](https://github.com/junegunn/vim-plug), add this line to your Vim
+configuration file:
+
+```vim
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+```
+
+`fzf#install()` makes sure that you have the latest binary, but it's optional,
+so you can omit it if you use a plugin manager that doesn't support hooks.
+
+For more installation options, see [README-VIM.md](README-VIM.md).
 
 Upgrading fzf
 -------------
@@ -179,6 +171,7 @@ method used.
 
 - git: `cd ~/.fzf && git pull && ./install`
 - brew: `brew update; brew reinstall fzf`
+- macports: `sudo port upgrade fzf`
 - chocolatey: `choco upgrade fzf`
 - vim-plug: `:PlugUpdate fzf`
 
@@ -278,6 +271,13 @@ or `py`.
 
 See the man page (`man fzf`) for the full list of options.
 
+#### Demo
+If you learn by watching videos, check out this screencast by [@samoshkin](https://github.com/samoshkin) to explore `fzf` features.
+
+<a title="fzf - command-line fuzzy finder" href="https://www.youtube.com/watch?v=qgG5Jhi_Els">
+  <img src="https://i.imgur.com/vtG8olE.png" width="640">
+</a>
+
 Examples
 --------
 
@@ -291,8 +291,10 @@ own as well.
 [fzf-tmux](bin/fzf-tmux) is a bash script that opens fzf in a tmux pane.
 
 ```sh
-# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
-#        (-[udlr]: up/down/left/right)
+
+# See available options
+fzf-tmux --help
 
 # select git branches in horizontal split below (15 lines)
 git branch | fzf-tmux -d 15
@@ -301,7 +303,7 @@ git branch | fzf-tmux -d 15
 cat /usr/share/dict/words | fzf-tmux -l 20% --multi --reverse
 ```
 
-It will still work even when you're not on tmux, silently ignoring `-[udlr]`
+It will still work even when you're not on tmux, silently ignoring `-[pudlr]`
 options, so you can invariably use `fzf-tmux` in your scripts.
 
 Alternatively, you can use `--height HEIGHT[%]` option not to start fzf in
@@ -311,16 +313,16 @@ fullscreen mode.
 fzf --height 40%
 ```
 
-Key bindings for command line
+Key bindings for command-line
 -----------------------------
 
 The install script will setup the following key bindings for bash, zsh, and
 fish.
 
-- `CTRL-T` - Paste the selected files and directories onto the command line
+- `CTRL-T` - Paste the selected files and directories onto the command-line
     - Set `FZF_CTRL_T_COMMAND` to override the default command
     - Set `FZF_CTRL_T_OPTS` to pass additional options
-- `CTRL-R` - Paste the selected command from history onto the command line
+- `CTRL-R` - Paste the selected command from history onto the command-line
     - If you want to see the commands in chronological order, press `CTRL-R`
       again which toggles sorting by relevance
     - Set `FZF_CTRL_R_OPTS` to pass additional options
@@ -328,13 +330,9 @@ fish.
     - Set `FZF_ALT_C_COMMAND` to override the default command
     - Set `FZF_ALT_C_OPTS` to pass additional options
 
-If you're on a tmux session, you can start fzf in a split pane by setting
+If you're on a tmux session, you can start fzf in a tmux split pane or in
-`FZF_TMUX` to 1, and change the height of the pane with `FZF_TMUX_HEIGHT`
+a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `-d 40%`).
-(e.g. `20`, `50%`).
+See `fzf-tmux --help` for available options.
-
-If you use vi mode on bash, you need to add `set -o vi` *before* `source
-~/.fzf.bash` in your .bashrc, so that it correctly sets up key bindings for vi
-mode.
 
 More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
 
@@ -372,7 +370,7 @@ cd ~/github/fzf**<TAB>
 
 #### Process IDs
 
-Fuzzy completion for PIDs is provided for kill command. In this case
+Fuzzy completion for PIDs is provided for kill command. In this case,
 there is no trigger sequence, just press tab key after kill command.
 
 ```sh
@@ -419,17 +417,83 @@ _fzf_compgen_path() {
 _fzf_compgen_dir() {
   fd --type d --hidden --follow --exclude ".git" . "$1"
 }
+
+# (EXPERIMENTAL) Advanced customization of fzf options via _fzf_comprun function
+# - The first argument to the function is the name of the command.
+# - You should make sure to pass the rest of the arguments to fzf.
+_fzf_comprun() {
+  local command=$1
+  shift
+
+  case "$command" in
+    cd)           fzf "$@" --preview 'tree -C {} | head -200' ;;
+    export|unset) fzf "$@" --preview "eval 'echo \$'{}" ;;
+    ssh)          fzf "$@" --preview 'dig {}' ;;
+    *)            fzf "$@" ;;
+  esac
+}
 ```
 
 #### Supported commands
 
 On bash, fuzzy completion is enabled only for a predefined set of commands
 (`complete | grep _fzf` to see the list). But you can enable it for other
-commands as well like follows.
+commands as well by using `_fzf_setup_completion` helper function.
 
 ```sh
-complete -F _fzf_path_completion -o default -o bashdefault ag
+# usage: _fzf_setup_completion path|dir|var|alias|host COMMANDS...
-complete -F _fzf_dir_completion -o default -o bashdefault tree
+_fzf_setup_completion path ag git kubectl
+_fzf_setup_completion dir tree
+```
+
+#### Custom fuzzy completion
+
+_**(Custom completion API is experimental and subject to change)**_
+
+For a command named _"COMMAND"_, define `_fzf_complete_COMMAND` function using
+`_fzf_complete` helper.
+
+```sh
+# Custom fuzzy completion for "doge" command
+#   e.g. doge **<TAB>
+_fzf_complete_doge() {
+  _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <(
+    echo very
+    echo wow
+    echo such
+    echo doge
+  )
+}
+```
+
+- The arguments before `--` are the options to fzf.
+- After `--`, simply pass the original completion arguments unchanged (`"$@"`).
+- Then write a set of commands that generates the completion candidates and
+  feed its output to the function using process substitution (`< <(...)`).
+
+zsh will automatically pick up the function using the naming convention but in
+bash you have to manually associate the function with the command using
+`complete` command.
+
+```sh
+[ -n "$BASH" ] && complete -F _fzf_complete_doge -o default -o bashdefault doge
+```
+
+If you need to post-process the output from fzf, define
+`_fzf_complete_COMMAND_post` as follows.
+
+```sh
+_fzf_complete_foo() {
+  _fzf_complete --multi --reverse --header-lines=3 -- "$@" < <(
+    ls -al
+  )
+}
+
+_fzf_complete_foo_post() {
+  awk '{print $NF}'
+}
+
+[ -n "$BASH" ] && complete -F _fzf_complete_foo -o default -o bashdefault foo
 ```
 
 Vim plugin
@@ -442,7 +506,7 @@ Advanced topics
 
 ### Performance
 
-fzf is fast, and is [getting even faster][perf]. Performance should not be
+fzf is fast and is [getting even faster][perf]. Performance should not be
 a problem in most use cases. However, you might want to be aware of the
 options that affect the performance.
 
@@ -453,7 +517,7 @@ options that affect the performance.
 - `--with-nth` makes fzf slower as fzf has to tokenize and reassemble each
   line.
 - If you absolutely need better performance, you can consider using
-  `--algo=v1` (the default being `v2`) to make fzf use faster greedy
+  `--algo=v1` (the default being `v2`) to make fzf use a faster greedy
   algorithm. However, this algorithm is not guaranteed to find the optimal
   ordering of the matches and is not recommended.
 
@@ -472,17 +536,63 @@ fzf --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort
 
 See *KEY BINDINGS* section of the man page for details.
 
+### Reloading the candidate list
+
+By binding `reload` action to a key or an event, you can make fzf dynamically
+reload the candidate list. See https://github.com/junegunn/fzf/issues/1750 for
+more details.
+
+#### 1. Update the list of processes by pressing CTRL-R
+
+```sh
+FZF_DEFAULT_COMMAND='ps -ef' \
+  fzf --bind 'ctrl-r:reload($FZF_DEFAULT_COMMAND)' \
+      --header 'Press CTRL-R to reload' --header-lines=1 \
+      --height=50% --layout=reverse
+```
+
+#### 2. Switch between sources by pressing CTRL-D or CTRL-F
+
+```sh
+FZF_DEFAULT_COMMAND='find . -type f' \
+  fzf --bind 'ctrl-d:reload(find . -type d),ctrl-f:reload($FZF_DEFAULT_COMMAND)' \
+      --height=50% --layout=reverse
+```
+
+#### 3. Interactive ripgrep integration
+
+The following example uses fzf as the selector interface for ripgrep. We bound
+`reload` action to `change` event, so every time you type on fzf, ripgrep
+process will restart with the updated query string denoted by the placeholder
+expression `{q}`. Also, note that we used `--phony` option so that fzf doesn't
+perform any secondary filtering.
+
+```sh
+INITIAL_QUERY=""
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \
+  fzf --bind "change:reload:$RG_PREFIX {q} || true" \
+      --ansi --phony --query "$INITIAL_QUERY" \
+      --height=50% --layout=reverse
+```
+
+If ripgrep doesn't find any matches, it will exit with a non-zero exit status,
+and fzf will warn you about it. To suppress the warning message, we added
+`|| true` to the command, so that it always exits with 0.
+
 ### Preview window
 
-When `--preview` option is set, fzf automatically starts external process with
+When the `--preview` option is set, fzf automatically starts an external process 
-the current line as the argument and shows the result in the split window.
+with the current line as the argument and shows the result in the split window. 
+Your `$SHELL` is used to execute the command with `$SHELL -c COMMAND`. 
+The window can be scrolled using the mouse or custom key bindings.
 
 ```bash
 # {} is replaced to the single-quoted string of the focused line
 fzf --preview 'cat {}'
 ```
 
-Since preview window is updated only after the process is complete, it's
+Since the preview window is updated only after the process is complete, it's
 important that the command finishes quickly.
 
 ```bash
@@ -490,34 +600,49 @@ important that the command finishes quickly.
 fzf --preview 'head -100 {}'
 ```
 
-Preview window supports ANSI colors, so you can use programs that
+Preview window supports ANSI colors, so you can use any program that
-syntax-highlights the content of a file.
+syntax-highlights the content of a file, such as 
-
+[Bat](https://github.com/sharkdp/bat) or
-- Highlight: http://www.andre-simon.de/doku/highlight/en/highlight.php
+[Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.php):
-- CodeRay: http://coderay.rubychan.de/
-- Rouge: https://github.com/jneen/rouge
 
 ```bash
-# Try highlight, coderay, rougify in turn, then fall back to cat
+fzf --preview 'bat --style=numbers --color=always --line-range :500 {}'
-fzf --preview '[[ $(file --mime {}) =~ binary ]] &&
-                 echo {} is a binary file ||
-                 (highlight -O ansi -l {} ||
-                  coderay {} ||
-                  rougify {} ||
-                  cat {}) 2> /dev/null | head -500'
 ```
 
-You can customize the size and position of the preview window using
+You can customize the size, position, and border of the preview window using
-`--preview-window` option. For example,
+`--preview-window` option, and the foreground and background color of it with
+`--color` option. For example,
 
 ```bash
-fzf --height 40% --reverse --preview 'file {}' --preview-window down:1
+fzf --height 40% --layout reverse --info inline --border \
+    --preview 'file {}' --preview-window down:1:noborder \
+    --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899'
 ```
 
-For more advanced examples, see [Key bindings for git with fzf][fzf-git].
+See the man page (`man fzf`) for the full list of options.
+
+For more advanced examples, see [Key bindings for git with fzf][fzf-git]
+([code](https://gist.github.com/junegunn/8b572b8d4b5eddd8b85e5f4d40f17236)).
 
 [fzf-git]: https://junegunn.kr/2016/07/fzf-git/
 
+----
+
+Since fzf is a general-purpose text filter rather than a file finder, **it is
+not a good idea to add `--preview` option to your `$FZF_DEFAULT_OPTS`**.
+
+```sh
+# *********************
+# ** DO NOT DO THIS! **
+# *********************
+export FZF_DEFAULT_OPTS='--preview "bat --style=numbers --color=always --line-range :500 {}"'
+
+# bat doesn't work with any input other than the list of files
+ps -ef | fzf
+seq 100 | fzf
+history | fzf
+```
+
 Tips
 ----
 
@@ -550,45 +675,17 @@ hidden files, use the following command:
 export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
 ```
 
-#### `git ls-tree` for fast traversal
-
-If you're running fzf in a large git repository, `git ls-tree` can boost up the
-speed of the traversal.
-
-```sh
-export FZF_DEFAULT_COMMAND='
-  (git ls-tree -r --name-only HEAD ||
-   find . -path "*/\.*" -prune -o -type f -print -o -type l -print |
-      sed s/^..//) 2> /dev/null'
-```
-
 #### Fish shell
 
-Fish shell before version 2.6.0 [doesn't allow](https://github.com/fish-shell/fish-shell/issues/1362)
+`CTRL-T` key binding of fish, unlike those of bash and zsh, will use the last
-reading from STDIN in command substitution, which means simple `vim (fzf)`
+token on the command-line as the root directory for the recursive search. For
-doesn't work as expected. The workaround for fish 2.5.0 and earlier is to use
+instance, hitting `CTRL-T` at the end of the following command-line
-the `read` fish command:
-
-```sh
-fzf | read -l result; and vim $result
-```
-
-or, for multiple results:
-
-```sh
-fzf -m | while read -l r; set result $result $r; end; and vim $result
-```
-
-The globbing system is different in fish and thus `**` completion will not work.
-However, the `CTRL-T` command will use the last token on the commandline as the
-root folder for the recursive search. For instance, hitting `CTRL-T` at the end
-of the following commandline
 
 ```sh
 ls /var/
 ```
 
-will list all files and folders under `/var/`.
+will list all files and directories under `/var/`.
 
 When using a custom `FZF_CTRL_T_COMMAND`, use the unexpanded `$dir` variable to
 make use of this feature. `$dir` defaults to `.` when the last token is not a
@@ -598,9 +695,14 @@ valid directory. Example:
 set -g FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
 ```
 
+Related projects
+----------------
+
+https://github.com/junegunn/fzf/wiki/Related-projects
+
 [License](LICENSE)
 ------------------
 
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 Junegunn Choi

bin/fzf-tmux

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # fzf-tmux: starts fzf in a tmux pane
-# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
 
 fail() {
   >&2 echo "$1"
@@ -10,6 +10,7 @@ fail() {
 fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'
 
+tmux_args=()
 args=()
 opt=""
 skip=""
@@ -20,15 +21,23 @@ term=""
 [[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
 
 help() {
-  >&2 echo 'usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+  >&2 echo 'usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
 
-  Layout
+  LAYOUT OPTIONS:
+    (default layout: -d 50%)
+
+    Popup window (requires tmux 3.2 or above):
+      -p [WIDTH[%][,HEIGHT[%]]]  (default: 50%)
+      -w WIDTH[%]
+      -h HEIGHT[%]
+      -x COL
+      -y ROW
+
+    Split pane:
       -u [HEIGHT[%]]             Split above (up)
       -d [HEIGHT[%]]             Split below (down)
       -l [WIDTH[%]]              Split left
       -r [WIDTH[%]]              Split right
-
-    (default: -d 50%)
 '
   exit
 }
@@ -47,8 +56,10 @@ while [[ $# -gt 0 ]]; do
       echo "fzf-tmux (with fzf $("$fzf" --version))"
       exit
       ;;
-    -w*|-h*|-d*|-u*|-r*|-l*)
+    -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
-      if [[ "$arg" =~ ^.[lrw] ]]; then
+      if [[ "$arg" =~ ^-[pwhxy] ]]; then
+        [[ "$opt" =~ "-K -E" ]] || opt="-K -E"
+      elif [[ "$arg" =~ ^.[lr] ]]; then
         opt="-h"
         if [[ "$arg" =~ ^.l ]]; then
           opt="$opt -d"
@@ -66,7 +77,7 @@ while [[ $# -gt 0 ]]; do
       if [[ ${#arg} -gt 2 ]]; then
         size="${arg:2}"
       else
-        if [[ "$1" =~ ^[0-9]+%?$ ]]; then
+        if [[ "$1" =~ ^[0-9%,]+$ ]] || [[ "$1" =~ ^[A-Z]$ ]]; then
           size="$1"
           shift
         else
@@ -74,7 +85,15 @@ while [[ $# -gt 0 ]]; do
         fi
       fi
 
-      if [[ "$size" =~ %$ ]]; then
+      if [[ "$arg" =~ ^-p ]]; then
+        if [[ -n "$size" ]]; then
+          w=${size%%,*}
+          h=${size##*,}
+          opt="$opt -w$w -h$h"
+        fi
+      elif [[ "$arg" =~ ^-[whxy] ]]; then
+        opt="$opt ${arg:0:2}$size"
+      elif [[ "$size" =~ %$ ]]; then
         size=${size:0:((${#size}-1))}
         if [[ -n "$swap" ]]; then
           opt="$opt -p $(( 100 - size ))"
@@ -100,6 +119,8 @@ while [[ $# -gt 0 ]]; do
       # "--" can be used to separate fzf-tmux options from fzf options to
       # avoid conflicts
       skip=1
+      tmux_args=("${args[@]}")
+      args=()
       continue
       ;;
     *)
@@ -109,17 +130,17 @@ while [[ $# -gt 0 ]]; do
   [[ -n "$skip" ]] && args+=("$arg")
 done
 
-if [[ -z "$TMUX" || "$opt" =~ ^-h && "$columns" -le 40 || ! "$opt" =~ ^-h && "$lines" -le 15 ]]; then
+if [[ -z "$TMUX" ]]; then
   "$fzf" "${args[@]}"
   exit $?
 fi
 
 # --height option is not allowed
-args+=("--no-height")
+args=("--no-height" "${args[@]}")
 
-# Handle zoomed tmux pane by moving it to a temp window
+# Handle zoomed tmux pane without popup options by moving it to a temp window
-if tmux list-panes -F '#F' | grep -q Z; then
+if [[ ! "$opt" =~ "-K -E" ]] && tmux list-panes -F '#F' | grep -q Z; then
-  zoomed=1
+  zoomed_without_popup=1
   original_window=$(tmux display-message -p "#{window_id}")
   tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - '\\;' do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
   tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
@@ -141,8 +162,8 @@ cleanup() {
     eval "tmux ${tmux_win_opts[@]}"
   fi
 
-  # Remove temp window if we were zoomed
+  # Remove temp window if we were zoomed without popup options
-  if [[ -n "$zoomed" ]]; then
+  if [[ -n "$zoomed_without_popup" ]]; then
     tmux display-message -p "#{window_id}" > /dev/null
     tmux swap-pane -t $original_window \; \
       select-window -t $original_window \; \
@@ -159,6 +180,7 @@ trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT
 
 envs="env TERM=$TERM "
+[[ "$opt" =~ "-K -E" ]] && FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
 [[ -n "$FZF_DEFAULT_OPTS"    ]] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
 [[ -n "$FZF_DEFAULT_COMMAND" ]] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
 
@@ -181,21 +203,34 @@ close="; trap - EXIT SIGINT SIGTERM $close"
 
 tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
 
+if [[ "$opt" =~ "-K -E" ]]; then
+  cat $fifo2 &
+  if [[ -n "$term" ]] || [[ -t 0 ]]; then
+    cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
+    TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux popup -d "$PWD" "${tmux_args[@]}" $opt -R "$envs bash $argsf" > /dev/null 2>&1
+  else
+    mkfifo $fifo1
+    cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; out=\$? $close; exit \$out" >> $argsf
+    cat <&0 > $fifo1 &
+    TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux popup -d "$PWD" "${tmux_args[@]}" $opt -R "$envs bash $argsf" > /dev/null 2>&1
+  fi
+  exit $?
+fi
+
 if [[ -n "$term" ]] || [[ -t 0 ]]; then
   cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash -c 'cd $(printf %q "$PWD"); exec -a fzf bash $argsf'" $swap \
+    split-window $opt "${tmux_args[@]}" "$envs bash -c 'cd $(printf %q "$PWD"); exec -a fzf bash $argsf'" $swap \
-    > /dev/null 2>&1
+    > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
 else
   mkfifo $fifo1
   cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash -c 'exec -a fzf bash $argsf'" $swap \
+    split-window $opt "${tmux_args[@]}" "$envs bash -c 'exec -a fzf bash $argsf'" $swap \
-    > /dev/null 2>&1
+    > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
   cat <&0 > $fifo1 &
 fi
 cat $fifo2
 exit "$(cat $fifo3)"
-

doc/fzf.txt

@@ -1,35 +1,97 @@
-fzf.txt	fzf	Last change: November 19 2017
+fzf.txt	fzf	Last change: April 4 2020
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
   FZF Vim integration
+    Installation
+    Summary
     :FZF[!]
       Configuration
         Examples
+          Explanation of g:fzf_colors
     fzf#run
     fzf#wrap
+    Tips
       fzf inside terminal buffer
+        Starting fzf in a popup window
         Hide statusline
-    GVim
     License
 
 FZF VIM INTEGRATION                                        *fzf-vim-integration*
 ==============================================================================
 
-This repository only enables basic integration with Vim. If you're looking for
-more, check out {fzf.vim}{1} project.
 
-(Note: To use fzf in GVim, an external terminal emulator is required.)
+INSTALLATION                                                  *fzf-installation*
+==============================================================================
 
-                                       {1} https://github.com/junegunn/fzf.vim
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to 'runtimepath' in your Vim configuration file. The path may differ
+depending on the package manager.
+>
+    " If installed using Homebrew
+    set rtp+=/usr/local/opt/fzf
+
+    " If installed using git
+    set rtp+=~/.fzf
+<
+If you use {vim-plug}{1}, the same can be written as:
+>
+    " If installed using Homebrew
+    Plug '/usr/local/opt/fzf'
+
+    " If installed using git
+    Plug '~/.fzf'
+<
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+>
+    Plug 'junegunn/fzf'
+<
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+                                                                   *fzf#install*
+>
+    Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+<
+                                      {1} https://github.com/junegunn/vim-plug
+
+
+SUMMARY                                                            *fzf-summary*
+==============================================================================
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+ 1. `fzf#run([spec dict])`
+   - Starts fzf inside Vim with the given spec
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
+   - Takes a spec for `fzf#run` and returns an extended version of it with
+     additional options for addressing global preferences (`g:fzf_xxx`)
+     - `:echo fzf#wrap({'source': 'ls'})`
+   - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
+   - Basic fuzzy file selector
+   - A reference implementation for those who don't want to write VimScript to
+     implement custom commands
+   - If you're looking for more such commands, check out {fzf.vim}{2} project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
+
+                                       {2} https://github.com/junegunn/fzf.vim
 
 
 :FZF[!]
 ==============================================================================
 
                                                                           *:FZF*
-
-If you have set up fzf for Vim, `:FZF` command will be added.
 >
     " Look for files under current directory
     :FZF
@@ -37,8 +99,8 @@ If you have set up fzf for Vim, `:FZF` command will be added.
     " Look for files under your home directory
     :FZF ~
 
-    " With options
+    " With fzf command-line options
-    :FZF --no-sort --reverse --inline-info /tmp
+    :FZF --reverse --info=inline /tmp
 
     " Bang version starts fzf in fullscreen mode
     :FZF!
@@ -56,8 +118,7 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
 < Configuration >_____________________________________________________________~
                                                              *fzf-configuration*
 
-       *g:fzf_action* *g:fzf_layout* *g:fzf_colors* *g:fzf_history_dir* *g:fzf_launcher*
+                      *g:fzf_action* *g:fzf_layout* *g:fzf_colors* *g:fzf_history_dir*
-                                                                *g:Fzf_launcher*
 
  - `g:fzf_action`
    - Customizable extra key bindings for opening selected files in different
@@ -68,9 +129,6 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
    - Customizes fzf colors to match the current color scheme
  - `g:fzf_history_dir`
    - Enables history feature
- - `g:fzf_launcher`
-   - (Only in GVim) Terminal emulator to open fzf with
-   - `g:Fzf_launcher` for function reference
 
 
 Examples~
@@ -96,15 +154,17 @@ Examples~
       \ 'ctrl-v': 'vsplit' }
 
     " Default fzf layout
-    " - down / up / left / right
+    " - down / up / left / right / window
     let g:fzf_layout = { 'down': '~40%' }
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
     " You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
     let g:fzf_layout = { 'window': 'enew' }
     let g:fzf_layout = { 'window': '-tabnew' }
-    let g:fzf_layout = { 'window': '10split enew' }
+    let g:fzf_layout = { 'window': '10new' }
 
     " Customize fzf colors to match your color scheme
+    " - fzf#wrap translates this to a set of `--color` options
     let g:fzf_colors =
     \ { 'fg':      ['fg', 'Normal'],
       \ 'bg':      ['bg', 'Normal'],
@@ -120,22 +180,109 @@ Examples~
       \ 'spinner': ['fg', 'Label'],
       \ 'header':  ['fg', 'Comment'] }
 
-    " Enable per-command history.
+    " Enable per-command history
-    " CTRL-N and CTRL-P will be automatically bound to next-history and
+    " - History files will be stored in the specified directory
-    " previous-history instead of down and up. If you don't like the change,
+    " - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
-    " explicitly bind the keys to down and up in your $FZF_DEFAULT_OPTS.
+    "   'previous-history' instead of 'down' and 'up'.
     let g:fzf_history_dir = '~/.local/share/fzf-history'
 <
 
-FZF#RUN                                                                *fzf#run*
+Explanation of g:fzf_colors~
+                                                 *fzf-explanation-of-gfzfcolors*
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+>
+    element: [ component, group1 [, group2, ...] ]
+<
+ - `element` is an fzf element to apply a color to:
+
+ ----------------------+------------------------------------------------------
+ Element               | Description                                          ~
+ ----------------------+------------------------------------------------------
+  `fg`   /  `bg`   /  `hl`   | Item (foreground / background / highlight)
+  `fg+`  /  `bg+`  /  `hl+`  | Current item (foreground / background / highlight)
+  `hl`   /  `hl+`          | Highlighted substrings (normal / current)
+  `gutter`               | Background of the gutter on the left
+  `pointer`              | Pointer to the current line ( `>` )
+  `marker`               | Multi-select marker ( `>` )
+  `border`               | Border around the window ( `--border`  and  `--preview` )
+  `header`               | Header ( `--header`  or  `--header-lines` )
+  `info`                 | Info line (match counters)
+  `spinner`              | Streaming input indicator
+  `prompt`               | Prompt before query ( `> ` )
+ ----------------------+------------------------------------------------------
+ - `component` specifies the component (`fg` / `bg`) from which to extract the
+   color when considering each of the following highlight groups
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+   order) for a matching color definition
+
+For example, consider the following specification:
+>
+      'prompt':  ['fg', 'Conditional', 'Comment'],
+<
+This means we color the prompt - using the `fg` attribute of the `Conditional`
+if it exists, - otherwise use the `fg` attribute of the `Comment` highlight
+group if it exists, - otherwise fall back to the default color settings for
+the prompt.
+
+You can examine the color option generated according the setting by printing
+the result of `fzf#wrap()` function like so:
+>
+    :echo fzf#wrap()
+<
+
+FZF#RUN
 ==============================================================================
 
-For more advanced uses, you can use `fzf#run([options])` function with the
+                                                                       *fzf#run*
-following options.
 
- ---------------------------+---------------+--------------------------------------------------------------
+`fzf#run()` function is the core of Vim integration. It takes a single
+dictionary argument, a spec, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+>
+    call fzf#run({'sink': 'e'})
+<
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
+>
+    call fzf#run({'sink': 'tabedit'})
+<
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
+>
+    call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+<
+fzf options can be specified as `options` entry in spec dictionary.
+>
+    call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+<
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+>
+    " up / down / left / right / window are allowed
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+<
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color schemes
+as the source to implement a color scheme selector.
+>
+    call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+                \               'fnamemodify(v:val, ":t:r")'),
+                \ 'sink': 'colo', 'left': '25%'})
+<
+The following table summarizes the available options.
+
+ ---------------------------+---------------+----------------------------------------------------------------------
  Option name                | Type          | Description                                                          ~
- ---------------------------+---------------+--------------------------------------------------------------
+ ---------------------------+---------------+----------------------------------------------------------------------
   `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
   `source`                    | list          | Vim list as input to fzf
   `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
@@ -143,84 +290,160 @@ following options.
   `sink*`                     | funcref       | Similar to  `sink` , but takes the list of output lines at once
   `options`                   | string/list   | Options to fzf
   `dir`                       | string        | Working directory
-  `up` / `down` / `left` / `right`  | number/string | Use tmux pane with the given size (e.g.  `20` ,  `50%` )
+  `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
-  `window`  (Vim 8 / Neovim)  | string        | Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
-  `launcher`                  | string        | External terminal emulator to start fzf with (GVim only)
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
-  `launcher`                  | funcref       | Function for generating  `launcher`  string (GVim only)
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
- ---------------------------+---------------+--------------------------------------------------------------
+ ---------------------------+---------------+----------------------------------------------------------------------
 
 `options` entry can be either a string or a list. For simple cases, string
-should suffice, but prefer to use list type if you're concerned about escaping
+should suffice, but prefer to use list type to avoid escaping issues.
-issues on different platforms.
 >
     call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
     call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
 <
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
 
-FZF#WRAP                                                              *fzf#wrap*
+ - Required:
+   - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+   - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+ - Optional:
+   - `yoffset` [float default 0.5 range [0 ~ 1]]
+   - `xoffset` [float default 0.5 range [0 ~ 1]]
+   - `highlight` [string default `'Comment'`]: Highlight group for border
+   - `border` [string default `rounded`]: Border style
+     - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right`
+
+
+FZF#WRAP
 ==============================================================================
 
-`fzf#wrap([name string,] [opts dict,] [fullscreen boolean])` is a helper
+                                                                      *fzf#wrap*
-function that decorates the options dictionary so that it understands
+
-`g:fzf_layout`, `g:fzf_action`, `g:fzf_colors`, and `g:fzf_history_dir` like
+We have seen that several aspects of `:FZF` command can be configured with a
-`:FZF`.
+set of global option variables; different ways to open files (`g:fzf_action`),
+window position and size (`g:fzf_layout`), color palette (`g:fzf_colors`),
+etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
+`fzf#run`.
+
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+   - All arguments are optional. Usually we only need to pass a spec
+     dictionary.
+   - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
+     is not defined.
+   - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also a
+dictionary) with additional options for addressing global preferences. You can
+examine the return value of it like so:
 >
-    command! -bang MyStuff
+    echo fzf#wrap({'source': 'ls'})
-      \ call fzf#run(fzf#wrap('my-stuff', {'dir': '~/my-stuff'}, <bang>0))
+<
+After we "wrap" our spec, we pass it to `fzf#run`.
+>
+    call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Now it supports CTRL-T, CTRL-V, and CTRL-X key bindings and it opens fzf
+window according to `g:fzf_layout` setting.
+
+To make it easier to use, let's define `LS` command.
+>
+    command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use <bang> value to set the
+last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
+>
+    " On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+    command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+<
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+>
+    command! -bang -complete=dir -nargs=* LS
+        \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+<
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign a
+unique name to our command and pass it as the first argument to `fzf#wrap`.
+>
+    " The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+    " The name is ignored if g:fzf_history_dir is not defined.
+    command! -bang -complete=dir -nargs=* LS
+        \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
 <
 
-FZF INSIDE TERMINAL BUFFER                          *fzf-inside-terminal-buffer*
+TIPS                                                                  *fzf-tips*
 ==============================================================================
 
+
+< fzf inside terminal buffer >________________________________________________~
+                                                    *fzf-inside-terminal-buffer*
+
 The latest versions of Vim and Neovim include builtin terminal emulator
 (`:terminal`) and fzf will start in a terminal buffer in the following cases:
 
  - On Neovim
  - On GVim
- - On Terminal Vim with the non-default layout
+ - On Terminal Vim with a non-default layout
    - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
 
 
-< Hide statusline >___________________________________________________________~
+Starting fzf in a popup window~
+                                            *fzf-starting-fzf-in-a-popup-window*
+>
+    " Required:
+    " - width [float range [0 ~ 1]]
+    " - height [float range [0 ~ 1]]
+    "
+    " Optional:
+    " - xoffset [float default 0.5 range [0 ~ 1]]
+    " - yoffset [float default 0.5 range [0 ~ 1]]
+    " - highlight [string default 'Comment']: Highlight group for border
+    " - border [string default 'rounded']: Border style
+    "   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+<
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting fzf-tmux options in `tmux` key.
+>
+    " See `man fzf-tmux` for available options
+    if exists('$TMUX')
+      let g:fzf_layout = { 'tmux': '-p90%,60%' }
+    else
+      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+    endif
+<
+
+Hide statusline~
                                                            *fzf-hide-statusline*
 
-When fzf starts in a terminal buffer, you may want to hide the statusline of
+When fzf starts in a terminal buffer, the file type of the buffer is set to
-the containing buffer.
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you use a non-popup layout (e.g. `{'down': '40%'}`) on
+Neovim, you might want to temporarily disable the statusline for a cleaner
+look.
 >
+    if has('nvim') && !exists('g:fzf_layout')
       autocmd! FileType fzf
       autocmd  FileType fzf set laststatus=0 noshowmode noruler
         \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+    endif
 <
 
-GVIM                                                                  *fzf-gvim*
-==============================================================================
-
-With the latest version of GVim, fzf will start inside the builtin terminal
-emulator of Vim. Please note that this terminal feature of Vim is still young
-and unstable and you may run into some issues.
-
-If you have an older version of GVim, you need an external terminal emulator
-to start fzf with. `xterm` command is used by default, but you can customize
-it with `g:fzf_launcher`.
->
-    " This is the default. %s is replaced with fzf command
-    let g:fzf_launcher = 'xterm -e bash -ic %s'
-
-    " Use urxvt instead
-    let g:fzf_launcher = 'urxvt -geometry 120x30 -e sh -c %s'
-<
-If you're running MacVim on OSX, I recommend you to use iTerm2 as the
-launcher. Refer to the {this wiki page}{3} to see how to set up.
-
-                {3} https://github.com/junegunn/fzf/wiki/On-MacVim-with-iTerm2
-
-
 LICENSE                                                            *fzf-license*
 ==============================================================================
 
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 Junegunn Choi
 
 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

glide.lock

@@ -1,134 +0,0 @@
-hash: 92a208bfbaecdf8d1ccaf99a465884c49f9cd91f44f1756d7bbf3290795c781b
-updated: 2017-12-03T13:37:23.420874333+09:00
-imports:
-- name: github.com/bjwbell/gensimd
-  version: 06eb18285485c0d572cc7f024050fc6cb652ed4c
-  subpackages:
-  - simd
-- name: github.com/codegangsta/cli
-  version: c6af8847eb2b7b297d07c3ede98903e95e680ef9
-- name: github.com/gdamore/encoding
-  version: b23993cbb6353f0e6aa98d0ee318a34728f628b9
-- name: github.com/gdamore/tcell
-  version: 0a0db94084dfe181108c18508ebd312f12d331fb
-  subpackages:
-  - encoding
-- name: github.com/lucasb-eyer/go-colorful
-  version: c900de9dbbc73129068f5af6a823068fc5f2308c
-- name: github.com/Masterminds/semver
-  version: 15d8430ab86497c5c0da827b748823945e1cf1e1
-- name: github.com/Masterminds/vcs
-  version: 6f1c6d150500e452704e9863f68c2559f58616bf
-- name: github.com/mattn/go-isatty
-  version: 66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8
-- name: github.com/mattn/go-runewidth
-  version: 14207d285c6c197daabb5c9793d63e7af9ab2d50
-- name: github.com/mattn/go-shellwords
-  version: 02e3cf038dcea8290e44424da473dd12be796a8a
-- name: github.com/mengzhuo/intrinsic
-  version: 34b800838e0bcd9c5b6abd414e3ad03dc1a686b8
-  subpackages:
-  - sse2
-- name: github.com/mitchellh/go-homedir
-  version: b8bc1bf767474819792c23f32d8286a45736f1c6
-- name: golang.org/x/crypto
-  version: e1a4589e7d3ea14a3352255d04b6f1a418845e5e
-  subpackages:
-  - acme
-  - blowfish
-  - cast5
-  - chacha20poly1305/internal/chacha20
-  - curve25519
-  - ed25519
-  - ed25519/internal/edwards25519
-  - hkdf
-  - nacl/secretbox
-  - openpgp
-  - openpgp/armor
-  - openpgp/elgamal
-  - openpgp/errors
-  - openpgp/packet
-  - openpgp/s2k
-  - pbkdf2
-  - pkcs12/internal/rc2
-  - poly1305
-  - ripemd160
-  - salsa20/salsa
-  - ssh
-  - ssh/agent
-  - ssh/terminal
-  - ssh/testdata
-- name: golang.org/x/net
-  version: a8b9294777976932365dabb6640cf1468d95c70f
-  subpackages:
-  - context
-  - context/ctxhttp
-- name: golang.org/x/sys
-  version: b90f89a1e7a9c1f6b918820b3daa7f08488c8594
-  subpackages:
-  - unix
-- name: golang.org/x/text
-  version: 4ee4af566555f5fbe026368b75596286a312663a
-  subpackages:
-  - cases
-  - collate
-  - collate/build
-  - currency
-  - encoding
-  - encoding/charmap
-  - encoding/ianaindex
-  - encoding/internal
-  - encoding/internal/identifier
-  - encoding/japanese
-  - encoding/korean
-  - encoding/simplifiedchinese
-  - encoding/traditionalchinese
-  - encoding/unicode
-  - encoding/unicode/utf32
-  - internal
-  - internal/colltab
-  - internal/format
-  - internal/gen
-  - internal/stringset
-  - internal/tag
-  - internal/testtext
-  - internal/triegen
-  - internal/ucd
-  - internal/utf8internal
-  - language
-  - language/display
-  - message
-  - runes
-  - secure/bidirule
-  - transform
-  - unicode/bidi
-  - unicode/cldr
-  - unicode/norm
-  - unicode/rangetable
-  - width
-- name: golang.org/x/tools
-  version: 04447353bc504b9a5c02eb227b9ecd252e64ea20
-  subpackages:
-  - go/ast/astutil
-  - go/buildutil
-  - go/loader
-- name: gopkg.in/yaml.v2
-  version: 287cf08546ab5e7e37d55a84f7ed3fd1db036de5
-testImports:
-- name: github.com/gopherjs/gopherjs
-  version: 444abdf920945de5d4a977b572bcc6c674d1e4eb
-  subpackages:
-  - js
-- name: github.com/jtolds/gls
-  version: 77f18212c9c7edc9bd6a33d383a7b545ce62f064
-- name: github.com/smartystreets/assertions
-  version: 0b37b35ec7434b77e77a4bb29b79677cced992ea
-  subpackages:
-  - internal/go-render/render
-  - internal/oglematchers
-- name: github.com/smartystreets/goconvey
-  version: e5b2b7c9111590d019a696c7800593f666e1a7f4
-  subpackages:
-  - convey
-  - convey/gotest
-  - convey/reporting

glide.yaml

@@ -1,16 +0,0 @@
-package: github.com/junegunn/fzf
-import:
-- package: github.com/mattn/go-isatty
-  version: 66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8
-- package: github.com/mattn/go-runewidth
-  version: 14207d285c6c197daabb5c9793d63e7af9ab2d50
-- package: github.com/mattn/go-shellwords
-  version: 02e3cf038dcea8290e44424da473dd12be796a8a
-- package: github.com/gdamore/tcell
-  version: 0a0db94084dfe181108c18508ebd312f12d331fb
-  subpackages:
-  - encoding
-- package: golang.org/x/crypto
-  version: e1a4589e7d3ea14a3352255d04b6f1a418845e5e
-  subpackages:
-  - ssh/terminal

go.mod

@@ -0,0 +1,15 @@
+module github.com/junegunn/fzf
+
+require (
+	github.com/gdamore/tcell v1.4.0
+	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
+	github.com/mattn/go-isatty v0.0.12
+	github.com/mattn/go-runewidth v0.0.8
+	github.com/mattn/go-shellwords v1.0.9
+	github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e
+	golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d
+	golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5
+	golang.org/x/text v0.3.2 // indirect
+)
+
+go 1.13

go.sum

@@ -0,0 +1,45 @@
+github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
+github.com/lucasb-eyer/go-colorful v1.0.2 h1:mCMFu6PgSozg9tDNMMK3g18oJBX7oYGrC09mS6CXfO4=
+github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
+github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
+github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-shellwords v1.0.9 h1:eaB5JspOwiKKcHdqcjbfe5lA9cNn/4NRRtddXJCimqk=
+github.com/mattn/go-shellwords v1.0.9/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e h1:NO86zOn5ScSKW8wRbMaSIcjDZUFpWdCQQnexRqZ9h9A=
+github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e/go.mod h1:G0Z6yVPru183i2MuRJx1DcR4dgIZtLcTdaaE/pC1BJU=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d h1:9FCpayM9Egr1baVnV1SX0H87m+XB0B8S0hAMi99X/3U=
+golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756 h1:9nuHUbU8dRnRRfj9KjWUVrJeoexdbeMjttk6Oh1rD10=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 h1:LfCXLvNmTYH9kEmVgqbnsWfruoXZIrh4YBgqVHtDvw0=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191011211836-4c025a95b26e h1:1o2bDs9pCd2xFhdwqJTrCIswAeEsn4h/PCNelWpfcsI=
+golang.org/x/tools v0.0.0-20191011211836-4c025a95b26e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -2,12 +2,11 @@
 
 set -u
 
-version=0.17.4
+version=0.23.0
 auto_completion=
 key_bindings=
 update_config=2
 binary_arch=
-allow_legacy=
 shells="bash zsh fish"
 prefix='~/.fzf'
 prefix_expand=~/.fzf
@@ -29,9 +28,6 @@ usage: $0 [OPTIONS]
     --no-bash            Do not set up bash configuration
     --no-zsh             Do not set up zsh configuration
     --no-fish            Do not set up fish configuration
-
-    --32                 Download 32-bit binary
-    --64                 Download 64-bit binary
 EOF
 }
 
@@ -45,7 +41,6 @@ for opt in "$@"; do
       auto_completion=1
       key_bindings=1
       update_config=1
-      allow_legacy=1
       ;;
     --xdg)
       prefix='"${XDG_CONFIG_HOME:-$HOME/.config}"/fzf/fzf'
@@ -58,8 +53,6 @@ for opt in "$@"; do
     --no-completion)   auto_completion=0 ;;
     --update-rc)       update_config=1   ;;
     --no-update-rc)    update_config=0   ;;
-    --32)              binary_arch=386   ;;
-    --64)              binary_arch=amd64 ;;
     --bin)             ;;
     --no-bash)         shells=${shells/bash/} ;;
     --no-zsh)          shells=${shells/zsh/} ;;
@@ -73,7 +66,8 @@ for opt in "$@"; do
 done
 
 cd "$(dirname "${BASH_SOURCE[0]}")"
-fzf_base="$(pwd)"
+fzf_base=$(pwd)
+fzf_base_esc=$(printf %q "$fzf_base")
 
 ask() {
   while true; do
@@ -90,11 +84,13 @@ ask() {
 check_binary() {
   echo -n "  - Checking fzf executable ... "
   local output
-  output=$("$fzf_base"/bin/fzf --version 2>&1 | awk '{print $1}')
+  output=$("$fzf_base"/bin/fzf --version 2>&1)
   if [ $? -ne 0 ]; then
     echo "Error: $output"
     binary_error="Invalid binary"
-  elif [ "$version" != "$output" ]; then
+  else
+    output=${output/ */}
+    if [ "$version" != "$output" ]; then
       echo "$output != $version"
       binary_error="Invalid version"
     else
@@ -102,6 +98,7 @@ check_binary() {
       binary_error=""
       return 0
     fi
+  fi
   rm -f "$fzf_base"/bin/fzf
   return 1
 }
@@ -109,7 +106,7 @@ check_binary() {
 link_fzf_in_path() {
   if which_fzf="$(command -v fzf)"; then
     echo "  - Found in \$PATH"
-    echo "  - Creating symlink: $which_fzf -> bin/fzf"
+    echo "  - Creating symlink: bin/fzf -> $which_fzf"
     (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
     check_binary && return
   fi
@@ -177,21 +174,18 @@ binary_available=1
 binary_error=""
 case "$archi" in
   Darwin\ *64)   download fzf-$version-darwin_${binary_arch:-amd64}.tgz  ;;
-  Darwin\ *86)   download fzf-$version-darwin_${binary_arch:-386}.tgz    ;;
   Linux\ armv5*) download fzf-$version-linux_${binary_arch:-arm5}.tgz    ;;
   Linux\ armv6*) download fzf-$version-linux_${binary_arch:-arm6}.tgz    ;;
   Linux\ armv7*) download fzf-$version-linux_${binary_arch:-arm7}.tgz    ;;
   Linux\ armv8*) download fzf-$version-linux_${binary_arch:-arm8}.tgz    ;;
   Linux\ aarch64*) download fzf-$version-linux_${binary_arch:-arm8}.tgz  ;;
   Linux\ *64)    download fzf-$version-linux_${binary_arch:-amd64}.tgz   ;;
-  Linux\ *86)    download fzf-$version-linux_${binary_arch:-386}.tgz     ;;
   FreeBSD\ *64)  download fzf-$version-freebsd_${binary_arch:-amd64}.tgz ;;
-  FreeBSD\ *86)  download fzf-$version-freebsd_${binary_arch:-386}.tgz   ;;
   OpenBSD\ *64)  download fzf-$version-openbsd_${binary_arch:-amd64}.tgz ;;
-  OpenBSD\ *86)  download fzf-$version-openbsd_${binary_arch:-386}.tgz   ;;
   CYGWIN*\ *64)  download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
-  MINGW*\ *86)   download fzf-$version-windows_${binary_arch:-386}.zip   ;;
   MINGW*\ *64)   download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
+  MSYS*\ *64)    download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
+  Windows*\ *64) download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
   *)             binary_available=0 binary_error=1 ;;
 esac
 
@@ -265,8 +259,8 @@ for shell in $shells; do
   cat > "$src" << EOF
 # Setup fzf
 # ---------
-if [[ ! "\$PATH" == *$fzf_base/bin* ]]; then
+if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
-  export PATH="\$PATH:$fzf_base/bin"
+  export PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
 fi
 
 # Auto-completion
@@ -276,7 +270,6 @@ $fzf_completion
 # Key bindings
 # ------------
 $fzf_key_bindings
-
 EOF
   echo "OK"
 done
@@ -285,8 +278,8 @@ done
 if [[ "$shells" =~ fish ]]; then
   echo -n "Update fish_user_paths ... "
   fish << EOF
-  echo \$fish_user_paths | \grep $fzf_base/bin > /dev/null
+  echo \$fish_user_paths | \grep "$fzf_base"/bin > /dev/null
-  or set --universal fish_user_paths \$fish_user_paths $fzf_base/bin
+  or set --universal fish_user_paths \$fish_user_paths "$fzf_base"/bin
 EOF
   [ $? -eq 0 ] && echo "OK" || echo "Failed"
 
@@ -379,7 +372,11 @@ fi
 
 if [ $update_config -eq 1 ]; then
   echo 'Finished. Restart your shell or reload config file.'
-  [[ "$shells" =~ bash ]] && echo '   source ~/.bashrc  # bash'
+  if [[ "$shells" =~ bash ]]; then
+    echo -n '   source ~/.bashrc  # bash'
+    [[ "$archi" =~ Darwin ]] && echo -n '  (.bashrc should be loaded from .bash_profile)'
+    echo
+  fi
   [[ "$shells" =~ zsh ]]  && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
   [[ "$shells" =~ fish ]] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
   echo

install.ps1

@@ -0,0 +1,73 @@
+$version="0.23.0"
+
+if ([Environment]::Is64BitProcess) {
+  $binary_arch="amd64"
+} else {
+  $binary_arch="386"
+}
+
+$fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
+
+function check_binary () {
+  Write-Host "  - Checking fzf executable ... " -NoNewline
+  $output=cmd /c $fzf_base\bin\fzf.exe --version 2>&1
+  if (-not $?) {
+    Write-Host "Error: $output"
+    $binary_error="Invalid binary"
+  } else {
+    $output=(-Split $output)[0]
+    if ($version -ne $output) {
+      Write-Host "$output != $version"
+      $binary_error="Invalid version"
+    } else {
+      Write-Host "$output"
+      $binary_error=""
+      return 1
+    }
+  }
+  Remove-Item "$fzf_base\bin\fzf.exe"
+  return 0
+}
+
+function download {
+  param($file)
+  Write-Host "Downloading bin/fzf ..."
+  if ("$version" -ne "alpha") {
+    if (Test-Path "$fzf_base\bin\fzf.exe") {
+      Write-Host "  - Already exists"
+      if (check_binary) {
+        return
+      }
+    }
+  }
+  if (-not (Test-Path "$fzf_base\bin")) {
+    md "$fzf_base\bin"
+  }
+  if (-not $?) {
+    $binary_error="Failed to create bin directory"
+    return
+  }
+  cd "$fzf_base\bin"
+  if ("$version" -eq "alpha") {
+    $url="https://github.com/junegunn/fzf-bin/releases/download/alpha/$file"
+  } else {
+    $url="https://github.com/junegunn/fzf-bin/releases/download/$version/$file"
+  }
+  $temp=$env:TMP + "\fzf.zip"
+  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+  (New-Object Net.WebClient).DownloadFile($url, $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("$temp"))
+  if ($?) {
+    (Microsoft.PowerShell.Archive\Expand-Archive -Path $temp -DestinationPath .); (Remove-Item $temp)
+  } else {
+    $binary_error="Failed to download with powershell"
+  }
+  if (-not (Test-Path fzf.exe)) {
+    $binary_error="Failed to download $file"
+    return
+  }
+  check_binary >$null
+}
+
+download "fzf-$version-windows_$binary_arch.zip"
+
+Write-Host 'For more information, see: https://github.com/junegunn/fzf'

main.go

@@ -1,9 +1,13 @@
 package main
 
-import "github.com/junegunn/fzf/src"
+import (
+	"github.com/junegunn/fzf/src"
+	"github.com/junegunn/fzf/src/protector"
+)
 
 var revision string
 
 func main() {
+	protector.Protect()
 	fzf.Run(fzf.ParseOptions(), revision)
 }

man/man1/fzf-tmux.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 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
@@ -21,25 +21,39 @@ 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 "Jun 2018" "fzf 0.17.4" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Oct 2020" "fzf 0.23.0" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane
 
 .SH SYNOPSIS
-.B fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+.B fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
 
 .SH DESCRIPTION
-fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane. It is
+fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
-designed to work just like fzf except that it does not take up the whole
+a tmux popup window. It is designed to work just like fzf except that it does
-screen. You can safely use fzf-tmux instead of fzf in your scripts as the extra
+not take up the whole screen. You can safely use fzf-tmux instead of fzf in
-options will be silently ignored if you're not on tmux.
+your scripts as the extra options will be silently ignored if you're not on
+tmux.
 
-.SH OPTIONS
+.SH LAYOUT OPTIONS
-.SS Layout
 
-(default: \fB-d 50%\fR)
+(default layout: \fB-d 50%\fR)
 
+.SS Popup window
+(requires tmux 3.2 or above)
+.TP
+.B "-p [WIDTH[%][,HEIGHT[%]]]"
+.TP
+.B "-w WIDTH[%]"
+.TP
+.B "-h WIDTH[%]"
+.TP
+.B "-x COL"
+.TP
+.B "-y ROW"
+
+.SS Split pane
 .TP
 .B "-u [height[%]]"
 Split above (up)

man/man1/fzf.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 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
@@ -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 "Jun 2018" "fzf 0.17.4" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Oct 2020" "fzf 0.23.0" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -70,6 +70,10 @@ Transform the presentation of each line using field index expressions
 .TP
 .BI "-d, --delimiter=" "STR"
 Field delimiter regex for \fB--nth\fR and \fB--with-nth\fR (default: AWK-style)
+.TP
+.BI "--phony"
+Do not perform search. With this option, fzf becomes a simple selector
+interface rather than a "fuzzy finder".
 .SS Search result
 .TP
 .B "+s, --no-sort"
@@ -79,7 +83,8 @@ Do not sort the result
 Reverse the order of the input
 
 .RS
-e.g. \fBhistory | fzf --tac --no-sort\fR
+e.g.
+     \fBhistory | fzf --tac --no-sort\fR
 .RE
 .TP
 .BI "--tiebreak=" "CRI[,..]"
@@ -109,7 +114,8 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .SS Interface
 .TP
 .B "-m, --multi"
-Enable multi-select with tab/shift-tab
+Enable multi-select with tab/shift-tab. It optionally takes an integer argument
+which denotes the maximum number of items that can be selected.
 .TP
 .B "+m, --no-multi"
 Disable multi-select
@@ -118,12 +124,16 @@ Disable multi-select
 Disable mouse
 .TP
 .BI "--bind=" "KEYBINDS"
-Comma-separated list of custom key bindings. See \fBKEY BINDINGS\fR for the
+Comma-separated list of custom key bindings. See \fBKEY/EVENT BINDINGS\fR for
-details.
+the details.
 .TP
 .B "--cycle"
 Enable cyclic scroll
 .TP
+.B "--keep-right"
+Keep the right end of the line visible when it's too long. Effective only when
+the query string is empty.
+.TP
 .B "--no-hscroll"
 Disable horizontal scroll
 .TP
@@ -172,8 +182,21 @@ Choose the layout (default: default)
 A synonym for \fB--layout=reverse\fB
 
 .TP
-.B "--border"
+.BI "--border" [=STYLE]
-Draw border above and below the finder
+Draw border around the finder
+
+.br
+.BR rounded "     Border with rounded corners (default)"
+.br
+.BR sharp "       Border with sharp corners"
+.br
+.BR horizontal "  Horizontal lines above and below the finder"
+.br
+
+.TP
+.B "--no-unicode"
+Use ASCII characters instead of Unicode box drawing characters to draw border
+
 .TP
 .BI "--margin=" MARGIN
 Comma-separated expression for margins around the finder.
@@ -196,16 +219,36 @@ terminal size with \fB%\fR suffix.
 .br
 
 .br
-e.g. \fBfzf --margin 10%\fR
+e.g.
-     \fBfzf --margin 1,5%\fR
+     \fBfzf --margin 10%
+     fzf --margin 1,5%\fR
 .RE
 .TP
-.B "--inline-info"
+.BI "--info=" "STYLE"
-Display finder info inline with the query
+Determines the display style of finder info.
+
+.br
+.BR default "       Display on the next line to the prompt"
+.br
+.BR inline "        Display on the same line"
+.br
+.BR hidden "        Do not display finder info"
+.br
+
+.TP
+.B "--no-info"
+A synonym for \fB--info=hidden\fB
+
 .TP
 .BI "--prompt=" "STR"
 Input prompt (default: '> ')
 .TP
+.BI "--pointer=" "STR"
+Pointer to the current line (default: '>')
+.TP
+.BI "--marker=" "STR"
+Multi-select marker (default: '>')
+.TP
 .BI "--header=" "STR"
 The given string will be printed as the sticky header. The lines are displayed
 in the given order from top to bottom regardless of \fB--layout\fR option, and
@@ -230,11 +273,6 @@ 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.
 
-.RS
-e.g. \fBfzf --color=bg+:24\fR
-     \fBfzf --color=light,fg:232,bg:255,bg+:116,info:27\fR
-.RE
-
 .RS
 .B BASE SCHEME:
     (default: dark on 256-color terminal, otherwise 16)
@@ -242,22 +280,38 @@ e.g. \fBfzf --color=bg+:24\fR
     \fBdark    \fRColor scheme for dark 256-color terminal
     \fBlight   \fRColor scheme for light 256-color terminal
     \fB16      \fRColor scheme for 16-color terminal
-    \fBbw      \fRNo colors
+    \fBbw      \fRNo colors (equivalent to \fB--no-color\fR)
 
 .B COLOR:
     \fBfg         \fRText
     \fBbg         \fRBackground
+    \fBpreview-fg \fRPreview window text
+    \fBpreview-bg \fRPreview window background
     \fBhl         \fRHighlighted substrings
     \fBfg+        \fRText (current line)
     \fBbg+        \fRBackground (current line)
+    \fBgutter     \fRGutter on the left (defaults to \fBbg+\fR)
     \fBhl+        \fRHighlighted substrings (current line)
-    \fBinfo    \fRInfo
+    \fBinfo       \fRInfo line (match counters)
-    \fBborder  \fRBorder of the preview window and horizontal separators (\fB--border\fR)
+    \fBborder     \fRBorder around the window (\fB--border\fR and \fB--preview\fR)
     \fBprompt     \fRPrompt
     \fBpointer    \fRPointer to the current line
     \fBmarker     \fRMulti-select marker
     \fBspinner    \fRStreaming input indicator
     \fBheader     \fRHeader
+
+.B EXAMPLES:
+
+     \fB# Seoul256 theme with 8-bit colors
+     # (https://github.com/junegunn/seoul256.vim) 
+     fzf --color='bg:237,bg+:236,info:143,border:240,spinner:108' \\
+         --color='hl:65,fg:252,header:65,fg+:252' \\
+         --color='pointer:161,marker:168,prompt:110,hl+:108'
+
+     # Seoul256 theme with 24-bit colors
+     fzf --color='bg:#4B4B4B,bg+:#3F3F3F,info:#BDBB72,border:#6B6B6B,spinner:#98BC99' \\
+         --color='hl:#719872,fg:#D9D9D9,header:#719872,fg+:#D9D9D9' \\
+         --color='pointer:#E12672,marker:#E17899,prompt:#98BEDE,hl+:#98BC99'\fR
 .RE
 .TP
 .B "--no-bold"
@@ -285,23 +339,41 @@ string, specify field index expressions between the braces (See \fBFIELD INDEX
 EXPRESSION\fR for the details).
 
 .RS
-e.g. \fBfzf --preview='head -$LINES {}'\fR
+e.g.
-     \fBls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
+     \fBfzf --preview='head -$LINES {}'
+     ls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
 
-fzf overrides \fB$LINES\fR and \fB$COLUMNS\fR so that they represent the exact
+fzf exports \fB$FZF_PREVIEW_LINES\fR and \fB$FZF_PREVIEW_COLUMNS\fR so that
-size of the preview window.
+they represent the exact size of the preview window. (It also overrides
+\fB$LINES\fR and \fB$COLUMNS\fR with the same values but they can be reset
+by the default shell, so prefer to refer to the ones with \fBFZF_PREVIEW_\fR
+prefix.)
 
 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
+e.g.
-     \fBgit log --oneline | fzf --multi --preview 'git show {+1}'\fR
+     \fBfzf --multi --preview='head -10 {+}'
+     git log --oneline | fzf --multi --preview 'git show {+1}'\fR
 
 When using a field index expression, leading and trailing whitespace is stripped
 from the replacement string. To preserve the whitespace, use the \fBs\fR flag.
 
-Also, \fB{q}\fR is replaced to the current query string.
+Also, \fB{q}\fR is replaced to the current query string, and \fB{n}\fR is
+replaced to zero-based ordinal index of the line. Use \fB{+n}\fR if you want
+all index numbers when multiple lines are selected.
+
+A placeholder expression with \fBf\fR flag is replaced to the path of
+a temporary file that holds the evaluated list. This is useful when you
+multi-select a large number of items and the length of the evaluated string may
+exceed \fBARG_MAX\fR.
+
+e.g.
+     \fB# Press CTRL-A to select 100K items and see the sum of all the numbers.
+     # This won't work properly without 'f' flag due to ARG_MAX limit.
+     seq 100000 | fzf --multi --bind ctrl-a:select-all \\
+                      --preview "awk '{sum+=\$1} END {print sum}' {+f}"\fR
 
 Note that you can escape a placeholder pattern by prepending a backslash.
 
@@ -309,8 +381,8 @@ Preview window will be updated even when there is no match for the current
 query if any of the placeholder expressions evaluates to a non-empty string.
 .RE
 .TP
-.BI "--preview-window=" "[POSITION][:SIZE[%]][:wrap][:hidden]"
+.BI "--preview-window=" "[POSITION][:SIZE[%]][:rounded|sharp|noborder][:wrap][:hidden][:+SCROLL[-OFFSET]]"
-Determine the layout of the preview window. If the argument ends with
+Determines the layout of the preview window. If the argument contains
 \fB:hidden\fR, the preview window will be hidden by default until
 \fBtoggle-preview\fR action is triggered. Long lines are truncated by default.
 Line wrap can be enabled with \fB:wrap\fR flag.
@@ -318,6 +390,17 @@ 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.
 
+To change the style of the border of the preview window, specify one of
+\fBrounded\fR (border with rounded edges, default), \fBsharp\fR (border with
+sharp edges), or \fBnoborder\fR (no border).
+
+\fB+SCROLL[-OFFSET]\fR determines the initial scroll offset of the preview
+window. \fBSCROLL\fR can be either a numeric integer or a single-field index
+expression that refers to a numeric integer. The optional \fB-OFFSET\fR part is
+for adjusting the base offset so that you can see the text above it. It should
+be given as a numeric integer (\fB-INTEGER\fR), or as a denominator form
+(\fB-/INTEGER\fR) for specifying a fraction of the preview window height.
+
 .RS
 .B POSITION: (default: right)
     \fBup
@@ -327,8 +410,22 @@ execute the command in the background.
 .RE
 
 .RS
-e.g. \fBfzf --preview="head {}" --preview-window=up:30%\fR
+e.g.
-     \fBfzf --preview="file {}" --preview-window=down:1\fR
+     \fB# Non-default scroll window positions and sizes
+     fzf --preview="head {}" --preview-window=up:30%
+     fzf --preview="file {}" --preview-window=down:1
+
+     # Initial scroll offset is set to the line number of each line of
+     # git grep output *minus* 5 lines (-5)
+     git grep --line-number '' |
+       fzf --delimiter : --preview 'nl {1}' --preview-window +{2}-5
+
+     # Preview with bat, matching line in the middle of the window (-/2)
+     git grep --line-number '' |
+       fzf --delimiter : \\
+           --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \\
+           --preview-window +{2}-/2\fR
+
 .RE
 .SS Scripting
 .TP
@@ -358,7 +455,8 @@ times, fzf will expect the union of the keys. \fB--no-expect\fR will clear the
 list.
 
 .RS
-e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s --expect=f1,f2,~,@\fR
+e.g.
+     \fBfzf --expect=ctrl-v,ctrl-t,alt-s --expect=f1,f2,~,@\fR
 .RE
 .TP
 .B "--read0"
@@ -390,7 +488,8 @@ Note that most options have the opposite versions with \fB--no-\fR prefix.
 .SH ENVIRONMENT VARIABLES
 .TP
 .B FZF_DEFAULT_COMMAND
-Default command to use when input is tty
+Default command to use when input is tty. On *nix systems, fzf runs the command
+with \fBsh -c\fR, so make sure that it's POSIX-compliant.
 .TP
 .B FZF_DEFAULT_OPTS
 Default options. e.g. \fBexport FZF_DEFAULT_OPTS="--extended --cycle"\fR
@@ -463,56 +562,123 @@ query matches entries that start with \fBcore\fR and end with either \fBgo\fR,
 
 e.g. \fB^core go$ | rb$ | py$\fR
 
-.SH KEY BINDINGS
+.SH KEY/EVENT BINDINGS
-You can customize key bindings of fzf with \fB--bind\fR option which takes
+\fB--bind\fR option allows you to bind \fBa key\fR or \fBan event\fR to one or
-a comma-separated list of key binding expressions. Each key binding expression
+more \fBactions\fR. You can use it to customize key bindings or implement
-follows the following format: \fBKEY:ACTION\fR
+dynamic behaviors.
 
-e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
+\fB--bind\fR takes a comma-separated list of binding expressions. Each binding
+expression is \fBKEY:ACTION\fR or \fBEVENT:ACTION\fR.
 
-.B AVAILABLE KEYS:    (SYNONYMS)
+e.g.
-    \fIctrl-[a-z]\fR
+     \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
-    \fIctrl-space\fR
-    \fIctrl-alt-[a-z]\fR
-    \fIalt-[a-z]\fR
-    \fIalt-[0-9]\fR
-    \fIf[1-12]\fR
-    \fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
-    \fIspace\fR
-    \fIbspace\fR      (\fIbs\fR)
-    \fIalt-up\fR
-    \fIalt-down\fR
-    \fIalt-left\fR
-    \fIalt-right\fR
-    \fIalt-enter\fR
-    \fIalt-space\fR
-    \fIalt-bspace\fR  (\fIalt-bs\fR)
-    \fIalt-/\fR
-    \fItab\fR
-    \fIbtab\fR        (\fIshift-tab\fR)
-    \fIesc\fR
-    \fIdel\fR
-    \fIup\fR
-    \fIdown\fR
-    \fIleft\fR
-    \fIright\fR
-    \fIhome\fR
-    \fIend\fR
-    \fIpgup\fR        (\fIpage-up\fR)
-    \fIpgdn\fR        (\fIpage-down\fR)
-    \fIshift-up\fR
-    \fIshift-down\fR
-    \fIshift-left\fR
-    \fIshift-right\fR
-    \fIleft-click\fR
-    \fIright-click\fR
-    \fIdouble-click\fR
-    or any single character
 
-Additionally, a special event named \fIchange\fR is available which is
+.SS AVAILABLE KEYS:    (SYNONYMS)
-triggered whenever the query string is changed.
+\fIctrl-[a-z]\fR
+.br
+\fIctrl-space\fR
+.br
+\fIctrl-\\\fR
+.br
+\fIctrl-]\fR
+.br
+\fIctrl-^\fR      (\fIctrl-6\fR)
+.br
+\fIctrl-/\fR      (\fIctrl-_\fR)
+.br
+\fIctrl-alt-[a-z]\fR
+.br
+\fIalt-[a-z]\fR
+.br
+\fIalt-[0-9]\fR
+.br
+\fIf[1-12]\fR
+.br
+\fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
+.br
+\fIspace\fR
+.br
+\fIbspace\fR      (\fIbs\fR)
+.br
+\fIalt-up\fR
+.br
+\fIalt-down\fR
+.br
+\fIalt-left\fR
+.br
+\fIalt-right\fR
+.br
+\fIalt-enter\fR
+.br
+\fIalt-space\fR
+.br
+\fIalt-bspace\fR  (\fIalt-bs\fR)
+.br
+\fIalt-/\fR
+.br
+\fItab\fR
+.br
+\fIbtab\fR        (\fIshift-tab\fR)
+.br
+\fIesc\fR
+.br
+\fIdel\fR
+.br
+\fIup\fR
+.br
+\fIdown\fR
+.br
+\fIleft\fR
+.br
+\fIright\fR
+.br
+\fIhome\fR
+.br
+\fIend\fR
+.br
+\fIinsert\fR
+.br
+\fIpgup\fR        (\fIpage-up\fR)
+.br
+\fIpgdn\fR        (\fIpage-down\fR)
+.br
+\fIshift-up\fR
+.br
+\fIshift-down\fR
+.br
+\fIshift-left\fR
+.br
+\fIshift-right\fR
+.br
+\fIleft-click\fR
+.br
+\fIright-click\fR
+.br
+\fIdouble-click\fR
+.br
+or any single character
 
-    e.g. \fBfzf --bind change:top\fR
+.SS AVAILABLE EVENTS:
+\fIchange\fR
+.RS
+Triggered whenever the query string is changed
+
+e.g.
+     \fB# Moves cursor to the top (or bottom depending on --layout) whenever the query is changed
+     fzf --bind change:top\fR
+.RE
+
+\fIbackward-eof\fR
+.RS
+Triggered when the query string is already empty and you try to delete it
+backward.
+
+e.g.
+     \fBfzf --bind backward-eof:abort\fR
+.RE
+
+.SS AVAILABLE ACTIONS:
+A key or an event can be bound to one or more of the following actions.
 
   \fBACTION:                   DEFAULT BINDINGS (NOTES):
     \fBabort\fR                     \fIctrl-c  ctrl-g  ctrl-q  esc\fR
@@ -520,19 +686,21 @@ triggered whenever the query string is changed.
     \fBaccept-non-empty\fR          (same as \fBaccept\fR except that it prevents fzf from exiting without selection)
     \fBbackward-char\fR             \fIctrl-b  left\fR
     \fBbackward-delete-char\fR      \fIctrl-h  bspace\fR
+    \fBbackward-delete-char/eof\fR  (same as \fBbackward-delete-char\fR except aborts fzf if query is empty)
     \fBbackward-kill-word\fR        \fIalt-bs\fR
     \fBbackward-word\fR             \fIalt-b   shift-left\fR
     \fBbeginning-of-line\fR         \fIctrl-a  home\fR
-    \fBcancel\fR                (clears query string if not empty, aborts fzf otherwise)
+    \fBcancel\fR                    (clear query string if not empty, abort fzf otherwise)
     \fBclear-screen\fR              \fIctrl-l\fR
+    \fBclear-selection\fR           (clear multi-selection)
+    \fBclear-query\fR               (clear query string)
     \fBdelete-char\fR               \fIdel\fR
-    \fBdelete-char/eof\fR       \fIctrl-d\fR
+    \fBdelete-char/eof\fR           \fIctrl-d\fR (same as \fBdelete-char\fR except aborts fzf if query is empty)
-    \fBdeselect-all\fR
+    \fBdeselect-all\fR              (deselect all matches)
     \fBdown\fR                      \fIctrl-j  ctrl-n  down\fR
     \fBend-of-line\fR               \fIctrl-e  end\fR
     \fBexecute(...)\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
@@ -545,16 +713,21 @@ triggered whenever the query string is changed.
     \fBpage-up\fR                   \fIpgup\fR
     \fBhalf-page-down\fR
     \fBhalf-page-up\fR
+    \fBpreview(...)\fR              (see below for the details)
     \fBpreview-down\fR              \fIshift-down\fR
     \fBpreview-up\fR                \fIshift-up\fR
     \fBpreview-page-down\fR
     \fBpreview-page-up\fR
+    \fBpreview-half-page-down\fR
+    \fBpreview-half-page-up\fR
     \fBprevious-history\fR          (\fIctrl-p\fR on \fB--history\fR)
     \fBprint-query\fR               (print query and exit)
+    \fBrefresh-preview\fR
+    \fBreload(...)\fR               (see below for the details)
     \fBreplace-query\fR             (replace query string with the current selection)
-    \fBselect-all\fR
+    \fBselect-all\fR                (select all matches)
     \fBtoggle\fR                    (\fIright-click\fR)
-    \fBtoggle-all\fR
+    \fBtoggle-all\fR                (toggle all matches)
     \fBtoggle+down\fR               \fIctrl-i  (tab)\fR
     \fBtoggle-in\fR                 (\fB--layout=reverse*\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)
     \fBtoggle-out\fR                (\fB--layout=reverse*\fR ? \fBtoggle+down\fR : \fBtoggle+up\fR)
@@ -568,10 +741,15 @@ triggered whenever the query string is changed.
     \fBup\fR                        \fIctrl-k  ctrl-p  up\fR
     \fByank\fR                      \fIctrl-y\fR
 
+.SS ACTION COMPOSITION
+
 Multiple actions can be chained using \fB+\fR separator.
 
+e.g.
      \fBfzf --bind 'ctrl-a:select-all+accept'\fR
 
+.SS COMMAND EXECUTION
+
 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.
@@ -599,9 +777,9 @@ parse errors.
     \fBexecute|...|\fR
     \fBexecute:...\fR
 .RS
-This is the special form that frees you from parse errors as it does not expect
+The last one is the special form that frees you from parse errors as it does
-the closing character. The catch is that it should be the last one in the
+not expect the closing character. The catch is that it should be the last one
-comma-separated list of key-action pairs.
+in the comma-separated list of key-action pairs.
 .RE
 
 fzf switches to the alternate screen when executing a command. However, if the
@@ -611,6 +789,44 @@ executes the command without the switching. Note that fzf will not be
 responsive until the command is complete. For asynchronous execution, start
 your command as a background process (i.e. appending \fB&\fR).
 
+.SS RELOAD INPUT
+
+\fBreload(...)\fR action is used to dynamically update the input list
+without restarting fzf. It takes the same command template with placeholder
+expressions as \fBexecute(...)\fR.
+
+See \fIhttps://github.com/junegunn/fzf/issues/1750\fR for more info.
+
+e.g.
+     \fB# Update the list of processes by pressing CTRL-R
+     ps -ef | fzf --bind 'ctrl-r:reload(ps -ef)' --header 'Press CTRL-R to reload' \\
+                  --header-lines=1 --layout=reverse
+
+     # Integration with ripgrep
+     RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+     INITIAL_QUERY="foobar"
+     FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \\
+       fzf --bind "change:reload:$RG_PREFIX {q} || true" \\
+           --ansi --phony --query "$INITIAL_QUERY"\fR
+
+.SS PREVIEW BINDING
+
+With \fBpreview(...)\fR action, you can specify multiple different preview
+commands in addition to the default preview command given by \fB--preview\fR
+option.
+
+e.g.
+
+     # Default preview command with an extra preview binding
+     fzf --preview 'file {}' --bind '?:preview:cat {}'
+
+     # A preview binding with no default preview command
+     # (Preview window is initially empty)
+     fzf --bind '?:preview:cat {}'
+
+     # Preview window hidden by default, it appears when you first hit '?'
+     fzf --bind '?:preview:cat {}' --preview-window hidden
+
 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)
 

plugin/fzf.vim

@@ -49,10 +49,23 @@ if s:is_win
 
   " Use utf-8 for fzf.vim commands
   " Return array of shell commands for cmd.exe
+  function! s:enc_to_cp(str)
+    if !has('iconv')
+      return a:str
+    endif
+    if !exists('s:codepage')
+      let s:codepage = libcallnr('kernel32.dll', 'GetACP', 0)
+    endif
+    return iconv(a:str, &encoding, 'cp'.s:codepage)
+  endfunction
   function! s:wrap_cmds(cmds)
-    return map(['@echo off', 'for /f "tokens=4" %%a in (''chcp'') do set origchcp=%%a', 'chcp 65001 > nul'] +
+    return map([
-          \ (type(a:cmds) == type([]) ? a:cmds : [a:cmds]) +
+      \ '@echo off',
-          \ ['chcp %origchcp% > nul'], 'v:val."\r"')
+      \ 'setlocal enabledelayedexpansion']
+    \ + (has('gui_running') ? ['set TERM= > nul'] : [])
+    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds])
+    \ + ['endlocal'],
+    \ '<SID>enc_to_cp(v:val."\r")')
   endfunction
 else
   let s:term_marker = ";#FZF"
@@ -64,6 +77,10 @@ else
   function! s:wrap_cmds(cmds)
     return a:cmds
   endfunction
+
+  function! s:enc_to_cp(str)
+    return a:str
+  endfunction
 endif
 
 function! s:shellesc_cmd(arg)
@@ -75,7 +92,7 @@ function! s:shellesc_cmd(arg)
 endfunction
 
 function! fzf#shellescape(arg, ...)
-  let shell = get(a:000, 0, &shell)
+  let shell = get(a:000, 0, s:is_win ? 'cmd.exe' : 'sh')
   if shell =~# 'cmd.exe$'
     return s:shellesc_cmd(a:arg)
   endif
@@ -98,45 +115,65 @@ function! s:fzf_tempname()
   return s:fzf_call('tempname')
 endfunction
 
-let s:default_layout = { 'down': '~40%' }
+let s:layout_keys = ['window', 'tmux', 'up', 'down', 'left', 'right']
-let s:layout_keys = ['window', 'up', 'down', 'left', 'right']
 let s:fzf_go = s:base_dir.'/bin/fzf'
 let s:fzf_tmux = s:base_dir.'/bin/fzf-tmux'
-let s:install = s:base_dir.'/install'
-let s:installed = 0
 
 let s:cpo_save = &cpo
 set cpo&vim
 
-function! s:fzf_exec()
+function! s:popup_support()
+  return has('nvim') ? has('nvim-0.4') : has('popupwin') && has('patch-8.2.191')
+endfunction
+
+function! s:default_layout()
+  return s:popup_support()
+        \ ? { 'window' : { 'width': 0.9, 'height': 0.6, 'highlight': 'Normal' } }
+        \ : { 'down': '~40%' }
+endfunction
+
+function! fzf#install()
+  if s:is_win && !has('win32unix')
+    let script = s:base_dir.'/install.ps1'
+    if !filereadable(script)
+      throw script.' not found'
+    endif
+    let script = 'powershell -ExecutionPolicy Bypass -file ' . script
+  else
+    let script = s:base_dir.'/install'
+    if !executable(script)
+      throw script.' not found'
+    endif
+    let script .= ' --bin'
+  endif
+
+  call s:warn('Running fzf installer ...')
+  call system(script)
+  if v:shell_error
+    throw 'Failed to download fzf: '.script
+  endif
+endfunction
+
+function! fzf#exec()
   if !exists('s:exec')
     if executable(s:fzf_go)
       let s:exec = s:fzf_go
     elseif executable('fzf')
       let s:exec = 'fzf'
-    elseif s:is_win && !has('win32unix')
+    elseif input('fzf executable not found. Download binary? (y/n) ') =~? '^y'
-      call s:warn('fzf executable not found.')
-      call s:warn('Download fzf binary for Windows from https://github.com/junegunn/fzf-bin/releases/')
-      call s:warn('and place it as '.s:base_dir.'\bin\fzf.exe')
-      throw 'fzf executable not found'
-    elseif !s:installed && executable(s:install) &&
-          \ input('fzf executable not found. Download binary? (y/n) ') =~? '^y'
       redraw
-      echo
+      call fzf#install()
-      call s:warn('Downloading fzf binary. Please wait ...')
+      return fzf#exec()
-      let s:installed = 1
-      call system(s:install.' --bin')
-      return s:fzf_exec()
     else
       redraw
       throw 'fzf executable not found'
     endif
   endif
-  return fzf#shellescape(s:exec)
+  return s:exec
 endfunction
 
 function! s:tmux_enabled()
-  if has('gui_running')
+  if has('gui_running') || !exists('$TMUX')
     return 0
   endif
 
@@ -145,10 +182,16 @@ function! s:tmux_enabled()
   endif
 
   let s:tmux = 0
-  if exists('$TMUX') && executable(s:fzf_tmux)
+  if !executable(s:fzf_tmux)
+    if executable('fzf-tmux')
+      let s:fzf_tmux = 'fzf-tmux'
+    else
+      return 0
+    endif
+  endif
+
   let output = system('tmux -V')
   let s:tmux = !v:shell_error && output >= 'tmux 1.7'
-  endif
   return s:tmux
 endfunction
 
@@ -157,21 +200,6 @@ function! s:escape(path)
   return s:is_win ? escape(path, '$') : path
 endfunction
 
-" Upgrade legacy options
-function! s:upgrade(dict)
-  let copy = copy(a:dict)
-  if has_key(copy, 'tmux')
-    let copy.down = remove(copy, 'tmux')
-  endif
-  if has_key(copy, 'tmux_height')
-    let copy.down = remove(copy, 'tmux_height')
-  endif
-  if has_key(copy, 'tmux_width')
-    let copy.right = remove(copy, 'tmux_width')
-  endif
-  return copy
-endfunction
-
 function! s:error(msg)
   echohl ErrorMsg
   echom a:msg
@@ -217,9 +245,13 @@ function! s:common_sink(action, lines) abort
   endif
   try
     let empty = empty(s:fzf_expand('%')) && line('$') == 1 && empty(getline(1)) && !&modified
-    let autochdir = &autochdir
+    " Preserve the current working directory in case it's changed during
-    set noautochdir
+    " the execution (e.g. `set autochdir` or `autocmd BufEnter * lcd ...`)
+    let cwd = exists('w:fzf_pushd') ? w:fzf_pushd.dir : expand('%:p:h')
     for item in a:lines
+      if item[0] != '~' && item !~ (s:is_win ? '^[A-Z]:\' : '^/')
+        let item = join([cwd, item], (s:is_win ? '\' : '/'))
+      endif
       if empty
         execute 'e' s:escape(item)
         let empty = 0
@@ -233,13 +265,12 @@ function! s:common_sink(action, lines) abort
     endfor
   catch /^Vim:Interrupt$/
   finally
-    let &autochdir = autochdir
     silent! autocmd! fzf_swap
   endtry
 endfunction
 
 function! s:get_color(attr, ...)
-  let gui = has('termguicolors') && &termguicolors
+  let gui = !s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors
   let fam = gui ? 'gui' : 'cterm'
   let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$'
   for group in a:000
@@ -254,7 +285,7 @@ endfunction
 function! s:defaults()
   let rules = copy(get(g:, 'fzf_colors', {}))
   let colors = join(map(items(filter(map(rules, 'call("s:get_color", v:val)'), '!empty(v:val)')), 'join(v:val, ":")'), ',')
-  return empty(colors) ? '' : ('--color='.colors)
+  return empty(colors) ? '' : fzf#shellescape('--color='.colors)
 endfunction
 
 function! s:validate_layout(layout)
@@ -278,7 +309,7 @@ function! fzf#wrap(...)
   let expects = map(copy(args), 'type(v:val)')
   let tidx = 0
   for arg in copy(a:000)
-    let tidx = index(expects, type(arg), tidx)
+    let tidx = index(expects, type(arg) == 6 ? type(0) : type(arg), tidx)
     if tidx < 0
       throw 'Invalid arguments (expected: [name string] [opts dict] [fullscreen boolean])'
     endif
@@ -303,7 +334,7 @@ function! fzf#wrap(...)
     if !exists('g:fzf_layout') && exists('g:fzf_height')
       let opts.down = g:fzf_height
     else
-      let opts = extend(opts, s:validate_layout(get(g:, 'fzf_layout', s:default_layout)))
+      let opts = extend(opts, s:validate_layout(get(g:, 'fzf_layout', s:default_layout())))
     endif
   endif
 
@@ -334,42 +365,38 @@ function! fzf#wrap(...)
 endfunction
 
 function! s:use_sh()
-  let [shell, shellslash] = [&shell, &shellslash]
+  let [shell, shellslash, shellcmdflag, shellxquote] = [&shell, &shellslash, &shellcmdflag, &shellxquote]
   if s:is_win
     set shell=cmd.exe
     set noshellslash
+    let &shellcmdflag = has('nvim') ? '/s /c' : '/c'
+    let &shellxquote = has('nvim') ? '"' : '('
   else
     set shell=sh
   endif
-  return [shell, shellslash]
+  return [shell, shellslash, shellcmdflag, shellxquote]
 endfunction
 
 function! fzf#run(...) abort
 try
-  let [shell, shellslash] = s:use_sh()
+  let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
 
-  let dict   = exists('a:1') ? s:upgrade(a:1) : {}
+  let dict   = exists('a:1') ? copy(a:1) : {}
   let temps  = { 'result': s:fzf_tempname() }
   let optstr = s:evaluate_opts(get(dict, 'options', ''))
   try
-    let fzf_exec = s:fzf_exec()
+    let fzf_exec = fzf#shellescape(fzf#exec())
   catch
     throw v:exception
   endtry
 
-  if has('nvim') && !has_key(dict, 'dir')
+  if !has_key(dict, 'dir')
     let dict.dir = s:fzf_getcwd()
   endif
   if has('win32unix') && has_key(dict, 'dir')
     let dict.dir = fnamemodify(dict.dir, ':p')
   endif
 
-  if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND) && !s:is_win
-    let temps.source = s:fzf_tempname()
-    call writefile(s:wrap_cmds(split($FZF_DEFAULT_COMMAND, "\n")), temps.source)
-    let dict.source = (empty($SHELL) ? &shell : $SHELL).' '.fzf#shellescape(temps.source)
-  endif
-
   if has_key(dict, 'source')
     let source = dict.source
     let type = type(source)
@@ -377,7 +404,7 @@ try
       let prefix = '( '.source.' )|'
     elseif type == 3
       let temps.input = s:fzf_tempname()
-      call writefile(source, temps.input)
+      call writefile(map(source, '<SID>enc_to_cp(v:val)'), temps.input)
       let prefix = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input).'|'
     else
       throw 'Invalid source type'
@@ -386,7 +413,7 @@ try
     let prefix = ''
   endif
 
-  let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0)
+  let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) || has_key(dict, 'tmux')
   let use_height = has_key(dict, 'down') && !has('gui_running') &&
         \ !(has('nvim') || s:is_win || has('win32unix') || s:present(dict, 'up', 'left', 'right', 'window')) &&
         \ executable('tput') && filereadable('/dev/tty')
@@ -394,7 +421,7 @@ try
   let has_nvim_term = has('nvim-0.2.1') || has('nvim') && !s:is_win
   let use_term = has_nvim_term ||
     \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || !use_height && s:present(dict, 'down', 'up', 'left', 'right', 'window'))
-  let use_tmux = (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:tmux_enabled() && s:splittable(dict)
+  let use_tmux = (has_key(dict, 'tmux') || (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:splittable(dict)) && s:tmux_enabled()
   if prefer_tmux && use_tmux
     let use_height = 0
     let use_term = 0
@@ -416,7 +443,7 @@ try
   call s:callback(dict, lines)
   return lines
 finally
-  let [&shell, &shellslash] = [shell, shellslash]
+  let [&shell, &shellslash, &shellcmdflag, &shellxquote] = [shell, shellslash, shellcmdflag, shellxquote]
 endtry
 endfunction
 
@@ -430,7 +457,8 @@ function! s:present(dict, ...)
 endfunction
 
 function! s:fzf_tmux(dict)
-  let size = ''
+  let size = get(a:dict, 'tmux', '')
+  if empty(size)
     for o in ['up', 'down', 'left', 'right']
       if s:present(a:dict, o)
         let spec = a:dict[o]
@@ -443,6 +471,7 @@ function! s:fzf_tmux(dict)
         break
       endif
     endfor
+  endif
   return printf('LINES=%d COLUMNS=%d %s %s %s --',
     \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
 endfunction
@@ -455,15 +484,18 @@ endfunction
 function! s:pushd(dict)
   if s:present(a:dict, 'dir')
     let cwd = s:fzf_getcwd()
-    if get(a:dict, 'prev_dir', '') ==# cwd
+    let w:fzf_pushd = {
-      return 1
+    \   'command': haslocaldir() ? 'lcd' : (exists(':tcd') && haslocaldir(-1) ? 'tcd' : 'cd'),
-    endif
+    \   'origin': cwd,
-    let a:dict.prev_dir = cwd
+    \   'bufname': bufname('')
+    \ }
     execute 'lcd' s:escape(a:dict.dir)
-    let a:dict.dir = s:fzf_getcwd()
+    let cwd = s:fzf_getcwd()
-    return 1
+    let w:fzf_pushd.dir = cwd
+    let a:dict.pushd = w:fzf_pushd
+    return cwd
   endif
-  return 0
+  return ''
 endfunction
 
 augroup fzf_popd
@@ -472,20 +504,38 @@ augroup fzf_popd
 augroup END
 
 function! s:dopopd()
-  if !exists('w:fzf_dir') || s:fzf_getcwd() != w:fzf_dir[1]
+  if !exists('w:fzf_pushd')
     return
   endif
-  execute 'lcd' s:escape(w:fzf_dir[0])
+
-  unlet w:fzf_dir
+  " FIXME: We temporarily change the working directory to 'dir' entry
+  " of options dictionary (set to the current working directory if not given)
+  " before running fzf.
+  "
+  " e.g. call fzf#run({'dir': '/tmp', 'source': 'ls', 'sink': 'e'})
+  "
+  " After processing the sink function, we have to restore the current working
+  " directory. But doing so may not be desirable if the function changed the
+  " working directory on purpose.
+  "
+  " So how can we tell if we should do it or not? A simple heuristic we use
+  " here is that we change directory only if the current working directory
+  " matches 'dir' entry. However, it is possible that the sink function did
+  " change the directory to 'dir'. In that case, the user will have an
+  " unexpected result.
+  if s:fzf_getcwd() ==# w:fzf_pushd.dir && (!&autochdir || w:fzf_pushd.bufname ==# bufname(''))
+    execute w:fzf_pushd.command s:escape(w:fzf_pushd.origin)
+  endif
+  unlet! w:fzf_pushd
 endfunction
 
 function! s:xterm_launcher()
-  let fmt = 'xterm -T "[fzf]" -bg "\%s" -fg "\%s" -geometry %dx%d+%d+%d -e bash -ic %%s'
+  let fmt = 'xterm -T "[fzf]" -bg "%s" -fg "%s" -geometry %dx%d+%d+%d -e bash -ic %%s'
   if has('gui_macvim')
     let fmt .= '&& osascript -e "tell application \"MacVim\" to activate"'
   endif
   return printf(fmt,
-    \ synIDattr(hlID("Normal"), "bg"), synIDattr(hlID("Normal"), "fg"),
+    \ escape(synIDattr(hlID("Normal"), "bg"), '#'), escape(synIDattr(hlID("Normal"), "fg"), '#'),
     \ &columns, &lines/2, getwinposx(), getwinposy())
 endfunction
 unlet! s:launcher
@@ -498,6 +548,10 @@ endif
 function! s:exit_handler(code, command, ...)
   if a:code == 130
     return 0
+  elseif has('nvim') && a:code == 129
+    " When deleting the terminal buffer while fzf is still running,
+    " Nvim sends SIGHUP.
+    return 0
   elseif a:code > 1
     call s:error('Error running ' . a:command)
     if !empty(a:000)
@@ -534,9 +588,7 @@ function! s:execute(dict, command, use_height, temps) abort
       let fzf.dict = a:dict
       let fzf.temps = a:temps
       function! fzf.on_exit(job_id, exit_status, event) dict
-        if s:present(self.dict, 'dir')
+        call s:pushd(self.dict)
-          execute 'lcd' s:escape(self.dict.dir)
-        endif
         let lines = s:collect(self.temps)
         call s:callback(self.dict, lines)
       endfunction
@@ -563,9 +615,10 @@ endfunction
 
 function! s:execute_tmux(dict, command, temps) abort
   let command = a:command
-  if s:pushd(a:dict)
+  let cwd = s:pushd(a:dict)
+  if len(cwd)
     " -c '#{pane_current_path}' is only available on tmux 1.9 or above
-    let command = join(['cd', fzf#shellescape(a:dict.dir), '&&', command])
+    let command = join(['cd', fzf#shellescape(cwd), '&&', command])
   endif
 
   call system(command)
@@ -587,14 +640,20 @@ function! s:calc_size(max, val, dict)
     let srcsz = len(a:dict.source)
   endif
 
-  let opts = s:evaluate_opts(get(a:dict, 'options', '')).$FZF_DEFAULT_OPTS
+  let opts = $FZF_DEFAULT_OPTS.' '.s:evaluate_opts(get(a:dict, 'options', ''))
-  let margin = stridx(opts, '--inline-info') > stridx(opts, '--no-inline-info') ? 1 : 2
+  if opts =~ 'preview'
-  let margin += stridx(opts, '--header') > stridx(opts, '--no-header')
+    return size
+  endif
+  let margin = match(opts, '--inline-info\|--info[^-]\{-}inline') > match(opts, '--no-inline-info\|--info[^-]\{-}\(default\|hidden\)') ? 1 : 2
+  let margin += stridx(opts, '--border') > stridx(opts, '--no-border') ? 2 : 0
+  if stridx(opts, '--header') > stridx(opts, '--no-header')
+    let margin += len(split(opts, "\n"))
+  endif
   return srcsz >= 0 ? min([srcsz + margin, size]) : size
 endfunction
 
 function! s:getpos()
-  return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
+  return {'tab': tabpagenr(), 'win': winnr(), 'winid': win_getid(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
 endfunction
 
 function! s:split(dict)
@@ -604,9 +663,18 @@ function! s:split(dict)
   \ 'left':  ['vertical topleft', 'vertical resize', &columns],
   \ 'right': ['vertical botright', 'vertical resize', &columns] }
   let ppos = s:getpos()
+  let is_popup = 0
   try
     if s:present(a:dict, 'window')
+      if type(a:dict.window) == type({})
+        if !s:popup_support()
+          throw 'Nvim 0.4+ or Vim 8.2.191+ with popupwin feature is required for pop-up window'
+        end
+        call s:popup(a:dict.window)
+        let is_popup = 1
+      else
         execute 'keepalt' a:dict.window
+      endif
     elseif !s:splittable(a:dict)
       execute (tabpagenr()-1).'tabnew'
     else
@@ -621,20 +689,22 @@ function! s:split(dict)
           endif
           execute cmd sz.'new'
           execute resz sz
-          return [ppos, {}]
+          return [ppos, {}, is_popup]
         endif
       endfor
     endif
-    return [ppos, { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }]
+    return [ppos, is_popup ? {} : { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }, is_popup]
   finally
+    if !is_popup
       setlocal winfixwidth winfixheight
+    endif
   endtry
 endfunction
 
 function! s:execute_term(dict, command, temps) abort
   let winrest = winrestcmd()
   let pbuf = bufnr('')
-  let [ppos, winopts] = s:split(a:dict)
+  let [ppos, winopts, is_popup] = s:split(a:dict)
   call s:use_sh()
   let b:fzf = a:dict
   let fzf = { 'buf': bufnr(''), 'pbuf': pbuf, 'ppos': ppos, 'dict': a:dict, 'temps': a:temps,
@@ -663,8 +733,8 @@ function! s:execute_term(dict, command, temps) abort
         " there's no other listed buffer (nvim +'set nobuflisted')
         close
       endif
-      execute 'tabnext' self.ppos.tab
+      silent! execute 'tabnext' self.ppos.tab
-      execute self.ppos.win.'wincmd w'
+      silent! execute self.ppos.win.'wincmd w'
     endif
 
     if bufexists(self.buf)
@@ -686,9 +756,7 @@ function! s:execute_term(dict, command, temps) abort
   endfunction
 
   try
-    if s:present(a:dict, 'dir')
+    call s:pushd(a:dict)
-      execute 'lcd' s:escape(a:dict.dir)
-    endif
     if s:is_win
       let fzf.temps.batchfile = s:fzf_tempname().'.bat'
       call writefile(s:wrap_cmds(a:command), fzf.temps.batchfile)
@@ -700,15 +768,22 @@ function! s:execute_term(dict, command, temps) abort
     if has('nvim')
       call termopen(command, fzf)
     else
-      let fzf.buf = term_start([&shell, &shellcmdflag, command], {'curwin': 1, 'exit_cb': function(fzf.on_exit)})
+      let term_opts = {'exit_cb': function(fzf.on_exit)}
-      if !has('patch-8.0.1261') && !has('nvim') && !s:is_win
+      if is_popup
+        let term_opts.hidden = 1
+      else
+        let term_opts.curwin = 1
+      endif
+      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
+      if is_popup && exists('#TerminalWinOpen')
+        doautocmd <nomodeline> TerminalWinOpen
+      endif
+      if !has('patch-8.0.1261') && !s:is_win
         call term_wait(fzf.buf, 20)
       endif
     endif
   finally
-    if s:present(a:dict, 'dir')
+    call s:dopopd()
-      lcd -
-    endif
   endtry
   setlocal nospell bufhidden=wipe nobuflisted nonumber
   setf fzf
@@ -727,21 +802,9 @@ function! s:collect(temps) abort
 endfunction
 
 function! s:callback(dict, lines) abort
-  " Since anything can be done in the sink function, there is no telling that
+  let popd = has_key(a:dict, 'pushd')
-  " the change of the working directory was made by &autochdir setting.
-  "
-  " We use the following heuristic to determine whether to restore CWD:
-  " - Always restore the current directory when &autochdir is disabled.
-  "   FIXME This makes it impossible to change directory from inside the sink
-  "   function when &autochdir is not used.
-  " - In case of an error or an interrupt, a:lines will be empty.
-  "   And it will be an array of a single empty string when fzf was finished
-  "   without a match. In these cases, we presume that the change of the
-  "   directory is not expected and should be undone.
-  let popd = has_key(a:dict, 'prev_dir') &&
-        \ (!&autochdir || (empty(a:lines) || len(a:lines) == 1 && empty(a:lines[0])))
   if popd
-    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
+    let w:fzf_pushd = a:dict.pushd
   endif
 
   try
@@ -765,11 +828,104 @@ function! s:callback(dict, lines) abort
 
   " We may have opened a new window or tab
   if popd
-    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
+    let w:fzf_pushd = a:dict.pushd
     call s:dopopd()
   endif
 endfunction
 
+if has('nvim')
+  function s:create_popup(hl, opts) abort
+    let buf = nvim_create_buf(v:false, v:true)
+    let opts = extend({'relative': 'editor', 'style': 'minimal'}, a:opts)
+    let border = has_key(opts, 'border') ? remove(opts, 'border') : []
+    let win = nvim_open_win(buf, v:true, opts)
+    call setwinvar(win, '&winhighlight', 'NormalFloat:'..a:hl)
+    call setwinvar(win, '&colorcolumn', '')
+    if !empty(border)
+      call nvim_buf_set_lines(buf, 0, -1, v:true, border)
+    endif
+    return buf
+  endfunction
+else
+  function! s:create_popup(hl, opts) abort
+    let is_frame = has_key(a:opts, 'border')
+    let s:popup_create = {buf -> popup_create(buf, #{
+      \ line: a:opts.row,
+      \ col: a:opts.col,
+      \ minwidth: a:opts.width,
+      \ minheight: a:opts.height,
+      \ zindex: 50 - is_frame,
+    \ })}
+    if is_frame
+      let id = s:popup_create('')
+      call setwinvar(id, '&wincolor', a:hl)
+      call setbufline(winbufnr(id), 1, a:opts.border)
+      execute 'autocmd BufWipeout * ++once call popup_close('..id..')'
+      return winbufnr(id)
+    else
+      autocmd TerminalOpen * ++once call s:popup_create(str2nr(expand('<abuf>')))
+    endif
+  endfunction
+endif
+
+function! s:popup(opts) abort
+  " Support ambiwidth == 'double'
+  let ambidouble = &ambiwidth == 'double' ? 2 : 1
+
+  " Size and position
+  let width = min([max([8, a:opts.width > 1 ? a:opts.width : float2nr(&columns * a:opts.width)]), &columns])
+  let width += width % ambidouble
+  let height = min([max([4, a:opts.height > 1 ? a:opts.height : float2nr(&lines * a:opts.height)]), &lines - has('nvim')])
+  let row = float2nr(get(a:opts, 'yoffset', 0.5) * (&lines - height))
+  let col = float2nr(get(a:opts, 'xoffset', 0.5) * (&columns - width))
+
+  " Managing the differences
+  let row = min([max([0, row]), &lines - has('nvim') - height])
+  let col = min([max([0, col]), &columns - width])
+  let row += !has('nvim')
+  let col += !has('nvim')
+
+  " Border style
+  let style = tolower(get(a:opts, 'border', 'rounded'))
+  if !has_key(a:opts, 'border') && !get(a:opts, 'rounded', 1)
+    let style = 'sharp'
+  endif
+
+  if style =~ 'vertical\|left\|right'
+    let mid = style == 'vertical' ? '│' .. repeat(' ', width - 2 * ambidouble) .. '│' :
+            \ style == 'left'     ? '│' .. repeat(' ', width - 1 * ambidouble)
+            \                     :        repeat(' ', width - 1 * ambidouble) .. '│'
+    let border = repeat([mid], height)
+    let shift = { 'row': 0, 'col': style == 'right' ? 0 : 2, 'width': style == 'vertical' ? -4 : -2, 'height': 0 }
+  elseif style =~ 'horizontal\|top\|bottom'
+    let hor = repeat('─', width / ambidouble)
+    let mid = repeat(' ', width)
+    let border = style == 'horizontal' ? [hor] + repeat([mid], height - 2) + [hor] :
+               \ style == 'top'        ? [hor] + repeat([mid], height - 1)
+               \                       :         repeat([mid], height - 1) + [hor]
+    let shift = { 'row': style == 'bottom' ? 0 : 1, 'col': 0, 'width': 0, 'height': style == 'horizontal' ? -2 : -1 }
+  else
+    let edges = style == 'sharp' ? ['┌', '┐', '└', '┘'] : ['╭', '╮', '╰', '╯']
+    let bar = repeat('─', width / ambidouble - 2)
+    let top = edges[0] .. bar .. edges[1]
+    let mid = '│' .. repeat(' ', width - 2 * ambidouble) .. '│'
+    let bot = edges[2] .. bar .. edges[3]
+    let border = [top] + repeat([mid], height - 2) + [bot]
+    let shift = { 'row': 1, 'col': 2, 'width': -4, 'height': -2 }
+  endif
+
+  let highlight = get(a:opts, 'highlight', 'Comment')
+  let frame = s:create_popup(highlight, {
+    \ 'row': row, 'col': col, 'width': width, 'height': height, 'border': border
+  \ })
+  call s:create_popup('Normal', {
+    \ 'row': row + shift.row, 'col': col + shift.col, 'width': width + shift.width, 'height': height + shift.height
+  \ })
+  if has('nvim')
+    execute 'autocmd BufWipeout <buffer> bwipeout '..frame
+  endif
+endfunction
+
 let s:default_action = {
   \ 'ctrl-t': 'tab split',
   \ 'ctrl-x': 'split',

shell/completion.bash

@@ -2,19 +2,21 @@
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.bash
+# /_/   /___/_/ completion.bash
 #
 # - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: empty)
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+if [[ $- =~ i ]]; then
+
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
 if ! declare -f _fzf_compgen_path > /dev/null; then
   _fzf_compgen_path() {
     echo "$1"
     command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
@@ -22,7 +24,7 @@ fi
 if ! declare -f _fzf_compgen_dir > /dev/null; then
   _fzf_compgen_dir() {
     command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o -type d \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
@@ -32,9 +34,16 @@ fi
 # To redraw line after fzf closes (printf '\e[5n')
 bind '"\e[0n": redraw-current-line'
 
-__fzfcmd_complete() {
+__fzf_comprun() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ] &&
+  if [ "$(type -t _fzf_comprun 2>&1)" = function ]; then
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    _fzf_comprun "$@"
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
+    shift
+    fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
+  else
+    shift
+    fzf "$@"
+  fi
 }
 
 __fzf_orig_completion_filter() {
@@ -70,6 +79,8 @@ _fzf_opts_completion() {
     --margin
     --inline-info
     --prompt
+    --pointer
+    --marker
     --header
     --header-lines
     --ansi
@@ -121,11 +132,11 @@ _fzf_handle_dynamic_completion() {
   if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
     $orig "$@"
   elif [ -n "$_fzf_completion_loader" ]; then
-    orig_complete=$(complete -p "$cmd" 2> /dev/null)
+    orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
     _completion_loader "$@"
     ret=$?
     # _completion_loader may not have updated completion for the command
-    if [ "$(complete -p "$cmd" 2> /dev/null)" != "$orig_complete" ]; then
+    if [ "$(complete -p "$orig_cmd" 2> /dev/null)" != "$orig_complete" ]; then
       eval "$(complete | command grep " -F.* $orig_cmd$" | __fzf_orig_completion_filter)"
       if [[ "$__fzf_nospace_commands" = *" $orig_cmd "* ]]; then
         eval "${orig_complete/ -F / -o nospace -F }"
@@ -138,8 +149,7 @@ _fzf_handle_dynamic_completion() {
 }
 
 __fzf_generic_path_completion() {
-  local cur base dir leftover matches trigger cmd fzf
+  local cur base dir leftover matches trigger cmd
-  fzf="$(__fzfcmd_complete)"
   cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
@@ -155,7 +165,7 @@ __fzf_generic_path_completion() {
         leftover=${leftover/#\/}
         [ -z "$dir" ] && dir='.'
         [ "$dir" != "/" ] && dir="${dir/%\//}"
-        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" $fzf $2 -q "$leftover" | while read -r item; do
+        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $2" __fzf_comprun "$4" -q "$leftover" | while read -r item; do
           printf "%q$3 " "$item"
         done)
         matches=${matches% }
@@ -180,10 +190,30 @@ __fzf_generic_path_completion() {
 }
 
 _fzf_complete() {
-  local cur selected trigger cmd fzf post
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in "${!args[@]}"; do
+    if [[ "${args[$i]}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local cur selected trigger cmd post
   post="$(caller 0 | awk '{print $2}')_post"
   type -t "$post" > /dev/null 2>&1 || post=cat
-  fzf="$(__fzfcmd_complete)"
 
   cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
@@ -191,17 +221,17 @@ _fzf_complete() {
   if [[ "$cur" == *"$trigger" ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
-    selected=$(cat | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" $fzf $1 -q "$cur" | $post | tr '\n' ' ')
+    selected=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | $post | tr '\n' ' ')
     selected=${selected% } # Strip trailing space not to repeat "-o nospace"
-    printf '\e[5n'
-
     if [ -n "$selected" ]; then
       COMPREPLY=("$selected")
-      return 0
-    fi
     else
-    shift
+      COMPREPLY=("$cur")
-    _fzf_handle_dynamic_completion "$cmd" "$@"
+    fi
+    printf '\e[5n'
+    return 0
+  else
+    _fzf_handle_dynamic_completion "$cmd" "${rest[@]}"
   fi
 }
 
@@ -219,49 +249,44 @@ _fzf_dir_completion() {
 }
 
 _fzf_complete_kill() {
-  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
+  local trigger=${FZF_COMPLETION_TRIGGER-'**'}
-
+  local cur="${COMP_WORDS[COMP_CWORD]}"
-  local selected fzf
+  if [[ -z "$cur" ]]; then
-  fzf="$(__fzfcmd_complete)"
+    COMP_WORDS[$COMP_CWORD]=$trigger
-  selected=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" $fzf -m | awk '{print $2}' | tr '\n' ' ')
+  elif [[ "$cur" != *"$trigger" ]]; then
-  printf '\e[5n'
+    return 1
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=( "$selected" )
-    return 0
   fi
+
+  _fzf_proc_completion "$@"
 }
 
-_fzf_complete_telnet() {
+_fzf_proc_completion() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
-    command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
+    command ps -ef | sed 1d
-        awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
-_fzf_complete_ssh() {
+_fzf_proc_completion_post() {
-  _fzf_complete '+m' "$@" < <(
+  awk '{print $2}'
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}') \
+}
+
+_fzf_host_completion() {
+  _fzf_complete +m -- "$@" < <(
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
         <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
         <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
-_fzf_complete_unset() {
+_fzf_var_completion() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
-_fzf_complete_export() {
+_fzf_alias_completion() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
-    declare -xp | sed 's/=.*//' | sed 's/.* //'
-  )
-}
-
-_fzf_complete_unalias() {
-  _fzf_complete '-m' "$@" < <(
     alias | sed 's/=.*//' | sed 's/.* //'
   )
 }
@@ -279,18 +304,17 @@ a_cmds="
   find git grep gunzip gzip hg jar
   ln ls mv open rm rsync scp
   svn tar unzip zip"
-x_cmds="kill ssh telnet unset unalias export"
 
 # Preserve existing completion
 eval "$(complete |
-  sed -E '/-F/!d; / _fzf/d; '"/ ($(echo $d_cmds $a_cmds $x_cmds | sed 's/ /|/g; s/+/\\+/g'))$/"'!d' |
+  sed -E '/-F/!d; / _fzf/d; '"/ ($(echo $d_cmds $a_cmds | sed 's/ /|/g; s/+/\\+/g'))$/"'!d' |
   __fzf_orig_completion_filter)"
 
 if type _completion_loader > /dev/null 2>&1; then
   _fzf_completion_loader=1
 fi
 
-_fzf_defc() {
+__fzf_defc() {
   local cmd func opts orig_var orig def
   cmd="$1"
   func="$2"
@@ -307,26 +331,42 @@ _fzf_defc() {
 
 # Anything
 for cmd in $a_cmds; do
-  _fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
+  __fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
 done
 
 # Directory
 for cmd in $d_cmds; do
-  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
+  __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
 done
 
-unset _fzf_defc
+# Kill completion (supports empty completion trigger)
+complete -F _fzf_complete_kill -o default -o bashdefault kill
 
-# Kill completion
+unset cmd d_cmds a_cmds
-complete -F _fzf_complete_kill -o nospace -o default -o bashdefault kill
 
-# Host completion
+_fzf_setup_completion() {
-complete -F _fzf_complete_ssh -o default -o bashdefault ssh
+  local kind fn cmd
-complete -F _fzf_complete_telnet -o default -o bashdefault telnet
+  kind=$1
+  fn=_fzf_${1}_completion
+  if [[ $# -lt 2 ]] || ! type -t "$fn" > /dev/null; then
+    echo "usage: ${FUNCNAME[0]} path|dir|var|alias|host|proc COMMANDS..."
+    return 1
+  fi
+  shift
+  eval "$(complete -p "$@" 2> /dev/null | grep -v "$fn" | __fzf_orig_completion_filter)"
+  for cmd in "$@"; do
+    case "$kind" in
+      dir)   __fzf_defc "$cmd" "$fn" "-o nospace -o dirnames" ;;
+      var)   __fzf_defc "$cmd" "$fn" "-o default -o nospace -v" ;;
+      alias) __fzf_defc "$cmd" "$fn" "-a" ;;
+      *)     __fzf_defc "$cmd" "$fn" "-o default -o bashdefault" ;;
+    esac
+  done
+}
 
-# Environment variables / Aliases
+# Environment variables / Aliases / Hosts
-complete -F _fzf_complete_unset -o default -o bashdefault unset
+_fzf_setup_completion 'var'   export unset
-complete -F _fzf_complete_export -o default -o bashdefault export
+_fzf_setup_completion 'alias' unalias
-complete -F _fzf_complete_unalias -o default -o bashdefault unalias
+_fzf_setup_completion 'host'  ssh telnet
 
-unset cmd d_cmds a_cmds x_cmds
+fi

shell/completion.zsh

@@ -2,19 +2,86 @@
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.zsh
+# /_/   /___/_/ completion.zsh
 #
 # - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: '-d 40%')
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+# Both branches of the following `if` do the same thing -- define
+# __fzf_completion_options such that `eval $__fzf_completion_options` sets
+# all options to the same values they currently have. We'll do just that at
+# the bottom of the file after changing options to what we prefer.
+#
+# IMPORTANT: Until we get to the `emulate` line, all words that *can* be quoted
+# *must* be quoted in order to prevent alias expansion. In addition, code must
+# be written in a way works with any set of zsh options. This is very tricky, so
+# careful when you change it.
+#
+# Start by loading the builtin zsh/parameter module. It provides `options`
+# associative array that stores current shell options.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  # This is the fast branch and it gets taken on virtually all Zsh installations.
+  #
+  # ${(kv)options[@]} expands to array of keys (option names) and values ("on"
+  # or "off"). The subsequent expansion# with (j: :) flag joins all elements
+  # together separated by spaces. __fzf_completion_options ends up with a value
+  # like this: "options=(shwordsplit off aliases on ...)".
+  __fzf_completion_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  # This branch is much slower because it forks to get the names of all
+  # zsh options. It's possible to eliminate this fork but it's not worth the
+  # trouble because this branch gets taken only on very ancient or broken
+  # zsh installations.
+  () {
+    # That `()` above defines an anonymous function. This is essentially a scope
+    # for local parameters. We use it to avoid polluting global scope.
+    'local' '__fzf_opt'
+    __fzf_completion_options="setopt"
+    # `set -o` prints one line for every zsh option. Each line contains option
+    # name, some spaces, and then either "on" or "off". We just want option names.
+    # Expansion with (@f) flag splits a string into lines. The outer expansion
+    # removes spaces and everything that follow them on every line. __fzf_opt
+    # ends up iterating over option names: shwordsplit, aliases, etc.
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        # Option $__fzf_opt is currently on, so remember to set it back on.
+        __fzf_completion_options+=" -o $__fzf_opt"
+      else
+        # Option $__fzf_opt is currently off, so remember to set it back off.
+        __fzf_completion_options+=" +o $__fzf_opt"
+      fi
+    done
+    # The value of __fzf_completion_options here looks like this:
+    # "setopt +o shwordsplit -o aliases ..."
+  }
+fi
+
+# Enable the default zsh options (those marked with <Z> in `man zshoptions`)
+# but without `aliases`. Aliases in functions are expanded when functions are
+# defined, so if we disable aliases here, we'll be sure to have no pesky
+# aliases in any of our functions. This way we won't need prefix every
+# command with `command` or to quote every word to defend against global
+# aliases. Note that `aliases` is not the only option that's important to
+# control. There are several others that could wreck havoc if they are set
+# to values we don't expect. With the following `emulate` command we
+# sidestep this issue entirely.
+'emulate' 'zsh' '-o' 'no_aliases'
+
+# This brace is the start of try-always block. The `always` part is like
+# `finally` in lesser languages. We use it to *always* restore user options.
+{
+
+# Bail out if not interactive shell.
+[[ -o interactive ]] || return 0
+
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
 if ! declare -f _fzf_compgen_path > /dev/null; then
   _fzf_compgen_path() {
     echo "$1"
     command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
@@ -22,27 +89,52 @@ fi
 if ! declare -f _fzf_compgen_dir > /dev/null; then
   _fzf_compgen_dir() {
     command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o -type d \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
 
 ###########################################################
 
-__fzfcmd_complete() {
+__fzf_comprun() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ] &&
+  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    _fzf_comprun "$@"
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
+    shift
+    if [ -n "$FZF_TMUX_OPTS" ]; then
+      fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
+    else
+      fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
+    fi
+  else
+    shift
+    fzf "$@"
+  fi
+}
+
+# Extract the name of the command. e.g. foo=1 bar baz**<tab>
+__fzf_extract_command() {
+  local token tokens
+  tokens=(${(z)1})
+  for token in $tokens; do
+    token=${(Q)token}
+    if [[ "$token" =~ [[:alnum:]] && ! "$token" =~ "=" ]]; then
+      echo "$token"
+      return
+    fi
+  done
+  echo "${tokens[1]}"
 }
 
 __fzf_generic_path_completion() {
-  local base lbuf compgen fzf_opts suffix tail fzf dir leftover matches
+  local base lbuf cmd compgen fzf_opts suffix tail dir leftover matches
   base=$1
   lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
   compgen=$3
   fzf_opts=$4
   suffix=$5
   tail=$6
-  fzf="$(__fzfcmd_complete)"
 
   setopt localoptions nonomatch
   eval "base=$base"
@@ -53,15 +145,14 @@ __fzf_generic_path_completion() {
       leftover=${leftover/#\/}
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
-      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" ${=fzf} ${=fzf_opts} -q "$leftover" | while read item; do
+      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
         echo -n "${(q)item}$suffix "
       done)
       matches=${matches% }
       if [ -n "$matches" ]; then
         LBUFFER="$lbuf$matches$tail"
       fi
-      zle redisplay
+      zle reset-prompt
-      typeset -f zle-line-init >/dev/null && zle zle-line-init
       break
     fi
     dir=$(dirname "$dir")
@@ -86,35 +177,55 @@ _fzf_feed_fifo() (
 )
 
 _fzf_complete() {
-  local fifo fzf_opts lbuf fzf matches post
+  setopt localoptions ksh_arrays
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in {0..${#args[@]}}; do
+    if [[ "${args[$i]}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local fifo lbuf cmd matches post
   fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
-  fzf_opts=$1
+  lbuf=${rest[0]}
-  lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
-  post="${funcstack[2]}_post"
+  post="${funcstack[1]}_post"
   type $post > /dev/null 2>&1 || post=cat
 
-  fzf="$(__fzfcmd_complete)"
-
   _fzf_feed_fifo "$fifo"
-  matches=$(cat "$fifo" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" ${=fzf} ${=fzf_opts} -q "${(Q)prefix}" | $post | tr '\n' ' ')
+  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
   if [ -n "$matches" ]; then
     LBUFFER="$lbuf$matches"
   fi
-  zle redisplay
+  zle reset-prompt
-  typeset -f zle-line-init >/dev/null && zle zle-line-init
   command rm -f "$fifo"
 }
 
 _fzf_complete_telnet() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
     command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
 _fzf_complete_ssh() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
-    command cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}') \
+    setopt localoptions nonomatch
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
         <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
         <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
@@ -122,25 +233,35 @@ _fzf_complete_ssh() {
 }
 
 _fzf_complete_export() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
 _fzf_complete_unset() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
 _fzf_complete_unalias() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
     alias | sed 's/=.*//'
   )
 }
 
+_fzf_complete_kill() {
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
+  )
+}
+
+_fzf_complete_kill_post() {
+  awk '{print $2}'
+}
+
 fzf-completion() {
-  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds
+  local tokens cmd prefix trigger tail matches lbuf d_cmds
   setopt localoptions noshwordsplit noksh_arrays noposixbuiltins
 
   # http://zsh.sourceforge.net/FAQ/zshfaq03.html
@@ -151,31 +272,36 @@ fzf-completion() {
     return
   fi
 
-  cmd=${tokens[1]}
+  cmd=$(__fzf_extract_command "$LBUFFER")
 
   # Explicitly allow for empty trigger.
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
 
+  # When the trigger starts with ';', it becomes a separate token
+  if [[ ${LBUFFER} = *"${tokens[-2]}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]}${tokens[-1]}"
+    tokens=(${tokens[0,-2]})
+  fi
+
+  lbuf=$LBUFFER
   tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
   # Kill completion (do not require trigger sequence)
-  if [ $cmd = kill -a ${LBUFFER[-1]} = ' ' ]; then
+  if [ "$cmd" = kill -a ${LBUFFER[-1]} = ' ' ]; then
-    fzf="$(__fzfcmd_complete)"
+    tail=$trigger
-    matches=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" ${=fzf} -m | awk '{print $2}' | tr '\n' ' ')
+    tokens+=$trigger
-    if [ -n "$matches" ]; then
+    lbuf="$lbuf$trigger"
-      LBUFFER="$LBUFFER$matches"
   fi
-    zle redisplay
+
-    typeset -f zle-line-init >/dev/null && zle zle-line-init
   # Trigger sequence given
-  elif [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
+  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
     d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})
 
     [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
-    [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}
+    [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
 
     if eval "type _fzf_complete_${cmd} > /dev/null"; then
-      eval "prefix=\"$prefix\" _fzf_complete_${cmd} \"$lbuf\""
+      prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
     elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
       _fzf_dir_completion "$prefix" "$lbuf"
     else
@@ -195,3 +321,9 @@ fzf-completion() {
 
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
+
+} always {
+  # Restore the original options.
+  eval $__fzf_completion_options
+  'unset' '__fzf_completion_options'
+}

shell/key-bindings.bash

@@ -1,3 +1,16 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.bash
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
 __fzf_select__() {
@@ -5,7 +18,7 @@ __fzf_select__() {
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | cut -b3-"}"
-  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" fzf -m "$@" | while read -r item; do
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read -r item; do
     printf '%q ' "$item"
   done
   echo
@@ -13,35 +26,15 @@ __fzf_select__() {
 
 if [[ $- =~ i ]]; then
 
-__fzf_use_tmux__() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]
-}
-
 __fzfcmd() {
-  __fzf_use_tmux__ &&
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
-}
-
-__fzf_select_tmux__() {
-  local height
-  height=${FZF_TMUX_HEIGHT:-40%}
-  if [[ $height =~ %$ ]]; then
-    height="-p ${height%\%}"
-  else
-    height="-l $height"
-  fi
-
-  tmux split-window $height "cd $(printf %q "$PWD"); FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS") PATH=$(printf %q "$PATH") FZF_CTRL_T_COMMAND=$(printf %q "$FZF_CTRL_T_COMMAND") FZF_CTRL_T_OPTS=$(printf %q "$FZF_CTRL_T_OPTS") bash -c 'source \"${BASH_SOURCE[0]}\"; RESULT=\"\$(__fzf_select__ --no-height)\"; tmux setb -b fzf \"\$RESULT\" \\; pasteb -b fzf -t $TMUX_PANE \\; deleteb -b fzf || tmux send-keys -t $TMUX_PANE \"\$RESULT\"'"
 }
 
 fzf-file-widget() {
-  if __fzf_use_tmux__; then
-    __fzf_select_tmux__
-  else
   local selected="$(__fzf_select__)"
   READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
   READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
-  fi
 }
 
 __fzf_cd__() {
@@ -51,71 +44,53 @@ __fzf_cd__() {
   dir=$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m) && printf 'cd %q' "$dir"
 }
 
-__fzf_history__() (
+__fzf_history__() {
-  local line
+  local output
-  shopt -u nocaseglob nocasematch
+  output=$(
-  line=$(
+    builtin fc -lnr -2147483648 |
-    HISTTIMEFORMAT= history |
+      last_hist=$(HISTTIMEFORMAT='' builtin history 1) perl -n -l0 -e 'BEGIN { getc; $/ = "\n\t"; $HISTCMD = $ENV{last_hist} + 1 } s/^[ *]//; print $HISTCMD - $. . "\t$_" if !$seen{$_}++' |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS --tac --sync -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m" $(__fzfcmd) |
+      FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m --read0" $(__fzfcmd) --query "$READLINE_LINE"
-    command grep '^ *[0-9]') &&
+  ) || return
-    if [[ $- =~ H ]]; then
+  READLINE_LINE=${output#*$'\t'}
-      sed 's/^ *\([0-9]*\)\** .*/!\1/' <<< "$line"
+  if [ -z "$READLINE_POINT" ]; then
+    echo "$READLINE_LINE"
   else
-      sed 's/^ *\([0-9]*\)\** *//' <<< "$line"
+    READLINE_POINT=0x7fffffff
   fi
-)
+}
 
-if [[ ! -o vi ]]; then
+# Required to refresh the prompt after fzf
-  # Required to refresh the prompt after fzf
+bind -m emacs-standard '"\er": redraw-current-line'
-  bind '"\er": redraw-current-line'
-  bind '"\e^": history-expand-line'
 
+bind -m vi-command '"\C-z": emacs-editing-mode'
+bind -m vi-insert '"\C-z": emacs-editing-mode'
+bind -m emacs-standard '"\C-z": vi-editing-mode'
+
+if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
   # CTRL-T - Paste the selected file path into the command line
-  if [ $BASH_VERSINFO -gt 3 ]; then
+  bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
-    bind -x '"\C-t": "fzf-file-widget"'
+  bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
-  elif __fzf_use_tmux__; then
+  bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
-    bind '"\C-t": " \C-u \C-a\C-k`__fzf_select_tmux__`\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
-  else
-    bind '"\C-t": " \C-u \C-a\C-k`__fzf_select__`\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
-  fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u\C-y\ey\C-u`__fzf_history__`\e\C-e\er\e^"'
+  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u"$(__fzf_history__)"\e\C-e\er"'
-
+  bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
-  # ALT-C - cd into the selected directory
+  bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
-  bind '"\ec": " \C-e\C-u`__fzf_cd__`\e\C-e\er\C-m"'
 else
-  # We'd usually use "\e" to enter vi-movement-mode so we can do our magic,
-  # but this incurs a very noticeable delay of a half second or so,
-  # because many other commands start with "\e".
-  # Instead, we bind an unused key, "\C-x\C-a",
-  # to also enter vi-movement-mode,
-  # and then use that thereafter.
-  # (We imagine that "\C-x\C-a" is relatively unlikely to be in use.)
-  bind '"\C-x\C-a": vi-movement-mode'
-
-  bind '"\C-x\C-e": shell-expand-line'
-  bind '"\C-x\C-r": redraw-current-line'
-  bind '"\C-x^": history-expand-line'
-
   # CTRL-T - Paste the selected file path into the command line
-  # - FIXME: Selected items are attached to the end regardless of cursor position
+  bind -m emacs-standard -x '"\C-t": fzf-file-widget'
-  if [ $BASH_VERSINFO -gt 3 ]; then
+  bind -m vi-command -x '"\C-t": fzf-file-widget'
-    bind -x '"\C-t": "fzf-file-widget"'
+  bind -m vi-insert -x '"\C-t": fzf-file-widget'
-  elif __fzf_use_tmux__; then
-    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi`__fzf_select_tmux__`\C-x\C-e\C-x\C-a0P$xa"'
-  else
-    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi`__fzf_select__`\C-x\C-e\C-x\C-a0Px$a \C-x\C-r\C-x\C-axa "'
-  fi
-  bind -m vi-command '"\C-t": "i\C-t"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\C-x\C-addi`__fzf_history__`\C-x\C-e\C-x\C-r\C-x^\C-x\C-a$a"'
+  bind -m emacs-standard -x '"\C-r": __fzf_history__'
-  bind -m vi-command '"\C-r": "i\C-r"'
+  bind -m vi-command -x '"\C-r": __fzf_history__'
-
+  bind -m vi-insert -x '"\C-r": __fzf_history__'
-  # ALT-C - cd into the selected directory
-  bind '"\ec": "\C-x\C-addi`__fzf_cd__`\C-x\C-e\C-x\C-r\C-m"'
-  bind -m vi-command '"\ec": "ddi`__fzf_cd__`\C-x\C-e\C-x\C-r\C-m"'
 fi
 
+# ALT-C - cd into the selected directory
+bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
+bind -m vi-command '"\ec": "\C-z\ec\C-z"'
+bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
+
 fi

shell/key-bindings.fish

@@ -1,3 +1,16 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.fish
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
 function fzf_key_bindings
@@ -10,13 +23,13 @@ function fzf_key_bindings
 
     # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
     # $dir itself, even if hidden.
-    set -q FZF_CTRL_T_COMMAND; or set -l FZF_CTRL_T_COMMAND "
+    test -n "$FZF_CTRL_T_COMMAND"; or set -l FZF_CTRL_T_COMMAND "
     command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 's@^\./@@'"
 
-    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
       eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
@@ -36,18 +49,18 @@ function fzf_key_bindings
   end
 
   function fzf-history-widget -d "Show command history"
-    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m"
 
-      set -l FISH_MAJOR (echo $FISH_VERSION | cut -f1 -d.)
+      set -l FISH_MAJOR (echo $version | cut -f1 -d.)
-      set -l FISH_MINOR (echo $FISH_VERSION | cut -f2 -d.)
+      set -l FISH_MINOR (echo $version | cut -f2 -d.)
 
       # history's -z flag is needed for multi-line support.
       # history's -z flag was added in fish 2.4.0, so don't use it for versions
       # before 2.4.0.
       if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
-        history -z | eval (__fzfcmd) --read0 -q '(commandline)' | perl -pe 'chomp if eof' | read -lz result
+        history -z | eval (__fzfcmd) --read0 --print0 -q '(commandline)' | read -lz result
         and commandline -- $result
       else
         history | eval (__fzfcmd) -q '(commandline)' | read -l result
@@ -62,10 +75,10 @@ function fzf_key_bindings
     set -l dir $commandline[1]
     set -l fzf_query $commandline[2]
 
-    set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
+    test -n "$FZF_ALT_C_COMMAND"; or set -l FZF_ALT_C_COMMAND "
     command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
     -o -type d -print 2> /dev/null | sed 's@^\./@@'"
-    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
       eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
@@ -82,10 +95,12 @@ function fzf_key_bindings
   end
 
   function __fzfcmd
-    set -q FZF_TMUX; or set FZF_TMUX 0
+    test -n "$FZF_TMUX"; or set FZF_TMUX 0
-    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    if [ $FZF_TMUX -eq 1 ]
+    if [ -n "$FZF_TMUX_OPTS" ]
-      echo "fzf-tmux -d$FZF_TMUX_HEIGHT"
+      echo "fzf-tmux $FZF_TMUX_OPTS -- "
+    else if [ $FZF_TMUX -eq 1 ]
+      echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
     else
       echo "fzf"
     end

shell/key-bindings.zsh

@@ -1,6 +1,42 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.zsh
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
-if [[ $- == *i* ]]; then
+
+# The code at the top and the bottom of this file is the same as in completion.zsh.
+# Refer to that file for explanation.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  __fzf_key_bindings_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  () {
+    __fzf_key_bindings_options="setopt"
+    'local' '__fzf_opt'
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        __fzf_key_bindings_options+=" -o $__fzf_opt"
+      else
+        __fzf_key_bindings_options+=" +o $__fzf_opt"
+      fi
+    done
+  }
+fi
+
+'emulate' 'zsh' '-o' 'no_aliases'
+
+{
+
+[[ -o interactive ]] || return 0
 
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
@@ -8,7 +44,7 @@ __fsel() {
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | cut -b3-"}"
-  setopt localoptions pipefail 2> /dev/null
+  setopt localoptions pipefail no_aliases 2> /dev/null
   eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read item; do
     echo -n "${(q)item} "
   done
@@ -17,20 +53,15 @@ __fsel() {
   return $ret
 }
 
-__fzf_use_tmux__() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]
-}
-
 __fzfcmd() {
-  __fzf_use_tmux__ &&
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
   LBUFFER="${LBUFFER}$(__fsel)"
   local ret=$?
-  zle redisplay
+  zle reset-prompt
-  typeset -f zle-line-init >/dev/null && zle zle-line-init
   return $ret
 }
 zle     -N   fzf-file-widget
@@ -50,16 +81,22 @@ zle -N fzf-redraw-prompt
 fzf-cd-widget() {
   local cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type d -print 2> /dev/null | cut -b3-"}"
-  setopt localoptions pipefail 2> /dev/null
+  setopt localoptions pipefail no_aliases 2> /dev/null
   local dir="$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m)"
   if [[ -z "$dir" ]]; then
     zle redisplay
     return 0
   fi
+  if [ -z "$BUFFER" ]; then
+    BUFFER="cd ${(q)dir}"
+    zle accept-line
+  else
+    print -sr "cd ${(q)dir}"
     cd "$dir"
+  fi
   local ret=$?
+  unset dir # ensure this doesn't end up appearing in prompt expansion
   zle fzf-redraw-prompt
-  typeset -f zle-line-init >/dev/null && zle zle-line-init
   return $ret
 }
 zle     -N    fzf-cd-widget
@@ -68,8 +105,8 @@ bindkey '\ec' fzf-cd-widget
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
   local selected num
-  setopt localoptions noglobsubst noposixbuiltins pipefail 2> /dev/null
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected=( $(fc -rl 1 |
+  selected=( $(fc -rl 1 | perl -ne 'print if !$seen{(/^\s*[0-9]+\**\s+(.*)/, $1)}++' |
     FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
   local ret=$?
   if [ -n "$selected" ]; then
@@ -78,11 +115,13 @@ fzf-history-widget() {
       zle vi-fetch-history -n $num
     fi
   fi
-  zle redisplay
+  zle reset-prompt
-  typeset -f zle-line-init >/dev/null && zle zle-line-init
   return $ret
 }
 zle     -N   fzf-history-widget
 bindkey '^R' fzf-history-widget
 
-fi
+} always {
+  eval $__fzf_key_bindings_options
+  'unset' '__fzf_key_bindings_options'
+}

src/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Junegunn Choi
+Copyright (c) 2013-2020 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/algo/algo.go

@@ -371,7 +371,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	// The first occurrence of each character in the pattern
 	offset32, F := alloc32(offset32, slab, M)
 	// Rune array
-	offset32, T := alloc32(offset32, slab, N)
+	_, T := alloc32(offset32, slab, N)
 	input.CopyRunes(T)
 
 	// Phase 2. Calculate bonus for each point
@@ -453,7 +453,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	copy(H, H0[f0:lastIdx+1])
 
 	// Possible length of consecutive chunk at each position.
-	offset16, C := alloc16(offset16, slab, width*M)
+	_, C := alloc16(offset16, slab, width*M)
 	copy(C, C0[f0:lastIdx+1])
 
 	Fsub := F[1:]
@@ -773,12 +773,17 @@ func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Ch
 		return Result{0, 0, 0}, nil
 	}
 
-	if text.Length() < len(pattern) {
+	trimmedLen := 0
+	if !unicode.IsSpace(pattern[0]) {
+		trimmedLen = text.LeadingWhitespaces()
+	}
+
+	if text.Length()-trimmedLen < len(pattern) {
 		return Result{-1, -1, 0}, nil
 	}
 
 	for index, r := range pattern {
-		char := text.Get(index)
+		char := text.Get(trimmedLen + index)
 		if !caseSensitive {
 			char = unicode.ToLower(char)
 		}
@@ -790,14 +795,17 @@ func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Ch
 		}
 	}
 	lenPattern := len(pattern)
-	score, _ := calculateScore(caseSensitive, normalize, text, pattern, 0, lenPattern, false)
+	score, _ := calculateScore(caseSensitive, normalize, text, pattern, trimmedLen, trimmedLen+lenPattern, false)
-	return Result{0, lenPattern, score}, nil
+	return Result{trimmedLen, trimmedLen + lenPattern, score}, nil
 }
 
 // SuffixMatch performs suffix-match
 func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenRunes := text.Length()
-	trimmedLen := lenRunes - text.TrailingWhitespaces()
+	trimmedLen := lenRunes
+	if len(pattern) == 0 || !unicode.IsSpace(pattern[len(pattern)-1]) {
+		trimmedLen -= text.TrailingWhitespaces()
+	}
 	if len(pattern) == 0 {
 		return Result{trimmedLen, trimmedLen, 0}, nil
 	}
@@ -828,14 +836,30 @@ func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Ch
 // EqualMatch performs equal-match
 func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenPattern := len(pattern)
-	if text.Length() != lenPattern {
+	if lenPattern == 0 {
+		return Result{-1, -1, 0}, nil
+	}
+
+	// Strip leading whitespaces
+	trimmedLen := 0
+	if !unicode.IsSpace(pattern[0]) {
+		trimmedLen = text.LeadingWhitespaces()
+	}
+
+	// Strip trailing whitespaces
+	trimmedEndLen := 0
+	if !unicode.IsSpace(pattern[lenPattern-1]) {
+		trimmedEndLen = text.TrailingWhitespaces()
+	}
+
+	if text.Length()-trimmedLen-trimmedEndLen != lenPattern {
 		return Result{-1, -1, 0}, nil
 	}
 	match := true
 	if normalize {
 		runes := text.ToRunes()
 		for idx, pchar := range pattern {
-			char := runes[idx]
+			char := runes[trimmedLen+idx]
 			if !caseSensitive {
 				char = unicode.To(unicode.LowerCase, char)
 			}
@@ -845,14 +869,15 @@ func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Cha
 			}
 		}
 	} else {
-		runesStr := text.ToString()
+		runes := text.ToRunes()
+		runesStr := string(runes[trimmedLen : len(runes)-trimmedEndLen])
 		if !caseSensitive {
 			runesStr = strings.ToLower(runesStr)
 		}
 		match = runesStr == string(pattern)
 	}
 	if match {
-		return Result{0, lenPattern, (scoreMatch+bonusBoundary)*lenPattern +
+		return Result{trimmedLen, trimmedLen + lenPattern, (scoreMatch+bonusBoundary)*lenPattern +
 			(bonusFirstCharMultiplier-1)*bonusBoundary}, nil
 	}
 	return Result{-1, -1, 0}, nil

src/algo/algo_test.go

@@ -136,6 +136,10 @@ func TestPrefixMatch(t *testing.T) {
 		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, score)
 		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, score)
 		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, score)
+
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", "foo", 1, 4, score)
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", " fo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "     fo", "foo", -1, -1, 0)
 	}
 }
 
@@ -148,6 +152,13 @@ func TestSuffixMatch(t *testing.T) {
 			scoreMatch*3+bonusConsecutive*2)
 		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9,
 			(scoreMatch+bonusCamel123)*3+bonusCamel123*(bonusFirstCharMultiplier-1))
+
+		// Strip trailing white space from the string
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+		// Only when the pattern doesn't end with a space
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz ", 6, 10,
+			scoreMatch*4+bonusConsecutive*2+bonusNonWord)
 	}
 }
 

src/algo/normalize.go

@@ -405,6 +405,74 @@ var normalized map[rune]rune = map[rune]rune{
 	0x024E: 'Y', //  WITH STROKE, LATIN CAPITAL LETTER
 	0x028F: 'Y', // , LATIN LETTER SMALL CAPITAL
 	0x1D22: 'Z', // , LATIN LETTER SMALL CAPITAL
+
+	'Ắ': 'A',
+	'Ấ': 'A',
+	'Ằ': 'A',
+	'Ầ': 'A',
+	'Ẳ': 'A',
+	'Ẩ': 'A',
+	'Ẵ': 'A',
+	'Ẫ': 'A',
+	'Ặ': 'A',
+	'Ậ': 'A',
+
+	'ắ': 'a',
+	'ấ': 'a',
+	'ằ': 'a',
+	'ầ': 'a',
+	'ẳ': 'a',
+	'ẩ': 'a',
+	'ẵ': 'a',
+	'ẫ': 'a',
+	'ặ': 'a',
+	'ậ': 'a',
+
+	'Ế': 'E',
+	'Ề': 'E',
+	'Ể': 'E',
+	'Ễ': 'E',
+	'Ệ': 'E',
+
+	'ế': 'e',
+	'ề': 'e',
+	'ể': 'e',
+	'ễ': 'e',
+	'ệ': 'e',
+
+	'Ố': 'O',
+	'Ớ': 'O',
+	'Ồ': 'O',
+	'Ờ': 'O',
+	'Ổ': 'O',
+	'Ở': 'O',
+	'Ỗ': 'O',
+	'Ỡ': 'O',
+	'Ộ': 'O',
+	'Ợ': 'O',
+
+	'ố': 'o',
+	'ớ': 'o',
+	'ồ': 'o',
+	'ờ': 'o',
+	'ổ': 'o',
+	'ở': 'o',
+	'ỗ': 'o',
+	'ỡ': 'o',
+	'ộ': 'o',
+	'ợ': 'o',
+
+	'Ứ': 'U',
+	'Ừ': 'U',
+	'Ử': 'U',
+	'Ữ': 'U',
+	'Ự': 'U',
+
+	'ứ': 'u',
+	'ừ': 'u',
+	'ử': 'u',
+	'ữ': 'u',
+	'ự': 'u',
 }
 
 // NormalizeRunes normalizes latin script letters

src/ansi.go

@@ -32,6 +32,55 @@ func (s *ansiState) equals(t *ansiState) bool {
 	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr
 }
 
+func (s *ansiState) ToString() string {
+	if !s.colored() {
+		return ""
+	}
+
+	ret := ""
+	if s.attr&tui.Bold > 0 {
+		ret += "1;"
+	}
+	if s.attr&tui.Dim > 0 {
+		ret += "2;"
+	}
+	if s.attr&tui.Italic > 0 {
+		ret += "3;"
+	}
+	if s.attr&tui.Underline > 0 {
+		ret += "4;"
+	}
+	if s.attr&tui.Blink > 0 {
+		ret += "5;"
+	}
+	if s.attr&tui.Reverse > 0 {
+		ret += "7;"
+	}
+	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)
+
+	return "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
+}
+
+func toAnsiString(color tui.Color, offset int) string {
+	col := int(color)
+	ret := ""
+	if col == -1 {
+		ret += strconv.Itoa(offset + 9)
+	} else if col < 8 {
+		ret += strconv.Itoa(offset + col)
+	} else if col < 16 {
+		ret += strconv.Itoa(offset - 30 + 90 + col - 8)
+	} else if col < 256 {
+		ret += strconv.Itoa(offset+8) + ";5;" + strconv.Itoa(col)
+	} else if col >= (1 << 24) {
+		r := strconv.Itoa((col >> 16) & 0xff)
+		g := strconv.Itoa((col >> 8) & 0xff)
+		b := strconv.Itoa(col & 0xff)
+		ret += strconv.Itoa(offset+8) + ";2;" + r + ";" + g + ";" + b
+	}
+	return ret + ";"
+}
+
 var ansiRegex *regexp.Regexp
 
 func init() {
@@ -41,10 +90,11 @@ func init() {
 		- http://ascii-table.com/ansi-escape-sequences.php
 		- http://ascii-table.com/ansi-escape-sequences-vt-100.php
 		- http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+		- https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
 	*/
 	// The following regular expression will include not all but most of the
 	// frequently used ANSI sequences
-	ansiRegex = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x0e\x0f]|.\x08)")
+	ansiRegex = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
 }
 
 func findAnsiStart(str string) int {
@@ -194,6 +244,10 @@ func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
 					state.attr = state.attr | tui.Blink
 				case 7:
 					state.attr = state.attr | tui.Reverse
+				case 23: // tput rmso
+					state.attr = state.attr &^ tui.Italic
+				case 24: // tput rmul
+					state.attr = state.attr &^ tui.Underline
 				case 0:
 					init()
 				default:

src/ansi_test.go

@@ -2,6 +2,7 @@ package fzf
 
 import (
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/junegunn/fzf/src/tui"
@@ -156,3 +157,31 @@ func TestExtractColor(t *testing.T) {
 		assert((*offsets)[1], 6, 11, 200, 100, false)
 	})
 }
+
+func TestAnsiCodeStringConversion(t *testing.T) {
+	assert := func(code string, prevState *ansiState, expected string) {
+		state := interpretCode(code, prevState)
+		if expected != state.ToString() {
+			t.Errorf("expected: %s, actual: %s",
+				strings.Replace(expected, "\x1b[", "\\x1b[", -1),
+				strings.Replace(state.ToString(), "\x1b[", "\\x1b[", -1))
+		}
+	}
+	assert("\x1b[m", nil, "")
+	assert("\x1b[m", &ansiState{attr: tui.Blink}, "")
+
+	assert("\x1b[31m", nil, "\x1b[31;49m")
+	assert("\x1b[41m", nil, "\x1b[39;41m")
+
+	assert("\x1b[92m", nil, "\x1b[92;49m")
+	assert("\x1b[102m", nil, "\x1b[39;102m")
+
+	assert("\x1b[31m", &ansiState{fg: 4, bg: 4}, "\x1b[31;44m")
+	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, attr: tui.Reverse}, "\x1b[1;2;7;31;49m")
+	assert("\x1b[38;5;100;48;5;200m", nil, "\x1b[38;5;100;48;5;200m")
+	assert("\x1b[48;5;100;38;5;200m", nil, "\x1b[38;5;200;48;5;100m")
+	assert("\x1b[48;5;100;38;2;10;20;30;1m", nil, "\x1b[1;38;2;10;20;30;48;5;100m")
+	assert("\x1b[48;5;100;38;2;10;20;30;7m",
+		&ansiState{attr: tui.Dim | tui.Italic, fg: 1, bg: 1},
+		"\x1b[2;3;7;38;2;10;20;30;48;5;100m")
+}

src/chunklist.go

@@ -64,6 +64,13 @@ func (cl *ChunkList) Push(data []byte) bool {
 	return ret
 }
 
+// Clear clears the data
+func (cl *ChunkList) Clear() {
+	cl.mutex.Lock()
+	cl.chunks = nil
+	cl.mutex.Unlock()
+}
+
 // Snapshot returns immutable snapshot of the ChunkList
 func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
 	cl.mutex.Lock()

src/constants.go

@@ -1,6 +1,7 @@
 package fzf
 
 import (
+	"math"
 	"os"
 	"time"
 
@@ -9,7 +10,7 @@ import (
 
 const (
 	// Current version
-	version = "0.17.4"
+	version = "0.23.0"
 
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
@@ -24,7 +25,10 @@ const (
 	// Terminal
 	initialDelay      = 20 * time.Millisecond
 	initialDelayTac   = 100 * time.Millisecond
-	spinnerDuration = 200 * time.Millisecond
+	spinnerDuration   = 100 * time.Millisecond
+	previewCancelWait = 500 * time.Millisecond
+	maxPatternLength  = 300
+	maxMulti          = math.MaxInt32
 
 	// Matcher
 	numPartitionsMultiplier = 8
@@ -58,8 +62,6 @@ func init() {
 		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
 	} else if os.Getenv("TERM") == "cygwin" {
 		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
-	} else {
-		defaultCommand = `for /r %P in (*) do @(set "_curfile=%P" & set "_curfile=!_curfile:%__CD__%=!" & echo !_curfile!)`
 	}
 }
 
@@ -75,6 +77,7 @@ const (
 )
 
 const (
+	exitCancel    = -1
 	exitOk        = 0
 	exitNoMatch   = 1
 	exitError     = 2

src/core.go

@@ -63,12 +63,14 @@ func Run(opts *Options, revision string) {
 	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
 		return util.ToChars(data), nil
 	}
+
+	var lineAnsiState, prevLineAnsiState *ansiState
 	if opts.Ansi {
 		if opts.Theme != nil {
-			var state *ansiState
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-				trimmed, offsets, newState := extractColor(string(data), state, nil)
+				prevLineAnsiState = lineAnsiState
-				state = newState
+				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
+				lineAnsiState = newState
 				return util.ToChars([]byte(trimmed)), offsets
 			}
 		} else {
@@ -100,6 +102,22 @@ func Run(opts *Options, revision string) {
 	} else {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			tokens := Tokenize(string(data), opts.Delimiter)
+			if opts.Ansi && opts.Theme != nil && len(tokens) > 1 {
+				var ansiState *ansiState
+				if prevLineAnsiState != nil {
+					ansiStateDup := *prevLineAnsiState
+					ansiState = &ansiStateDup
+				}
+				for _, token := range tokens {
+					prevAnsiState := ansiState
+					_, _, ansiState = extractColor(token.text.ToString(), ansiState, nil)
+					if prevAnsiState != nil {
+						token.text.Prepend("\x1b[m" + prevAnsiState.ToString())
+					} else {
+						token.text.Prepend("\x1b[m")
+					}
+				}
+			}
 			trans := Transform(tokens, opts.WithNth)
 			transformed := joinTokens(trans)
 			if len(header) < opts.HeaderLines {
@@ -108,6 +126,7 @@ func Run(opts *Options, revision string) {
 				return false
 			}
 			item.text, item.colors = ansiProcessor([]byte(transformed))
+			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
 			itemIndex++
@@ -117,10 +136,11 @@ func Run(opts *Options, revision string) {
 
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
+	var reader *Reader
 	if !streamingFilter {
-		reader := NewReader(func(data []byte) bool {
+		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, opts.ReadZero)
+		}, eventBox, opts.ReadZero, opts.Filter == nil)
 		go reader.ReadSource()
 	}
 
@@ -149,6 +169,7 @@ func Run(opts *Options, revision string) {
 		}
 
 		pattern := patternBuilder([]rune(*opts.Filter))
+		matcher.sort = pattern.sortable
 
 		found := false
 		if streamingFilter {
@@ -163,7 +184,7 @@ func Run(opts *Options, revision string) {
 						}
 					}
 					return false
-				}, eventBox, opts.ReadZero)
+				}, eventBox, opts.ReadZero, false)
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -203,11 +224,28 @@ func Run(opts *Options, revision string) {
 
 	// Event coordination
 	reading := true
+	clearCache := util.Once(false)
+	clearSelection := util.Once(false)
 	ticks := 0
+	var nextCommand *string
+	restart := func(command string) {
+		reading = true
+		clearCache = util.Once(true)
+		clearSelection = util.Once(true)
+		chunkList.Clear()
+		header = make([]string, 0, opts.HeaderLines)
+		go reader.restart(command)
+	}
 	eventBox.Watch(EvtReadNew)
 	for {
 		delay := true
 		ticks++
+		input := func() []rune {
+			if opts.Phony {
+				return []rune{}
+			}
+			return []rune(terminal.Input())
+		}
 		eventBox.Wait(func(events *util.Events) {
 			if _, fin := (*events)[EvtReadFin]; fin {
 				delete(*events, EvtReadNew)
@@ -216,21 +254,39 @@ func Run(opts *Options, revision string) {
 				switch evt {
 
 				case EvtReadNew, EvtReadFin:
+					if evt == EvtReadFin && nextCommand != nil {
+						restart(*nextCommand)
+						nextCommand = nil
+						break
+					} else {
 						reading = reading && evt == EvtReadNew
-					snapshot, count := chunkList.Snapshot()
-					terminal.UpdateCount(count, !reading, value.(bool))
-					if opts.Sync {
-						terminal.UpdateList(PassMerger(&snapshot, opts.Tac))
 					}
-					matcher.Reset(snapshot, terminal.Input(), false, !reading, sort)
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading, value.(*string))
+					if opts.Sync {
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
+					}
+					matcher.Reset(snapshot, input(), false, !reading, sort, clearCache())
 
 				case EvtSearchNew:
+					var command *string
 					switch val := value.(type) {
-					case bool:
+					case searchRequest:
-						sort = val
+						sort = val.sort
+						command = val.command
+					}
+					if command != nil {
+						if reading {
+							reader.terminate()
+							nextCommand = command
+						} else {
+							restart(*command)
+						}
+						break
 					}
 					snapshot, _ := chunkList.Snapshot()
-					matcher.Reset(snapshot, terminal.Input(), true, !reading, sort)
+					matcher.Reset(snapshot, input(), true, !reading, sort, clearCache())
 					delay = false
 
 				case EvtSearchProgress:
@@ -240,7 +296,9 @@ func Run(opts *Options, revision string) {
 					}
 
 				case EvtHeader:
-					terminal.UpdateHeader(value.([]string))
+					headerPadded := make([]string, opts.HeaderLines)
+					copy(headerPadded, value.([]string))
+					terminal.UpdateHeader(headerPadded)
 
 				case EvtSearchFin:
 					switch val := value.(type) {
@@ -270,7 +328,7 @@ func Run(opts *Options, revision string) {
 								terminal.startChan <- true
 							}
 						}
-						terminal.UpdateList(val)
+						terminal.UpdateList(val, clearSelection())
 					}
 				}
 			}

src/history.go

@@ -59,7 +59,7 @@ func (h *History) append(line string) error {
 
 	lines := append(h.lines[:len(h.lines)-1], line)
 	if len(lines) > h.maxSize {
-		lines = lines[len(lines)-h.maxSize : len(lines)]
+		lines = lines[len(lines)-h.maxSize:]
 	}
 	h.lines = append(lines, "")
 	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)

src/matcher.go

@@ -16,6 +16,7 @@ type MatchRequest struct {
 	pattern    *Pattern
 	final      bool
 	sort       bool
+	clearCache bool
 }
 
 // Matcher is responsible for performing search
@@ -69,7 +70,7 @@ func (m *Matcher) Loop() {
 			events.Clear()
 		})
 
-		if request.sort != m.sort {
+		if request.sort != m.sort || request.clearCache {
 			m.sort = request.sort
 			m.mergerCache = make(map[string]*Merger)
 			clearChunkCache()
@@ -207,13 +208,13 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 			return nil, wait()
 		}
 
-		if time.Now().Sub(startedAt) > progressMinDuration {
+		if time.Since(startedAt) > progressMinDuration {
 			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
 		}
 	}
 
 	partialResults := make([][]Result, numSlices)
-	for _ = range slices {
+	for range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
@@ -221,7 +222,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 }
 
 // Reset is called to interrupt/signal the ongoing search
-func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, clearCache bool) {
 	pattern := m.patternBuilder(patternRunes)
 
 	var event util.EventType
@@ -230,5 +231,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort})
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
 }

src/options.go

@@ -6,12 +6,13 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"unicode"
 	"unicode/utf8"
 
 	"github.com/junegunn/fzf/src/algo"
 	"github.com/junegunn/fzf/src/tui"
-	"github.com/junegunn/fzf/src/util"
 
+	"github.com/mattn/go-runewidth"
 	"github.com/mattn/go-shellwords"
 )
 
@@ -33,15 +34,17 @@ const usage = `usage: fzf [options]
     -d, --delimiter=STR   Field delimiter regex (default: AWK-style)
     +s, --no-sort         Do not sort the result
     --tac                 Reverse the order of the input
+    --phony               Do not perform search
     --tiebreak=CRI[,..]   Comma-separated list of sort criteria to apply
                           when the scores are tied [length|begin|end|index]
                           (default: length)
 
   Interface
-    -m, --multi           Enable multi-select with tab/shift-tab
+    -m, --multi[=MAX]     Enable multi-select with tab/shift-tab
     --no-mouse            Disable mouse
     --bind=KEYBINDS       Custom key bindings. Refer to the man page.
     --cycle               Enable cyclic scroll
+    --keep-right          Keep the right end of the line visible on overflow
     --no-hscroll          Disable horizontal scroll
     --hscroll-off=COL     Number of screen columns to keep to the right of the
                           highlighted substring (default: 10)
@@ -54,10 +57,13 @@ const usage = `usage: fzf [options]
     --min-height=HEIGHT   Minimum height when --height is given in percent
                           (default: 10)
     --layout=LAYOUT       Choose layout: [default|reverse|reverse-list]
-    --border              Draw border above and below the finder
+    --border[=STYLE]      Draw border around the finder
+                          [rounded|sharp|horizontal] (default: rounded)
     --margin=MARGIN       Screen margin (TRBL / TB,RL / T,RL,B / T,R,B,L)
-    --inline-info         Display finder info inline with the query
+    --info=STYLE          Finder info style [default|inline|hidden]
     --prompt=STR          Input prompt (default: '> ')
+    --pointer=STR         Pointer to the current line (default: '>')
+    --marker=STR          Multi-select marker (default: '>')
     --header=STR          String to print as header
     --header-lines=N      The first N lines of the input are treated as header
 
@@ -74,7 +80,9 @@ const usage = `usage: fzf [options]
   Preview
     --preview=COMMAND     Command to preview highlighted line ({})
     --preview-window=OPT  Preview window layout (default: right:50%)
-                          [up|down|left|right][:SIZE[%]][:wrap][:hidden]
+                          [up|down|left|right][:SIZE[%]][:wrap][:cycle][:hidden]
+                          [:+SCROLL[-OFFSET]]
+                          [:rounded|sharp|noborder]
 
   Scripting
     -q, --query=STR       Start the finder with the given query
@@ -141,12 +149,23 @@ const (
 	layoutReverseList
 )
 
+type infoStyle int
+
+const (
+	infoDefault infoStyle = iota
+	infoInline
+	infoHidden
+)
+
 type previewOpts struct {
 	command  string
 	position windowPosition
 	size     sizeSpec
+	scroll   string
 	hidden   bool
 	wrap     bool
+	cycle    bool
+	border   tui.BorderShape
 }
 
 // Options stores the values of command-line options
@@ -154,6 +173,7 @@ type Options struct {
 	Fuzzy       bool
 	FuzzyAlgo   algo.Algo
 	Extended    bool
+	Phony       bool
 	Case        Case
 	Normalize   bool
 	Nth         []Range
@@ -162,7 +182,7 @@ type Options struct {
 	Sort        int
 	Tac         bool
 	Criteria    []criterion
-	Multi       bool
+	Multi       int
 	Ansi        bool
 	Mouse       bool
 	Theme       *tui.ColorTheme
@@ -172,12 +192,15 @@ type Options struct {
 	MinHeight   int
 	Layout      layoutType
 	Cycle       bool
+	KeepRight   bool
 	Hscroll     bool
 	HscrollOff  int
 	FileWord    bool
-	InlineInfo  bool
+	InfoStyle   infoStyle
 	JumpLabels  string
 	Prompt      string
+	Pointer     string
+	Marker      string
 	Query       string
 	Select1     bool
 	Exit0       bool
@@ -189,12 +212,14 @@ type Options struct {
 	PrintQuery  bool
 	ReadZero    bool
 	Printer     func(string)
+	PrintSep    string
 	Sync        bool
 	History     *History
 	Header      []string
 	HeaderLines int
 	Margin      [4]sizeSpec
-	Bordered    bool
+	BorderShape tui.BorderShape
+	Unicode     bool
 	Tabstop     int
 	ClearOnExit bool
 	Version     bool
@@ -205,6 +230,7 @@ func defaultOptions() *Options {
 		Fuzzy:       true,
 		FuzzyAlgo:   algo.FuzzyMatchV2,
 		Extended:    true,
+		Phony:       false,
 		Case:        CaseSmart,
 		Normalize:   true,
 		Nth:         make([]Range, 0),
@@ -213,7 +239,7 @@ func defaultOptions() *Options {
 		Sort:        1000,
 		Tac:         false,
 		Criteria:    []criterion{byScore, byLength},
-		Multi:       false,
+		Multi:       0,
 		Ansi:        false,
 		Mouse:       true,
 		Theme:       tui.EmptyTheme(),
@@ -222,12 +248,15 @@ func defaultOptions() *Options {
 		MinHeight:   10,
 		Layout:      layoutDefault,
 		Cycle:       false,
+		KeepRight:   false,
 		Hscroll:     true,
 		HscrollOff:  10,
 		FileWord:    false,
-		InlineInfo:  false,
+		InfoStyle:   infoDefault,
 		JumpLabels:  defaultJumpLabels,
 		Prompt:      "> ",
+		Pointer:     ">",
+		Marker:      ">",
 		Query:       "",
 		Select1:     false,
 		Exit0:       false,
@@ -235,22 +264,24 @@ func defaultOptions() *Options {
 		ToggleSort:  false,
 		Expect:      make(map[int]string),
 		Keymap:      make(map[int][]action),
-		Preview:     previewOpts{"", posRight, sizeSpec{50, true}, false, false},
+		Preview:     previewOpts{"", posRight, sizeSpec{50, true}, "", false, false, false, tui.BorderRounded},
 		PrintQuery:  false,
 		ReadZero:    false,
 		Printer:     func(str string) { fmt.Println(str) },
+		PrintSep:    "\n",
 		Sync:        false,
 		History:     nil,
 		Header:      make([]string, 0),
 		HeaderLines: 0,
 		Margin:      defaultMargin(),
+		Unicode:     true,
 		Tabstop:     8,
 		ClearOnExit: true,
 		Version:     false}
 }
 
 func help(code int) {
-	os.Stderr.WriteString(usage)
+	os.Stdout.WriteString(usage)
 	os.Exit(code)
 }
 
@@ -277,12 +308,12 @@ func nextString(args []string, i *int, message string) string {
 	return args[*i]
 }
 
-func optionalNextString(args []string, i *int) string {
+func optionalNextString(args []string, i *int) (bool, string) {
-	if len(args) > *i+1 && !strings.HasPrefix(args[*i+1], "-") {
+	if len(args) > *i+1 && !strings.HasPrefix(args[*i+1], "-") && !strings.HasPrefix(args[*i+1], "+") {
 		*i++
-		return args[*i]
+		return true, args[*i]
 	}
-	return ""
+	return false, ""
 }
 
 func atoi(str string) int {
@@ -310,13 +341,14 @@ func nextInt(args []string, i *int, message string) int {
 	return atoi(args[*i])
 }
 
-func optionalNumeric(args []string, i *int) int {
+func optionalNumeric(args []string, i *int, defaultValue int) int {
 	if len(args) > *i+1 {
 		if strings.IndexAny(args[*i+1], "0123456789") == 0 {
 			*i++
+			return atoi(args[*i])
 		}
 	}
-	return 1 // Don't care
+	return defaultValue
 }
 
 func splitNth(str string) []Range {
@@ -375,13 +407,30 @@ func parseAlgo(str string) algo.Algo {
 	return algo.FuzzyMatchV2
 }
 
+func parseBorder(str string, optional bool) tui.BorderShape {
+	switch str {
+	case "rounded":
+		return tui.BorderRounded
+	case "sharp":
+		return tui.BorderSharp
+	case "horizontal":
+		return tui.BorderHorizontal
+	default:
+		if optional && str == "" {
+			return tui.BorderRounded
+		}
+		errorExit("invalid border style (expected: rounded|sharp|horizontal)")
+	}
+	return tui.BorderNone
+}
+
 func parseKeyChords(str string, message string) map[int]string {
 	if len(str) == 0 {
 		errorExit(message)
 	}
 
 	tokens := strings.Split(str, ",")
-	if str == "," || strings.HasPrefix(str, ",,") || strings.HasSuffix(str, ",,") || strings.Index(str, ",,,") >= 0 {
+	if str == "," || strings.HasPrefix(str, ",,") || strings.HasSuffix(str, ",,") || strings.Contains(str, ",,,") {
 		tokens = append(tokens, ",")
 	}
 
@@ -409,8 +458,18 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = tui.BSpace
 		case "ctrl-space":
 			chord = tui.CtrlSpace
+		case "ctrl-^", "ctrl-6":
+			chord = tui.CtrlCaret
+		case "ctrl-/", "ctrl-_":
+			chord = tui.CtrlSlash
+		case "ctrl-\\":
+			chord = tui.CtrlBackSlash
+		case "ctrl-]":
+			chord = tui.CtrlRightBracket
 		case "change":
 			chord = tui.Change
+		case "backward-eof":
+			chord = tui.BackwardEOF
 		case "alt-enter", "alt-return":
 			chord = tui.CtrlAltM
 		case "alt-space":
@@ -439,6 +498,8 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = tui.Home
 		case "end":
 			chord = tui.End
+		case "insert":
+			chord = tui.Insert
 		case "pgup", "page-up":
 			chord = tui.PgUp
 		case "pgdn", "page-down":
@@ -572,10 +633,16 @@ func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme {
 				theme.Fg = ansi
 			case "bg":
 				theme.Bg = ansi
+			case "preview-fg":
+				theme.PreviewFg = ansi
+			case "preview-bg":
+				theme.PreviewBg = ansi
 			case "fg+":
 				theme.Current = ansi
 			case "bg+":
 				theme.DarkBg = ansi
+			case "gutter":
+				theme.Gutter = ansi
 			case "hl":
 				theme.Match = ansi
 			case "hl+":
@@ -621,13 +688,21 @@ func init() {
 	// Backreferences are not supported.
 	// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
 	executeRegexp = regexp.MustCompile(
-		"(?si):(execute(?:-multi|-silent)?):.+|:(execute(?:-multi|-silent)?)(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
+		`(?si)[:+](execute(?:-multi|-silent)?|reload|preview):.+|[:+](execute(?:-multi|-silent)?|reload|preview)(\([^)]*\)|\[[^\]]*\]|~[^~]*~|![^!]*!|@[^@]*@|\#[^\#]*\#|\$[^\$]*\$|%[^%]*%|\^[^\^]*\^|&[^&]*&|\*[^\*]*\*|;[^;]*;|/[^/]*/|\|[^\|]*\|)`)
 }
 
 func parseKeymap(keymap map[int][]action, str string) {
 	masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string {
-		prefix := ":execute"
+		symbol := ":"
-		if src[len(prefix)] == '-' {
+		if strings.HasPrefix(src, "+") {
+			symbol = "+"
+		}
+		prefix := symbol + "execute"
+		if strings.HasPrefix(src[1:], "reload") {
+			prefix = symbol + "reload"
+		} else if strings.HasPrefix(src[1:], "preview") {
+			prefix = symbol + "preview"
+		} else if src[len(prefix)] == '-' {
 			c := src[len(prefix)+1]
 			if c == 's' || c == 'S' {
 				prefix += "-silent"
@@ -687,12 +762,16 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actAcceptNonEmpty)
 			case "print-query":
 				appendAction(actPrintQuery)
+			case "refresh-preview":
+				appendAction(actRefreshPreview)
 			case "replace-query":
 				appendAction(actReplaceQuery)
 			case "backward-char":
 				appendAction(actBackwardChar)
 			case "backward-delete-char":
 				appendAction(actBackwardDeleteChar)
+			case "backward-delete-char/eof":
+				appendAction(actBackwardDeleteCharEOF)
 			case "backward-word":
 				appendAction(actBackwardWord)
 			case "clear-screen":
@@ -705,6 +784,10 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actEndOfLine)
 			case "cancel":
 				appendAction(actCancel)
+			case "clear-query":
+				appendAction(actClearQuery)
+			case "clear-selection":
+				appendAction(actClearSelection)
 			case "forward-char":
 				appendAction(actForwardChar)
 			case "forward-word":
@@ -773,13 +856,25 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actPreviewPageUp)
 			case "preview-page-down":
 				appendAction(actPreviewPageDown)
+			case "preview-half-page-up":
+				appendAction(actPreviewHalfPageUp)
+			case "preview-half-page-down":
+				appendAction(actPreviewHalfPageDown)
 			default:
 				t := isExecuteAction(specLower)
 				if t == actIgnore {
+					if specIndex == 0 && specLower == "" {
+						actions = append(keymap[key], actions...)
+					} else {
 						errorExit("unknown action: " + spec)
+					}
 				} else {
 					var offset int
 					switch t {
+					case actReload:
+						offset = len("reload")
+					case actPreview:
+						offset = len("preview")
 					case actExecuteSilent:
 						offset = len("execute-silent")
 					case actExecuteMulti:
@@ -815,6 +910,10 @@ func isExecuteAction(str string) actionType {
 		prefix = matches[0][2]
 	}
 	switch prefix {
+	case "reload":
+		return actReload
+	case "preview":
+		return actPreview
 	case "execute":
 		return actExecute
 	case "execute-silent":
@@ -880,21 +979,33 @@ func parseLayout(str string) layoutType {
 	return layoutDefault
 }
 
-func parsePreviewWindow(opts *previewOpts, input string) {
+func parseInfoStyle(str string) infoStyle {
-	// Default
+	switch str {
-	opts.position = posRight
+	case "default":
-	opts.size = sizeSpec{50, true}
+		return infoDefault
-	opts.hidden = false
+	case "inline":
-	opts.wrap = false
+		return infoInline
+	case "hidden":
+		return infoHidden
+	default:
+		errorExit("invalid info style (expected: default / inline / hidden)")
+	}
+	return infoDefault
+}
 
+func parsePreviewWindow(opts *previewOpts, input string) {
 	tokens := strings.Split(input, ":")
 	sizeRegex := regexp.MustCompile("^[0-9]+%?$")
+	offsetRegex := regexp.MustCompile("^\\+([0-9]+|{-?[0-9]+})(-[0-9]+|-/[1-9][0-9]*)?$")
 	for _, token := range tokens {
 		switch token {
+		case "":
 		case "hidden":
 			opts.hidden = true
 		case "wrap":
 			opts.wrap = true
+		case "cycle":
+			opts.cycle = true
 		case "up", "top":
 			opts.position = posUp
 		case "down", "bottom":
@@ -903,22 +1014,22 @@ func parsePreviewWindow(opts *previewOpts, input string) {
 			opts.position = posLeft
 		case "right":
 			opts.position = posRight
+		case "rounded", "border":
+			opts.border = tui.BorderRounded
+		case "sharp":
+			opts.border = tui.BorderSharp
+		case "noborder":
+			opts.border = tui.BorderNone
 		default:
 			if sizeRegex.MatchString(token) {
 				opts.size = parseSize(token, 99, "window size")
+			} else if offsetRegex.MatchString(token) {
+				opts.scroll = token[1:]
 			} else {
-				errorExit("invalid preview window layout: " + input)
+				errorExit("invalid preview window option: " + token)
 			}
 		}
 	}
-	if !opts.size.percent && opts.size.size > 0 {
-		// Adjust size for border
-		opts.size.size += 2
-		// And padding
-		if opts.position == posLeft || opts.position == posRight {
-			opts.size.size += 2
-		}
-	}
 }
 
 func parseMargin(margin string) [4]sizeSpec {
@@ -973,6 +1084,8 @@ func parseOptions(opts *Options, allArgs []string) {
 		}
 	}
 	validateJumpLabels := false
+	validatePointer := false
+	validateMarker := false
 	for i := 0; i < len(allArgs); i++ {
 		arg := allArgs[i]
 		switch arg {
@@ -1007,12 +1120,16 @@ func parseOptions(opts *Options, allArgs []string) {
 			}
 		case "--no-expect":
 			opts.Expect = make(map[int]string)
+		case "--no-phony":
+			opts.Phony = false
+		case "--phony":
+			opts.Phony = true
 		case "--tiebreak":
 			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
 			parseKeymap(opts.Keymap, nextString(allArgs, &i, "bind expression required"))
 		case "--color":
-			spec := optionalNextString(allArgs, &i)
+			_, spec := optionalNextString(allArgs, &i)
 			if len(spec) == 0 {
 				opts.Theme = tui.EmptyTheme()
 			} else {
@@ -1027,7 +1144,7 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--with-nth":
 			opts.WithNth = splitNth(nextString(allArgs, &i, "nth expression required"))
 		case "-s", "--sort":
-			opts.Sort = optionalNumeric(allArgs, &i)
+			opts.Sort = optionalNumeric(allArgs, &i, 1)
 		case "+s", "--no-sort":
 			opts.Sort = 0
 		case "--tac":
@@ -1039,9 +1156,9 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "+i":
 			opts.Case = CaseRespect
 		case "-m", "--multi":
-			opts.Multi = true
+			opts.Multi = optionalNumeric(allArgs, &i, maxMulti)
 		case "+m", "--no-multi":
-			opts.Multi = false
+			opts.Multi = 0
 		case "--ansi":
 			opts.Ansi = true
 		case "--no-ansi":
@@ -1071,6 +1188,10 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Cycle = true
 		case "--no-cycle":
 			opts.Cycle = false
+		case "--keep-right":
+			opts.KeepRight = true
+		case "--no-keep-right":
+			opts.KeepRight = false
 		case "--hscroll":
 			opts.Hscroll = true
 		case "--no-hscroll":
@@ -1081,10 +1202,15 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.FileWord = true
 		case "--no-filepath-word":
 			opts.FileWord = false
+		case "--info":
+			opts.InfoStyle = parseInfoStyle(
+				nextString(allArgs, &i, "info style required"))
+		case "--no-info":
+			opts.InfoStyle = infoHidden
 		case "--inline-info":
-			opts.InlineInfo = true
+			opts.InfoStyle = infoInline
 		case "--no-inline-info":
-			opts.InlineInfo = false
+			opts.InfoStyle = infoDefault
 		case "--jump-labels":
 			opts.JumpLabels = nextString(allArgs, &i, "label characters required")
 			validateJumpLabels = true
@@ -1102,14 +1228,22 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.ReadZero = false
 		case "--print0":
 			opts.Printer = func(str string) { fmt.Print(str, "\x00") }
+			opts.PrintSep = "\x00"
 		case "--no-print0":
 			opts.Printer = func(str string) { fmt.Println(str) }
+			opts.PrintSep = "\n"
 		case "--print-query":
 			opts.PrintQuery = true
 		case "--no-print-query":
 			opts.PrintQuery = false
 		case "--prompt":
 			opts.Prompt = nextString(allArgs, &i, "prompt string required")
+		case "--pointer":
+			opts.Pointer = nextString(allArgs, &i, "pointer sign string required")
+			validatePointer = true
+		case "--marker":
+			opts.Marker = nextString(allArgs, &i, "selected sign string required")
+			validateMarker = true
 		case "--sync":
 			opts.Sync = true
 		case "--no-sync":
@@ -1137,7 +1271,7 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Preview.command = ""
 		case "--preview-window":
 			parsePreviewWindow(&opts.Preview,
-				nextString(allArgs, &i, "preview window layout required: [up|down|left|right][:SIZE[%]][:wrap][:hidden]"))
+				nextString(allArgs, &i, "preview window layout required: [up|down|left|right][:SIZE[%]][:rounded|sharp|noborder][:wrap][:cycle][:hidden][:+SCROLL[-OFFSET]]"))
 		case "--height":
 			opts.Height = parseHeight(nextString(allArgs, &i, "height required: HEIGHT[%]"))
 		case "--min-height":
@@ -1147,9 +1281,14 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--no-margin":
 			opts.Margin = defaultMargin()
 		case "--no-border":
-			opts.Bordered = false
+			opts.BorderShape = tui.BorderNone
 		case "--border":
-			opts.Bordered = true
+			hasArg, arg := optionalNextString(allArgs, &i)
+			opts.BorderShape = parseBorder(arg, !hasArg)
+		case "--no-unicode":
+			opts.Unicode = false
+		case "--unicode":
+			opts.Unicode = true
 		case "--margin":
 			opts.Margin = parseMargin(
 				nextString(allArgs, &i, "margin required (TRBL / TB,RL / T,RL,B / T,R,B,L)"))
@@ -1170,20 +1309,32 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.Filter = &value
 			} else if match, value := optString(arg, "-d", "--delimiter="); match {
 				opts.Delimiter = delimiterRegexp(value)
+			} else if match, value := optString(arg, "--border="); match {
+				opts.BorderShape = parseBorder(value, false)
 			} else if match, value := optString(arg, "--prompt="); match {
 				opts.Prompt = value
+			} else if match, value := optString(arg, "--pointer="); match {
+				opts.Pointer = value
+				validatePointer = true
+			} else if match, value := optString(arg, "--marker="); match {
+				opts.Marker = value
+				validateMarker = true
 			} else if match, value := optString(arg, "-n", "--nth="); match {
 				opts.Nth = splitNth(value)
 			} else if match, value := optString(arg, "--with-nth="); match {
 				opts.WithNth = splitNth(value)
 			} else if match, _ := optString(arg, "-s", "--sort="); match {
 				opts.Sort = 1 // Don't care
+			} else if match, value := optString(arg, "-m", "--multi="); match {
+				opts.Multi = atoi(value)
 			} else if match, value := optString(arg, "--height="); match {
 				opts.Height = parseHeight(value)
 			} else if match, value := optString(arg, "--min-height="); match {
 				opts.MinHeight = atoi(value)
 			} else if match, value := optString(arg, "--layout="); match {
 				opts.Layout = parseLayout(value)
+			} else if match, value := optString(arg, "--info="); match {
+				opts.InfoStyle = parseInfoStyle(value)
 			} else if match, value := optString(arg, "--toggle-sort="); match {
 				parseToggleSort(opts.Keymap, value)
 			} else if match, value := optString(arg, "--expect="); match {
@@ -1216,6 +1367,7 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.HscrollOff = atoi(value)
 			} else if match, value := optString(arg, "--jump-labels="); match {
 				opts.JumpLabels = value
+				validateJumpLabels = true
 			} else {
 				errorExit("unknown option: " + arg)
 			}
@@ -1245,11 +1397,40 @@ func parseOptions(opts *Options, allArgs []string) {
 			}
 		}
 	}
+
+	if validatePointer {
+		if err := validateSign(opts.Pointer, "pointer"); err != nil {
+			errorExit(err.Error())
+		}
+	}
+
+	if validateMarker {
+		if err := validateSign(opts.Marker, "marker"); err != nil {
+			errorExit(err.Error())
+		}
+	}
+}
+
+func validateSign(sign string, signOptName string) error {
+	if sign == "" {
+		return fmt.Errorf("%v cannot be empty", signOptName)
+	}
+	widthSum := 0
+	for _, r := range sign {
+		if !unicode.IsGraphic(r) {
+			return fmt.Errorf("invalid character in %v", signOptName)
+		}
+		widthSum += runewidth.RuneWidth(r)
+		if widthSum > 2 {
+			return fmt.Errorf("%v display width should be up to 2", signOptName)
+		}
+	}
+	return nil
 }
 
 func postProcessOptions(opts *Options) {
-	if util.IsWindows() && opts.Height.size > 0 {
+	if !tui.IsLightRendererSupported() && opts.Height.size > 0 {
-		errorExit("--height option is currently not supported on Windows")
+		errorExit("--height option is currently not supported on this platform")
 	}
 	// Default actions for CTRL-N / CTRL-P when --history is set
 	if opts.History != nil {

src/options_test.go

@@ -243,9 +243,10 @@ func TestBind(t *testing.T) {
 	check(tui.CtrlA, "", actBeginningOfLine)
 	parseKeymap(keymap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-			"f1:execute(ls {})+abort,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"f1:execute(ls {+})+abort+execute(echo {+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
 			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
 			"x:Execute(foo+bar),X:execute/bar+baz/"+
+			",f1:+top,f1:+top"+
 			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
 	check(tui.CtrlA, "", actKillLine)
 	check(tui.CtrlB, "", actToggleSort, actUp, actDown)
@@ -253,7 +254,7 @@ func TestBind(t *testing.T) {
 	check(tui.AltZ+',', "", actAbort)
 	check(tui.AltZ+':', "", actAccept)
 	check(tui.AltZ, "", actPageDown)
-	check(tui.F1, "ls {}", actExecute, actAbort)
+	check(tui.F1, "ls {+}", actExecute, actAbort, actExecute, actSelectAll, actTop, actTop)
 	check(tui.F2, "echo {}, {}, {}", actExecute)
 	check(tui.F3, "echo '({})'", actExecute)
 	check(tui.F4, "less {}", actExecute)
@@ -392,17 +393,18 @@ func TestPreviewOpts(t *testing.T) {
 		opts.Preview.wrap == true &&
 		opts.Preview.position == posLeft &&
 		opts.Preview.size.percent == false &&
-		opts.Preview.size.size == 15+2+2) {
+		opts.Preview.size.size == 15) {
 		t.Error(opts.Preview)
 	}
-	opts = optsFor("--preview-window=up:15:wrap:hidden", "--preview-window=down")
+	opts = optsFor("--preview-window=up:15:wrap:hidden", "--preview-window=down", "--preview-window=cycle")
 	if !(opts.Preview.command == "" &&
-		opts.Preview.hidden == false &&
+		opts.Preview.hidden == true &&
-		opts.Preview.wrap == false &&
+		opts.Preview.wrap == true &&
+		opts.Preview.cycle == true &&
 		opts.Preview.position == posDown &&
-		opts.Preview.size.percent == true &&
+		opts.Preview.size.percent == false &&
-		opts.Preview.size.size == 50) {
+		opts.Preview.size.size == 15) {
-		t.Error(opts.Preview)
+		t.Error(opts.Preview.size.size)
 	}
 	opts = optsFor("--preview-window=up:15:wrap:hidden")
 	if !(opts.Preview.command == "" &&
@@ -410,7 +412,7 @@ func TestPreviewOpts(t *testing.T) {
 		opts.Preview.wrap == true &&
 		opts.Preview.position == posUp &&
 		opts.Preview.size.percent == false &&
-		opts.Preview.size.size == 15+2) {
+		opts.Preview.size.size == 15) {
 		t.Error(opts.Preview)
 	}
 }
@@ -421,3 +423,29 @@ func TestAdditiveExpect(t *testing.T) {
 		t.Error(opts.Expect)
 	}
 }
+
+func TestValidateSign(t *testing.T) {
+	testCases := []struct {
+		inputSign string
+		isValid   bool
+	}{
+		{"> ", true},
+		{"아", true},
+		{"😀", true},
+		{"", false},
+		{">>>", false},
+		{"\n", false},
+		{"\t", false},
+	}
+
+	for _, testCase := range testCases {
+		err := validateSign(testCase.inputSign, "")
+		if testCase.isValid && err != nil {
+			t.Errorf("Input sign `%s` caused error", testCase.inputSign)
+		}
+
+		if !testCase.isValid && err == nil {
+			t.Errorf("Input sign `%s` did not cause error", testCase.inputSign)
+		}
+	}
+}

src/pattern.go

@@ -33,6 +33,7 @@ type term struct {
 	inv           bool
 	text          []rune
 	caseSensitive bool
+	normalize     bool
 }
 
 // String returns the string representation of a term.
@@ -52,6 +53,7 @@ type Pattern struct {
 	forward       bool
 	text          []rune
 	termSets      []termSet
+	sortable      bool
 	cacheable     bool
 	cacheKey      string
 	delimiter     Delimiter
@@ -101,23 +103,34 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 	}
 
 	caseSensitive := true
+	sortable := true
 	termSets := []termSet{}
 
 	if extended {
 		termSets = parseTerms(fuzzy, caseMode, normalize, asString)
+		// We should not sort the result if there are only inverse search terms
+		sortable = false
 	Loop:
 		for _, termSet := range termSets {
 			for idx, term := range termSet {
+				if !term.inv {
+					sortable = true
+				}
 				// If the query contains inverse search terms or OR operators,
 				// we cannot cache the search scope
 				if !cacheable || idx > 0 || term.inv || fuzzy && term.typ != termFuzzy || !fuzzy && term.typ != termExact {
 					cacheable = false
+					if sortable {
+						// Can't break until we see at least one non-inverse term
 						break Loop
 					}
 				}
 			}
+		}
 	} else {
 		lowerString := strings.ToLower(asString)
+		normalize = normalize &&
+			lowerString == string(algo.NormalizeRunes([]rune(lowerString)))
 		caseSensitive = caseMode == CaseRespect ||
 			caseMode == CaseSmart && lowerString != asString
 		if !caseSensitive {
@@ -134,6 +147,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		forward:       forward,
 		text:          []rune(asString),
 		termSets:      termSets,
+		sortable:      sortable,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
@@ -162,6 +176,8 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
+		normalizeTerm := normalize &&
+			lowerText == string(algo.NormalizeRunes([]rune(lowerText)))
 		if !caseSensitive {
 			text = lowerText
 		}
@@ -211,14 +227,15 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				set = termSet{}
 			}
 			textRunes := []rune(text)
-			if normalize {
+			if normalizeTerm {
 				textRunes = algo.NormalizeRunes(textRunes)
 			}
 			set = append(set, term{
 				typ:           typ,
 				inv:           inv,
 				text:          textRunes,
-				caseSensitive: caseSensitive})
+				caseSensitive: caseSensitive,
+				normalize:     normalizeTerm})
 			switchSet = true
 		}
 	}
@@ -349,7 +366,7 @@ func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Of
 		matched := false
 		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-			off, score, pos := p.iter(pfun, input, term.caseSensitive, p.normalize, p.forward, term.text, withPos, slab)
+			off, score, pos := p.iter(pfun, input, term.caseSensitive, term.normalize, p.forward, term.text, withPos, slab)
 			if sidx := off[0]; sidx >= 0 {
 				if term.inv {
 					continue

src/pattern_test.go

@@ -98,6 +98,9 @@ func TestEqual(t *testing.T) {
 	}
 	match("ABC", -1, -1)
 	match("AbC", 0, 3)
+	match("AbC  ", 0, 3)
+	match(" AbC ", 1, 4)
+	match("  AbC", 2, 5)
 }
 
 func TestCaseSensitivity(t *testing.T) {

src/protector/protector.go

@@ -0,0 +1,8 @@
+// +build !openbsd
+
+package protector
+
+// Protect calls OS specific protections like pledge on OpenBSD
+func Protect() {
+	return
+}

src/protector/protector_openbsd.go

@@ -0,0 +1,10 @@
+// +build openbsd
+
+package protector
+
+import "golang.org/x/sys/unix"
+
+// Protect calls OS specific protections like pledge on OpenBSD
+func Protect() {
+	unix.PledgePromises("stdio rpath tty proc exec")
+}

src/reader.go

@@ -2,12 +2,17 @@ package fzf
 
 import (
 	"bufio"
+	"context"
 	"io"
 	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
 	"sync/atomic"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
+	"github.com/saracen/walker"
 )
 
 // Reader reads from command or standard input
@@ -16,11 +21,17 @@ type Reader struct {
 	eventBox *util.EventBox
 	delimNil bool
 	event    int32
+	finChan  chan bool
+	mutex    sync.Mutex
+	exec     *exec.Cmd
+	command  *string
+	killed   bool
+	wait     bool
 }
 
 // NewReader returns new Reader object
-func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool) *Reader {
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool, wait bool) *Reader {
-	return &Reader{pusher, eventBox, delimNil, int32(EvtReady)}
+	return &Reader{pusher, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, false, wait}
 }
 
 func (r *Reader) startEventPoller() {
@@ -29,9 +40,12 @@ func (r *Reader) startEventPoller() {
 		pollInterval := readerPollIntervalMin
 		for {
 			if atomic.CompareAndSwapInt32(ptr, int32(EvtReadNew), int32(EvtReady)) {
-				r.eventBox.Set(EvtReadNew, true)
+				r.eventBox.Set(EvtReadNew, (*string)(nil))
 				pollInterval = readerPollIntervalMin
 			} else if atomic.LoadInt32(ptr) == int32(EvtReadFin) {
+				if r.wait {
+					r.finChan <- true
+				}
 				return
 			} else {
 				pollInterval += readerPollIntervalStep
@@ -46,7 +60,37 @@ func (r *Reader) startEventPoller() {
 
 func (r *Reader) fin(success bool) {
 	atomic.StoreInt32(&r.event, int32(EvtReadFin))
-	r.eventBox.Set(EvtReadFin, success)
+	if r.wait {
+		<-r.finChan
+	}
+
+	r.mutex.Lock()
+	ret := r.command
+	if success || r.killed {
+		ret = nil
+	}
+	r.mutex.Unlock()
+
+	r.eventBox.Set(EvtReadFin, ret)
+}
+
+func (r *Reader) terminate() {
+	r.mutex.Lock()
+	defer func() { r.mutex.Unlock() }()
+
+	r.killed = true
+	if r.exec != nil && r.exec.Process != nil {
+		util.KillCommand(r.exec)
+	} else if defaultCommand != "" {
+		os.Stdin.Close()
+	}
+}
+
+func (r *Reader) restart(command string) {
+	r.event = int32(EvtReady)
+	r.startEventPoller()
+	success := r.readFromCommand(nil, command)
+	r.fin(success)
 }
 
 // ReadSource reads data from the default command or from standard input
@@ -54,12 +98,17 @@ func (r *Reader) ReadSource() {
 	r.startEventPoller()
 	var success bool
 	if util.IsTty() {
+		// The default command for *nix requires bash
+		shell := "bash"
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			// The default command for *nix requires bash
+			if defaultCommand != "" {
-			success = r.readFromCommand("bash", defaultCommand)
+				success = r.readFromCommand(&shell, defaultCommand)
 			} else {
-			success = r.readFromCommand("sh", cmd)
+				success = r.readFiles()
+			}
+		} else {
+			success = r.readFromCommand(nil, cmd)
 		}
 	} else {
 		success = r.readFromStdin()
@@ -102,16 +151,51 @@ func (r *Reader) readFromStdin() bool {
 	return true
 }
 
-func (r *Reader) readFromCommand(shell string, cmd string) bool {
+func (r *Reader) readFiles() bool {
-	listCommand := util.ExecCommandWith(shell, cmd)
+	r.killed = false
-	out, err := listCommand.StdoutPipe()
+	fn := func(path string, mode os.FileInfo) error {
+		path = filepath.Clean(path)
+		if path != "." {
+			isDir := mode.Mode().IsDir()
+			if isDir && filepath.Base(path)[0] == '.' {
+				return filepath.SkipDir
+			}
+			if !isDir && r.pusher([]byte(path)) {
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
+			}
+		}
+		r.mutex.Lock()
+		defer r.mutex.Unlock()
+		if r.killed {
+			return context.Canceled
+		}
+		return nil
+	}
+	cb := walker.WithErrorCallback(func(pathname string, err error) error {
+		return nil
+	})
+	return walker.Walk(".", fn, cb) == nil
+}
+
+func (r *Reader) readFromCommand(shell *string, command string) bool {
+	r.mutex.Lock()
+	r.killed = false
+	r.command = &command
+	if shell != nil {
+		r.exec = util.ExecCommandWith(*shell, command, true)
+	} else {
+		r.exec = util.ExecCommand(command, true)
+	}
+	out, err := r.exec.StdoutPipe()
 	if err != nil {
+		r.mutex.Unlock()
 		return false
 	}
-	err = listCommand.Start()
+	err = r.exec.Start()
+	r.mutex.Unlock()
 	if err != nil {
 		return false
 	}
 	r.feed(out)
-	return listCommand.Wait() == nil
+	return r.exec.Wait() == nil
 }

src/reader_test.go

@@ -10,10 +10,9 @@ import (
 func TestReadFromCommand(t *testing.T) {
 	strs := []string{}
 	eb := util.NewEventBox()
-	reader := Reader{
+	reader := NewReader(
-		pusher:   func(s []byte) bool { strs = append(strs, string(s)); return true },
+		func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eventBox: eb,
+		eb, false, true)
-		event:    int32(EvtReady)}
 
 	reader.startEventPoller()
 
@@ -23,7 +22,7 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Normal command
-	reader.fin(reader.readFromCommand("sh", `echo abc && echo def`))
+	reader.fin(reader.readFromCommand(nil, `echo abc && echo def`))
 	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
 		t.Errorf("%s", strs)
 	}
@@ -48,7 +47,7 @@ func TestReadFromCommand(t *testing.T) {
 	reader.startEventPoller()
 
 	// Failing command
-	reader.fin(reader.readFromCommand("sh", `no-such-command`))
+	reader.fin(reader.readFromCommand(nil, `no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)

src/result.go

@@ -16,7 +16,6 @@ type colorOffset struct {
 	offset [2]int32
 	color  tui.ColorPair
 	attr   tui.Attr
-	index  int32
 }
 
 type Result struct {

src/terminal_test.go

@@ -30,92 +30,92 @@ func TestReplacePlaceholder(t *testing.T) {
 			t.Errorf("expected: %s, actual: %s", expected, result)
 		}
 	}
-
+	printsep := "\n"
 	// {}, preserve ansi
-	result = replacePlaceholder("echo {}", false, Delimiter{}, false, "query", items1)
+	result = replacePlaceholder("echo {}", false, Delimiter{}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar \x1b[31mbaz\x1b[m'")
 
 	// {}, strip ansi
-	result = replacePlaceholder("echo {}", true, Delimiter{}, false, "query", items1)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar baz'")
 
 	// {}, with multiple items
-	result = replacePlaceholder("echo {}", true, Delimiter{}, false, "query", items2)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items2)
 	check("echo 'foo'\\''bar baz'")
 
 	// {..}, strip leading whitespaces, preserve ansi
-	result = replacePlaceholder("echo {..}", false, Delimiter{}, false, "query", items1)
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
 	check("echo 'foo'\\''bar \x1b[31mbaz\x1b[m'")
 
 	// {..}, strip leading whitespaces, strip ansi
-	result = replacePlaceholder("echo {..}", true, Delimiter{}, false, "query", items1)
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
 	check("echo 'foo'\\''bar baz'")
 
 	// {q}
-	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, false, "query", items1)
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar baz' 'query'")
 
 	// {q}, multiple items
-	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
 	check("echo 'foo'\\''bar baz' 'FOO'\\''BAR BAZ''query '\\''string'\\''''foo'\\''bar baz' 'FOO'\\''BAR BAZ'")
 
-	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, printsep, 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)
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, 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{}, false, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, 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)
+	result = replacePlaceholder("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, 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)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, 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}/'' ''")
 
 	// Whitespace preserving flag with "'" delimiter
-	result = replacePlaceholder("echo {s1}", true, Delimiter{str: &delim}, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	check("echo '  foo'")
 
-	result = replacePlaceholder("echo {s2}", true, Delimiter{str: &delim}, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	check("echo 'bar baz'")
 
-	result = replacePlaceholder("echo {s}", true, Delimiter{str: &delim}, false, "query", items1)
+	result = replacePlaceholder("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar baz'")
 
-	result = replacePlaceholder("echo {s..}", true, Delimiter{str: &delim}, false, "query", items1)
+	result = replacePlaceholder("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar baz'")
 
 	// Whitespace preserving flag with regex delimiter
-	regex = regexp.MustCompile("\\w+")
+	regex = regexp.MustCompile(`\w+`)
 
-	result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	check("echo '  '")
 
-	result = replacePlaceholder("echo {s2}", true, Delimiter{regex: regex}, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	check("echo ''\\'''")
 
-	result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, false, "query", items1)
+	result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	check("echo ' '")
 
 	// No match
-	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, false, "query", []*Item{nil, nil})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
 	check("echo /")
 
 	// No match, but with selections
-	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, false, "query", []*Item{nil, item1})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
 	check("echo /'  foo'\\''bar baz'")
 
 	// String delimiter
-	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, 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}, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	check("echo '  foo'\\''bar baz'/'f'/'r b'/''\\''bar b'")
 }
 

src/tokenizer.go

@@ -238,7 +238,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 			for _, part := range parts {
 				output.WriteString(part.ToString())
 			}
-			merged = util.ToChars([]byte(output.String()))
+			merged = util.ToChars(output.Bytes())
 		}
 
 		var prefixLength int32

src/tokenizer_test.go

@@ -73,7 +73,7 @@ func TestTransform(t *testing.T) {
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
-			if string(joinTokens(tx)) != "abc:  def:  ghi:  " {
+			if joinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", tx)
 			}
 		}
@@ -95,7 +95,7 @@ func TestTransform(t *testing.T) {
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if string(joinTokens(tx)) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
 				tx[0].text.ToString() != "  abc:  def:" || tx[0].prefixLength != 0 ||
 				tx[1].text.ToString() != "  ghi:" || tx[1].prefixLength != 12 ||

src/tui/dummy.go

@@ -27,7 +27,7 @@ const (
 
 func (r *FullscreenRenderer) Init()             {}
 func (r *FullscreenRenderer) Pause(bool)        {}
-func (r *FullscreenRenderer) Resume(bool) {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
 func (r *FullscreenRenderer) Clear()            {}
 func (r *FullscreenRenderer) Refresh()          {}
 func (r *FullscreenRenderer) Close()            {}
@@ -39,6 +39,6 @@ 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, borderStyle BorderStyle) Window {
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
 	return nil
 }

src/tui/light.go

@@ -3,11 +3,9 @@ package tui
 import (
 	"fmt"
 	"os"
-	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"
 	"unicode/utf8"
 
@@ -23,26 +21,13 @@ const (
 	defaultEscDelay = 100
 	escPollInterval = 5
 	offsetPollTries = 10
+	maxInputBuffer  = 10 * 1024
 )
 
 const consoleDevice string = "/dev/tty"
 
-var offsetRegexp *regexp.Regexp = regexp.MustCompile("\x1b\\[([0-9]+);([0-9]+)R")
+var offsetRegexp *regexp.Regexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
-
+var offsetRegexpBegin *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 {
-		tty := ttyname()
-		if len(tty) > 0 {
-			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
-				return in
-			}
-		}
-		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
-		os.Exit(2)
-	}
-	return in
-}
 
 func (r *LightRenderer) stderr(str string) {
 	r.stderrInternal(str, true)
@@ -100,11 +85,19 @@ type LightRenderer struct {
 	y             int
 	x             int
 	maxHeightFunc func(int) int
+
+	// Windows only
+	ttyinChannel    chan byte
+	inHandle        uintptr
+	outHandle       uintptr
+	origStateInput  uint32
+	origStateOutput uint32
 }
 
 type LightWindow struct {
 	renderer *LightRenderer
 	colored  bool
+	preview  bool
 	border   BorderStyle
 	top      int
 	left     int
@@ -132,38 +125,9 @@ func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop in
 	return &r
 }
 
-func (r *LightRenderer) fd() int {
+func repeat(r rune, times int) string {
-	return int(r.ttyin.Fd())
-}
-
-func (r *LightRenderer) defaultTheme() *ColorTheme {
-	if strings.Contains(os.Getenv("TERM"), "256") {
-		return Dark256
-	}
-	colors, err := exec.Command("tput", "colors").Output()
-	if err == nil && atoi(strings.TrimSpace(string(colors)), 16) > 16 {
-		return Dark256
-	}
-	return Default16
-}
-
-func (r *LightRenderer) findOffset() (row int, col int) {
-	r.csi("6n")
-	r.flush()
-	bytes := []byte{}
-	for tries := 0; tries < offsetPollTries; tries++ {
-		bytes = r.getBytesInternal(bytes, tries > 0)
-		offsets := offsetRegexp.FindSubmatch(bytes)
-		if len(offsets) > 2 {
-			return atoi(string(offsets[1]), 0) - 1, atoi(string(offsets[2]), 0) - 1
-		}
-	}
-	return -1, -1
-}
-
-func repeat(s string, times int) string {
 	if times > 0 {
-		return strings.Repeat(s, times)
+		return strings.Repeat(string(r), times)
 	}
 	return ""
 }
@@ -179,13 +143,9 @@ func atoi(s string, defaultValue int) int {
 func (r *LightRenderer) Init() {
 	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)
 
-	fd := r.fd()
+	if err := r.initPlatform(); err != nil {
-	origState, err := terminal.GetState(fd)
-	if err != nil {
 		errorExit(err.Error())
 	}
-	r.origState = origState
-	terminal.MakeRaw(fd)
 	r.updateTerminalSize()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
 
@@ -258,28 +218,6 @@ func getEnv(name string, defaultValue int) int {
 	return atoi(env, defaultValue)
 }
 
-func (r *LightRenderer) updateTerminalSize() {
-	width, height, err := terminal.GetSize(r.fd())
-	if err == nil {
-		r.width = width
-		r.height = r.maxHeightFunc(height)
-	} else {
-		r.width = getEnv("COLUMNS", defaultWidth)
-		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
-	}
-}
-
-func (r *LightRenderer) getch(nonblock bool) (int, bool) {
-	b := make([]byte, 1)
-	fd := r.fd()
-	util.SetNonblock(r.ttyin, nonblock)
-	_, err := util.Read(fd, b)
-	if err != nil {
-		return 0, false
-	}
-	return int(b[0]), true
-}
-
 func (r *LightRenderer) getBytes() []byte {
 	return r.getBytesInternal(r.buffer, false)
 }
@@ -297,6 +235,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 	}
 	buffer = append(buffer, byte(c))
 
+	pc := c
 	for {
 		c, ok = r.getch(true)
 		if !ok {
@@ -306,9 +245,20 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 				continue
 			}
 			break
-		}
+		} else if c == ESC && pc != c {
+			retries = r.escDelay / escPollInterval
+		} else {
 			retries = 0
+		}
 		buffer = append(buffer, byte(c))
+		pc = c
+
+		// This should never happen under normal conditions,
+		// so terminate fzf immediately.
+		if len(buffer) > maxInputBuffer {
+			r.Close()
+			panic(fmt.Sprintf("Input buffer overflow (%d): %v", len(buffer), buffer))
+		}
 	}
 
 	return buffer
@@ -338,6 +288,14 @@ func (r *LightRenderer) GetChar() Event {
 		return Event{BSpace, 0, nil}
 	case 0:
 		return Event{CtrlSpace, 0, nil}
+	case 28:
+		return Event{CtrlBackSlash, 0, nil}
+	case 29:
+		return Event{CtrlRightBracket, 0, nil}
+	case 30:
+		return Event{CtrlCaret, 0, nil}
+	case 31:
+		return Event{CtrlSlash, 0, nil}
 	case ESC:
 		ev := r.escSequence(&sz)
 		// Second chance
@@ -364,6 +322,13 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 	if len(r.buffer) < 2 {
 		return Event{ESC, 0, nil}
 	}
+
+	loc := offsetRegexpBegin.FindIndex(r.buffer)
+	if loc != nil && loc[0] == 0 {
+		*sz = loc[1]
+		return Event{Invalid, 0, nil}
+	}
+
 	*sz = 2
 	if r.buffer[1] >= 1 && r.buffer[1] <= 'z'-'a'+1 {
 		return Event{int(CtrlAltA + r.buffer[1] - 1), 0, nil}
@@ -374,112 +339,125 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 		alt = true
 	}
 	switch r.buffer[1] {
-	case 32:
+	case ESC:
+		return Event{ESC, 0, nil}
+	case ' ':
 		return Event{AltSpace, 0, nil}
-	case 47:
+	case '/':
 		return Event{AltSlash, 0, nil}
-	case 98:
+	case 'b':
 		return Event{AltB, 0, nil}
-	case 100:
+	case 'd':
 		return Event{AltD, 0, nil}
-	case 102:
+	case 'f':
 		return Event{AltF, 0, nil}
 	case 127:
 		return Event{AltBS, 0, nil}
-	case 91, 79:
+	case '[', 'O':
 		if len(r.buffer) < 3 {
 			return Event{Invalid, 0, nil}
 		}
 		*sz = 3
 		switch r.buffer[2] {
-		case 68:
+		case 'D':
 			if alt {
 				return Event{AltLeft, 0, nil}
 			}
 			return Event{Left, 0, nil}
-		case 67:
+		case 'C':
 			if alt {
 				// Ugh..
 				return Event{AltRight, 0, nil}
 			}
 			return Event{Right, 0, nil}
-		case 66:
+		case 'B':
 			if alt {
 				return Event{AltDown, 0, nil}
 			}
 			return Event{Down, 0, nil}
-		case 65:
+		case 'A':
 			if alt {
 				return Event{AltUp, 0, nil}
 			}
 			return Event{Up, 0, nil}
-		case 90:
+		case 'Z':
 			return Event{BTab, 0, nil}
-		case 72:
+		case 'H':
 			return Event{Home, 0, nil}
-		case 70:
+		case 'F':
 			return Event{End, 0, nil}
-		case 77:
+		case 'M':
 			return r.mouseSequence(sz)
-		case 80:
+		case 'P':
 			return Event{F1, 0, nil}
-		case 81:
+		case 'Q':
 			return Event{F2, 0, nil}
-		case 82:
+		case 'R':
 			return Event{F3, 0, nil}
-		case 83:
+		case 'S':
 			return Event{F4, 0, nil}
-		case 49, 50, 51, 52, 53, 54:
+		case '1', '2', '3', '4', '5', '6':
 			if len(r.buffer) < 4 {
 				return Event{Invalid, 0, nil}
 			}
 			*sz = 4
 			switch r.buffer[2] {
-			case 50:
+			case '2':
-				if len(r.buffer) == 5 && r.buffer[4] == 126 {
+				if r.buffer[3] == '~' {
+					return Event{Insert, 0, nil}
+				}
+				if len(r.buffer) > 4 && r.buffer[4] == '~' {
 					*sz = 5
 					switch r.buffer[3] {
-					case 48:
+					case '0':
 						return Event{F9, 0, nil}
-					case 49:
+					case '1':
 						return Event{F10, 0, nil}
-					case 51:
+					case '3':
 						return Event{F11, 0, nil}
-					case 52:
+					case '4':
 						return Event{F12, 0, nil}
 					}
 				}
 				// Bracketed paste mode: \e[200~ ... \e[201~
-				if r.buffer[3] == '0' && (r.buffer[4] == '0' || r.buffer[4] == '1') && r.buffer[5] == '~' {
+				if len(r.buffer) > 5 && r.buffer[3] == '0' && (r.buffer[4] == '0' || r.buffer[4] == '1') && r.buffer[5] == '~' {
 					// Immediately discard the sequence from the buffer and reread input
 					r.buffer = r.buffer[6:]
 					*sz = 0
 					return r.GetChar()
 				}
 				return Event{Invalid, 0, nil} // INS
-			case 51:
+			case '3':
 				return Event{Del, 0, nil}
-			case 52:
+			case '4':
 				return Event{End, 0, nil}
-			case 53:
+			case '5':
 				return Event{PgUp, 0, nil}
-			case 54:
+			case '6':
 				return Event{PgDn, 0, nil}
-			case 49:
+			case '1':
 				switch r.buffer[3] {
-				case 126:
+				case '~':
 					return Event{Home, 0, nil}
-				case 53, 55, 56, 57:
+				case '1', '2', '3', '4', '5', '7', '8', '9':
-					if len(r.buffer) == 5 && r.buffer[4] == 126 {
+					if len(r.buffer) == 5 && r.buffer[4] == '~' {
 						*sz = 5
 						switch r.buffer[3] {
-						case 53:
+						case '1':
+							return Event{F1, 0, nil}
+						case '2':
+							return Event{F2, 0, nil}
+						case '3':
+							return Event{F3, 0, nil}
+						case '4':
+							return Event{F4, 0, nil}
+						case '5':
 							return Event{F5, 0, nil}
-						case 55:
+						case '7':
 							return Event{F6, 0, nil}
-						case 56:
+						case '8':
 							return Event{F7, 0, nil}
-						case 57:
+						case '9':
 							return Event{F8, 0, nil}
 						}
 					}
@@ -509,6 +487,9 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 	if r.buffer[1] >= 'a' && r.buffer[1] <= 'z' {
 		return Event{AltA + int(r.buffer[1]) - 'a', 0, nil}
 	}
+	if r.buffer[1] >= '0' && r.buffer[1] <= '9' {
+		return Event{Alt0 + int(r.buffer[1]) - '0', 0, nil}
+	}
 	return Event{Invalid, 0, nil}
 }
 
@@ -538,7 +519,7 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {
 			r.prevDownTime = now
 		} else {
 			if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
-				time.Now().Sub(r.prevDownTime) < doubleClickDuration {
+				time.Since(r.prevDownTime) < doubleClickDuration {
 				double = true
 			}
 		}
@@ -564,7 +545,7 @@ func (r *LightRenderer) rmcup() {
 }
 
 func (r *LightRenderer) Pause(clear bool) {
-	terminal.Restore(r.fd(), r.origState)
+	r.restoreTerminal()
 	if clear {
 		if r.fullscreen {
 			r.rmcup()
@@ -576,8 +557,8 @@ func (r *LightRenderer) Pause(clear bool) {
 	}
 }
 
-func (r *LightRenderer) Resume(clear bool) {
+func (r *LightRenderer) Resume(clear bool, sigcont bool) {
-	terminal.MakeRaw(r.fd())
+	r.setupTerminal()
 	if clear {
 		if r.fullscreen {
 			r.smcup()
@@ -585,10 +566,10 @@ func (r *LightRenderer) Resume(clear bool) {
 			r.rmcup()
 		}
 		r.flush()
-	} else if !r.fullscreen && r.mouse {
+	} else if sigcont && !r.fullscreen && r.mouse {
-		// NOTE: Resume(false) is only called on SIGCONT after SIGSTOP.
+		// NOTE: SIGCONT (Coming back from CTRL-Z):
-		// And It's highly likely that the offset we obtained at the beginning will
+		// It's highly likely that the offset we obtained at the beginning is
-		// no longer be correct, so we simply disable mouse input.
+		// no longer correct, so we simply disable mouse input.
 		r.csi("?1000l")
 		r.mouse = false
 	}
@@ -631,7 +612,8 @@ func (r *LightRenderer) Close() {
 		r.csi("?1000l")
 	}
 	r.flush()
-	terminal.Restore(r.fd(), r.origState)
+	r.closePlatform()
+	r.restoreTerminal()
 }
 
 func (r *LightRenderer) MaxX() int {
@@ -646,10 +628,11 @@ func (r *LightRenderer) DoesAutoWrap() bool {
 	return false
 }
 
-func (r *LightRenderer) NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window {
+func (r *LightRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
 	w := &LightWindow{
 		renderer: r,
 		colored:  r.theme != nil,
+		preview:  preview,
 		border:   borderStyle,
 		top:      top,
 		left:     left,
@@ -659,16 +642,21 @@ func (r *LightRenderer) NewWindow(top int, left int, width int, height int, bord
 		fg:       colDefault,
 		bg:       colDefault}
 	if r.theme != nil {
+		if preview {
+			w.fg = r.theme.PreviewFg
+			w.bg = r.theme.PreviewBg
+		} else {
 			w.fg = r.theme.Fg
 			w.bg = r.theme.Bg
 		}
+	}
 	w.drawBorder()
 	return w
 }
 
 func (w *LightWindow) drawBorder() {
-	switch w.border {
+	switch w.border.shape {
-	case BorderAround:
+	case BorderRounded, BorderSharp:
 		w.drawBorderAround()
 	case BorderHorizontal:
 		w.drawBorderHorizontal()
@@ -677,32 +665,34 @@ func (w *LightWindow) drawBorder() {
 
 func (w *LightWindow) drawBorderHorizontal() {
 	w.Move(0, 0)
-	w.CPrint(ColBorder, AttrRegular, repeat("─", w.width))
+	w.CPrint(ColBorder, AttrRegular, repeat(w.border.horizontal, w.width))
 	w.Move(w.height-1, 0)
-	w.CPrint(ColBorder, AttrRegular, repeat("─", w.width))
+	w.CPrint(ColBorder, AttrRegular, repeat(w.border.horizontal, w.width))
 }
 
 func (w *LightWindow) drawBorderAround() {
 	w.Move(0, 0)
-	w.CPrint(ColBorder, AttrRegular, "┌"+repeat("─", w.width-2)+"┐")
+	color := ColBorder
+	if w.preview {
+		color = ColPreviewBorder
+	}
+	w.CPrint(color, AttrRegular,
+		string(w.border.topLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.topRight))
 	for y := 1; y < w.height-1; y++ {
 		w.Move(y, 0)
-		w.CPrint(ColBorder, AttrRegular, "│")
+		w.CPrint(color, AttrRegular, string(w.border.vertical))
-		w.cprint2(colDefault, w.bg, AttrRegular, repeat(" ", w.width-2))
+		w.CPrint(color, AttrRegular, repeat(' ', w.width-2))
-		w.CPrint(ColBorder, AttrRegular, "│")
+		w.CPrint(color, AttrRegular, string(w.border.vertical))
 	}
 	w.Move(w.height-1, 0)
-	w.CPrint(ColBorder, AttrRegular, "└"+repeat("─", w.width-2)+"┘")
+	w.CPrint(color, AttrRegular,
+		string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
 }
 
 func (w *LightWindow) csi(code string) {
 	w.renderer.csi(code)
 }
 
-func (w *LightWindow) stderr(str string) {
-	w.renderer.stderr(str)
-}
-
 func (w *LightWindow) stderrInternal(str string, allowNLCR bool) {
 	w.renderer.stderrInternal(str, allowNLCR)
 }
@@ -753,7 +743,7 @@ func (w *LightWindow) MoveAndClear(y int, x int) {
 	w.Move(y, x)
 	// We should not delete preview window on the right
 	// csi("K")
-	w.Print(repeat(" ", w.width-x))
+	w.Print(repeat(' ', w.width-x))
 	w.Move(y, x)
 }
 
@@ -849,7 +839,7 @@ func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLin
 		width += w
 		str := string(r)
 		if r == '\t' {
-			str = repeat(" ", w)
+			str = repeat(' ', w)
 		}
 		if prefixLength+width <= max {
 			line += str

src/tui/light_unix.go

@@ -0,0 +1,110 @@
+// +build !windows
+
+package tui
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+func IsLightRendererSupported() bool {
+	return true
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	if strings.Contains(os.Getenv("TERM"), "256") {
+		return Dark256
+	}
+	colors, err := exec.Command("tput", "colors").Output()
+	if err == nil && atoi(strings.TrimSpace(string(colors)), 16) > 16 {
+		return Dark256
+	}
+	return Default16
+}
+
+func (r *LightRenderer) fd() int {
+	return int(r.ttyin.Fd())
+}
+
+func (r *LightRenderer) initPlatform() error {
+	fd := r.fd()
+	origState, err := terminal.GetState(fd)
+	if err != nil {
+		return err
+	}
+	r.origState = origState
+	terminal.MakeRaw(fd)
+	return nil
+}
+
+func (r *LightRenderer) closePlatform() {
+	// NOOP
+}
+
+func openTtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
+			}
+		}
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
+	}
+	return in
+}
+
+func (r *LightRenderer) setupTerminal() {
+	terminal.MakeRaw(r.fd())
+}
+
+func (r *LightRenderer) restoreTerminal() {
+	terminal.Restore(r.fd(), r.origState)
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	width, height, err := terminal.GetSize(r.fd())
+
+	if err == nil {
+		r.width = width
+		r.height = r.maxHeightFunc(height)
+	} else {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+	}
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	r.csi("6n")
+	r.flush()
+	bytes := []byte{}
+	for tries := 0; tries < offsetPollTries; tries++ {
+		bytes = r.getBytesInternal(bytes, tries > 0)
+		offsets := offsetRegexp.FindSubmatch(bytes)
+		if len(offsets) > 3 {
+			// Add anything we skipped over to the input buffer
+			r.buffer = append(r.buffer, offsets[1]...)
+			return atoi(string(offsets[2]), 0) - 1, atoi(string(offsets[3]), 0) - 1
+		}
+	}
+	return -1, -1
+}
+
+func (r *LightRenderer) getch(nonblock bool) (int, bool) {
+	b := make([]byte, 1)
+	fd := r.fd()
+	util.SetNonblock(r.ttyin, nonblock)
+	_, err := util.Read(fd, b)
+	if err != nil {
+		return 0, false
+	}
+	return int(b[0]), true
+}

src/tui/light_windows.go

@@ -0,0 +1,140 @@
+//+build windows
+
+package tui
+
+import (
+	"os"
+	"syscall"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	consoleFlagsInput  = uint32(windows.ENABLE_VIRTUAL_TERMINAL_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_EXTENDED_FLAGS)
+	consoleFlagsOutput = uint32(windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING | windows.ENABLE_PROCESSED_OUTPUT | windows.DISABLE_NEWLINE_AUTO_RETURN)
+)
+
+// IsLightRendererSupported checks to see if the Light renderer is supported
+func IsLightRendererSupported() bool {
+	var oldState uint32
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if windows.GetConsoleMode(windows.Stderr, &oldState) != nil {
+		return false
+	}
+	// attempt to set mode to determine if we support VT 100 codes. This will work on newer Windows 10
+	// version:
+	canSetVt100 := windows.SetConsoleMode(windows.Stderr, oldState|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) == nil
+	var checkState uint32
+	if windows.GetConsoleMode(windows.Stderr, &checkState) != nil ||
+		(checkState&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) != windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING {
+		return false
+	}
+	windows.SetConsoleMode(windows.Stderr, oldState)
+	return canSetVt100
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	// the getenv check is borrowed from here: https://github.com/gdamore/tcell/commit/0c473b86d82f68226a142e96cc5a34c5a29b3690#diff-b008fcd5e6934bf31bc3d33bf49f47d8R178:
+	if !IsLightRendererSupported() || os.Getenv("ConEmuPID") != "" || os.Getenv("TCELL_TRUECOLOR") == "disable" {
+		return Default16
+	}
+	return Dark256
+}
+
+func (r *LightRenderer) initPlatform() error {
+	//outHandle := windows.Stdout
+	outHandle, _ := syscall.Open("CONOUT$", syscall.O_RDWR, 0)
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if err := windows.GetConsoleMode(windows.Handle(outHandle), &r.origStateOutput); err != nil {
+		return err
+	}
+	r.outHandle = uintptr(outHandle)
+	inHandle, _ := syscall.Open("CONIN$", syscall.O_RDWR, 0)
+	if err := windows.GetConsoleMode(windows.Handle(inHandle), &r.origStateInput); err != nil {
+		return err
+	}
+	r.inHandle = uintptr(inHandle)
+
+	r.setupTerminal()
+
+	// channel for non-blocking reads. Buffer to make sure
+	// we get the ESC sets:
+	r.ttyinChannel = make(chan byte, 12)
+
+	// the following allows for non-blocking IO.
+	// syscall.SetNonblock() is a NOOP under Windows.
+	go func() {
+		fd := int(r.inHandle)
+		b := make([]byte, 1)
+		for {
+			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
+			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+
+			_, err := util.Read(fd, b)
+			if err == nil {
+				r.ttyinChannel <- b[0]
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (r *LightRenderer) closePlatform() {
+	windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
+}
+
+func openTtyIn() *os.File {
+	// not used
+	return nil
+}
+
+func (r *LightRenderer) setupTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput); err != nil {
+		return err
+	}
+	return windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+}
+
+func (r *LightRenderer) restoreTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput); err != nil {
+		return err
+	}
+	return windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+
+	} else {
+		r.width = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
+		r.height = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+	}
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		return -1, -1
+	}
+	return int(bufferInfo.CursorPosition.X), int(bufferInfo.CursorPosition.Y)
+}
+
+func (r *LightRenderer) getch(nonblock bool) (int, bool) {
+	if nonblock {
+		select {
+		case bc := <-r.ttyinChannel:
+			return int(bc), true
+		default:
+			return 0, false
+		}
+	} else {
+		bc := <-r.ttyinChannel
+		return int(bc), true
+	}
+}

src/tui/tcell.go

@@ -28,10 +28,12 @@ type Attr tcell.Style
 
 type TcellWindow struct {
 	color       bool
+	preview     bool
 	top         int
 	left        int
 	width       int
 	height      int
+	normal      ColorPair
 	lastX       int
 	lastY       int
 	moveCursor  bool
@@ -61,12 +63,8 @@ func (w *TcellWindow) Refresh() {
 	}
 	w.lastX = 0
 	w.lastY = 0
-	switch w.borderStyle {
+
-	case BorderAround:
+	w.drawBorder()
-		w.drawBorder(true)
-	case BorderHorizontal:
-		w.drawBorder(false)
-	}
 }
 
 func (w *TcellWindow) FinishFill() {
@@ -288,6 +286,12 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{keyfn('z'), 0, nil}
 		case tcell.KeyCtrlSpace:
 			return Event{CtrlSpace, 0, nil}
+		case tcell.KeyCtrlBackslash:
+			return Event{CtrlBackSlash, 0, nil}
+		case tcell.KeyCtrlRightSq:
+			return Event{CtrlRightBracket, 0, nil}
+		case tcell.KeyCtrlUnderscore:
+			return Event{CtrlSlash, 0, nil}
 		case tcell.KeyBackspace2:
 			if alt {
 				return Event{AltBS, 0, nil}
@@ -315,6 +319,8 @@ func (r *FullscreenRenderer) GetChar() Event {
 			}
 			return Event{Right, 0, nil}
 
+		case tcell.KeyInsert:
+			return Event{Insert, 0, nil}
 		case tcell.KeyHome:
 			return Event{Home, 0, nil}
 		case tcell.KeyDelete:
@@ -382,12 +388,16 @@ func (r *FullscreenRenderer) GetChar() Event {
 	return Event{Invalid, 0, nil}
 }
 
-func (r *FullscreenRenderer) Pause(bool) {
+func (r *FullscreenRenderer) Pause(clear bool) {
+	if clear {
 		_screen.Fini()
+	}
 }
 
-func (r *FullscreenRenderer) Resume(bool) {
+func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {
+	if clear {
 		r.initScreen()
+	}
 }
 
 func (r *FullscreenRenderer) Close() {
@@ -402,14 +412,19 @@ func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
 	_screen.Show()
 }
 
-func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window {
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
-	// TODO
+	normal := ColNormal
+	if preview {
+		normal = ColPreview
+	}
 	return &TcellWindow{
 		color:       r.theme != nil,
+		preview:     preview,
 		top:         top,
 		left:        left,
 		width:       width,
 		height:      height,
+		normal:      normal,
 		borderStyle: borderStyle}
 }
 
@@ -417,16 +432,16 @@ func (w *TcellWindow) Close() {
 	// TODO
 }
 
-func fill(x, y, w, h int, r rune) {
+func fill(x, y, w, h int, n ColorPair, r rune) {
 	for ly := 0; ly <= h; ly++ {
 		for lx := 0; lx <= w; lx++ {
-			_screen.SetContent(x+lx, y+ly, r, nil, ColNormal.style())
+			_screen.SetContent(x+lx, y+ly, r, nil, n.style())
 		}
 	}
 }
 
 func (w *TcellWindow) Erase() {
-	fill(w.left-1, w.top, w.width+1, w.height, ' ')
+	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
 }
 
 func (w *TcellWindow) Enclose(y int, x int) bool {
@@ -443,13 +458,13 @@ func (w *TcellWindow) Move(y int, x int) {
 func (w *TcellWindow) MoveAndClear(y int, x int) {
 	w.Move(y, x)
 	for i := w.lastX; i < w.width; i++ {
-		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, ColNormal.style())
+		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, w.normal.style())
 	}
 	w.lastX = x
 }
 
 func (w *TcellWindow) Print(text string) {
-	w.printString(text, ColNormal, 0)
+	w.printString(text, w.normal, 0)
 }
 
 func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
@@ -462,7 +477,7 @@ func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
 			Underline(a&Attr(tcell.AttrUnderline) != 0)
 	} else {
-		style = ColNormal.style().
+		style = w.normal.style().
 			Reverse(a&Attr(tcell.AttrReverse) != 0 || pair == ColCurrent || pair == ColCurrentMatch).
 			Underline(a&Attr(tcell.AttrUnderline) != 0 || pair == ColMatch || pair == ColCurrentMatch)
 	}
@@ -513,7 +528,7 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 	if w.color {
 		style = pair.style()
 	} else {
-		style = ColNormal.style()
+		style = w.normal.style()
 	}
 	style = style.
 		Blink(a&Attr(tcell.AttrBlink) != 0).
@@ -553,20 +568,24 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 }
 
 func (w *TcellWindow) Fill(str string) FillReturn {
-	return w.fillString(str, ColNormal, 0)
+	return w.fillString(str, w.normal, 0)
 }
 
 func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	if fg == colDefault {
-		fg = ColNormal.Fg()
+		fg = w.normal.Fg()
 	}
 	if bg == colDefault {
-		bg = ColNormal.Bg()
+		bg = w.normal.Bg()
 	}
 	return w.fillString(str, NewColorPair(fg, bg), a)
 }
 
-func (w *TcellWindow) drawBorder(around bool) {
+func (w *TcellWindow) drawBorder() {
+	if w.borderStyle.shape == BorderNone {
+		return
+	}
+
 	left := w.left
 	right := left + w.width
 	top := w.top
@@ -574,25 +593,29 @@ func (w *TcellWindow) drawBorder(around bool) {
 
 	var style tcell.Style
 	if w.color {
-		style = ColBorder.style()
+		if w.preview {
+			style = ColPreviewBorder.style()
 		} else {
-		style = ColNormal.style()
+			style = ColBorder.style()
+		}
+	} else {
+		style = w.normal.style()
 	}
 
 	for x := left; x < right; x++ {
-		_screen.SetContent(x, top, tcell.RuneHLine, nil, style)
+		_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
-		_screen.SetContent(x, bot-1, tcell.RuneHLine, nil, style)
+		_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
 	}
 
-	if around {
+	if w.borderStyle.shape != BorderHorizontal {
 		for y := top; y < bot; y++ {
-			_screen.SetContent(left, y, tcell.RuneVLine, nil, style)
+			_screen.SetContent(left, y, w.borderStyle.vertical, nil, style)
-			_screen.SetContent(right-1, y, tcell.RuneVLine, nil, style)
+			_screen.SetContent(right-1, y, w.borderStyle.vertical, nil, style)
 		}
 
-		_screen.SetContent(left, top, tcell.RuneULCorner, nil, style)
+		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
-		_screen.SetContent(right-1, top, tcell.RuneURCorner, nil, style)
+		_screen.SetContent(right-1, top, w.borderStyle.topRight, nil, style)
-		_screen.SetContent(left, bot-1, tcell.RuneLLCorner, nil, style)
+		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
-		_screen.SetContent(right-1, bot-1, tcell.RuneLRCorner, nil, style)
+		_screen.SetContent(right-1, bot-1, w.borderStyle.bottomRight, nil, style)
 	}
 }

src/tui/tui.go

@@ -40,6 +40,12 @@ const (
 	ESC
 	CtrlSpace
 
+	// https://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal
+	CtrlBackSlash
+	CtrlRightBracket
+	CtrlCaret
+	CtrlSlash
+
 	Invalid
 	Resize
 	Mouse
@@ -60,6 +66,7 @@ const (
 	Right
 	Home
 	End
+	Insert
 
 	SUp
 	SDown
@@ -80,6 +87,7 @@ const (
 	F12
 
 	Change
+	BackwardEOF
 
 	AltSpace
 	AltSlash
@@ -117,7 +125,7 @@ func (c Color) is24() bool {
 
 const (
 	colUndefined Color = -2
-	colDefault         = -1
+	colDefault   Color = -1
 )
 
 const (
@@ -164,14 +172,13 @@ func (p ColorPair) Bg() Color {
 	return p.bg
 }
 
-func (p ColorPair) is24() bool {
-	return p.fg.is24() || p.bg.is24()
-}
-
 type ColorTheme struct {
 	Fg           Color
 	Bg           Color
+	PreviewFg    Color
+	PreviewBg    Color
 	DarkBg       Color
+	Gutter       Color
 	Prompt       Color
 	Match        Color
 	Current      Color
@@ -200,18 +207,76 @@ type MouseEvent struct {
 	Mod    bool
 }
 
-type BorderStyle int
+type BorderShape int
 
 const (
-	BorderNone BorderStyle = iota
+	BorderNone BorderShape = iota
-	BorderAround
+	BorderRounded
+	BorderSharp
 	BorderHorizontal
 )
 
+type BorderStyle struct {
+	shape       BorderShape
+	horizontal  rune
+	vertical    rune
+	topLeft     rune
+	topRight    rune
+	bottomLeft  rune
+	bottomRight rune
+}
+
+type BorderCharacter int
+
+func MakeBorderStyle(shape BorderShape, unicode bool) BorderStyle {
+	if unicode {
+		if shape == BorderRounded {
+			return BorderStyle{
+				shape:       shape,
+				horizontal:  '─',
+				vertical:    '│',
+				topLeft:     '╭',
+				topRight:    '╮',
+				bottomLeft:  '╰',
+				bottomRight: '╯',
+			}
+		}
+		return BorderStyle{
+			shape:       shape,
+			horizontal:  '─',
+			vertical:    '│',
+			topLeft:     '┌',
+			topRight:    '┐',
+			bottomLeft:  '└',
+			bottomRight: '┘',
+		}
+	}
+	return BorderStyle{
+		shape:       shape,
+		horizontal:  '-',
+		vertical:    '|',
+		topLeft:     '+',
+		topRight:    '+',
+		bottomLeft:  '+',
+		bottomRight: '+',
+	}
+}
+
+func MakeTransparentBorder() BorderStyle {
+	return BorderStyle{
+		shape:       BorderRounded,
+		horizontal:  ' ',
+		vertical:    ' ',
+		topLeft:     ' ',
+		topRight:    ' ',
+		bottomLeft:  ' ',
+		bottomRight: ' '}
+}
+
 type Renderer interface {
 	Init()
 	Pause(clear bool)
-	Resume(clear bool)
+	Resume(clear bool, sigcont bool)
 	Clear()
 	RefreshWindows(windows []Window)
 	Refresh()
@@ -223,7 +288,7 @@ type Renderer interface {
 	MaxY() int
 	DoesAutoWrap() bool
 
-	NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window
+	NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window
 }
 
 type Window interface {
@@ -272,24 +337,31 @@ var (
 	Dark256   *ColorTheme
 	Light256  *ColorTheme
 
-	ColNormal       ColorPair
 	ColPrompt          ColorPair
+	ColNormal          ColorPair
 	ColMatch           ColorPair
-	ColCurrent      ColorPair
-	ColCurrentMatch ColorPair
-	ColSpinner      ColorPair
-	ColInfo         ColorPair
 	ColCursor          ColorPair
 	ColSelected        ColorPair
+	ColCurrent         ColorPair
+	ColCurrentMatch    ColorPair
+	ColCurrentCursor   ColorPair
+	ColCurrentSelected ColorPair
+	ColSpinner         ColorPair
+	ColInfo            ColorPair
 	ColHeader          ColorPair
 	ColBorder          ColorPair
+	ColPreview         ColorPair
+	ColPreviewBorder   ColorPair
 )
 
 func EmptyTheme() *ColorTheme {
 	return &ColorTheme{
 		Fg:           colUndefined,
 		Bg:           colUndefined,
+		PreviewFg:    colUndefined,
+		PreviewBg:    colUndefined,
 		DarkBg:       colUndefined,
+		Gutter:       colUndefined,
 		Prompt:       colUndefined,
 		Match:        colUndefined,
 		Current:      colUndefined,
@@ -311,7 +383,10 @@ func init() {
 	Default16 = &ColorTheme{
 		Fg:           colDefault,
 		Bg:           colDefault,
+		PreviewFg:    colUndefined,
+		PreviewBg:    colUndefined,
 		DarkBg:       colBlack,
+		Gutter:       colUndefined,
 		Prompt:       colBlue,
 		Match:        colGreen,
 		Current:      colYellow,
@@ -325,7 +400,10 @@ func init() {
 	Dark256 = &ColorTheme{
 		Fg:           colDefault,
 		Bg:           colDefault,
+		PreviewFg:    colUndefined,
+		PreviewBg:    colUndefined,
 		DarkBg:       236,
+		Gutter:       colUndefined,
 		Prompt:       110,
 		Match:        108,
 		Current:      254,
@@ -339,7 +417,10 @@ func init() {
 	Light256 = &ColorTheme{
 		Fg:           colDefault,
 		Bg:           colDefault,
+		PreviewFg:    colUndefined,
+		PreviewBg:    colUndefined,
 		DarkBg:       251,
+		Gutter:       colUndefined,
 		Prompt:       25,
 		Match:        66,
 		Current:      237,
@@ -370,7 +451,10 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 	}
 	theme.Fg = o(baseTheme.Fg, theme.Fg)
 	theme.Bg = o(baseTheme.Bg, theme.Bg)
+	theme.PreviewFg = o(theme.Fg, o(baseTheme.PreviewFg, theme.PreviewFg))
+	theme.PreviewBg = o(theme.Bg, o(baseTheme.PreviewBg, theme.PreviewBg))
 	theme.DarkBg = o(baseTheme.DarkBg, theme.DarkBg)
+	theme.Gutter = o(theme.DarkBg, o(baseTheme.Gutter, theme.Gutter))
 	theme.Prompt = o(baseTheme.Prompt, theme.Prompt)
 	theme.Match = o(baseTheme.Match, theme.Match)
 	theme.Current = o(baseTheme.Current, theme.Current)
@@ -392,29 +476,37 @@ func initPalette(theme *ColorTheme) {
 		return ColorPair{fg, bg, idx}
 	}
 	if theme != nil {
-		ColNormal = pair(theme.Fg, theme.Bg)
 		ColPrompt = pair(theme.Prompt, theme.Bg)
+		ColNormal = pair(theme.Fg, theme.Bg)
 		ColMatch = pair(theme.Match, theme.Bg)
+		ColCursor = pair(theme.Cursor, theme.Gutter)
+		ColSelected = pair(theme.Selected, theme.Gutter)
 		ColCurrent = pair(theme.Current, theme.DarkBg)
 		ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
+		ColCurrentCursor = pair(theme.Cursor, theme.DarkBg)
+		ColCurrentSelected = pair(theme.Selected, theme.DarkBg)
 		ColSpinner = pair(theme.Spinner, theme.Bg)
 		ColInfo = pair(theme.Info, theme.Bg)
-		ColCursor = pair(theme.Cursor, theme.DarkBg)
-		ColSelected = pair(theme.Selected, theme.DarkBg)
 		ColHeader = pair(theme.Header, theme.Bg)
 		ColBorder = pair(theme.Border, theme.Bg)
+		ColPreview = pair(theme.PreviewFg, theme.PreviewBg)
+		ColPreviewBorder = pair(theme.Border, theme.PreviewBg)
 	} else {
-		ColNormal = pair(colDefault, colDefault)
 		ColPrompt = pair(colDefault, colDefault)
+		ColNormal = pair(colDefault, colDefault)
 		ColMatch = pair(colDefault, colDefault)
-		ColCurrent = pair(colDefault, colDefault)
-		ColCurrentMatch = pair(colDefault, colDefault)
-		ColSpinner = pair(colDefault, colDefault)
-		ColInfo = pair(colDefault, colDefault)
 		ColCursor = pair(colDefault, colDefault)
 		ColSelected = pair(colDefault, colDefault)
+		ColCurrent = pair(colDefault, colDefault)
+		ColCurrentMatch = pair(colDefault, colDefault)
+		ColCurrentCursor = pair(colDefault, colDefault)
+		ColCurrentSelected = pair(colDefault, colDefault)
+		ColSpinner = pair(colDefault, colDefault)
+		ColInfo = pair(colDefault, colDefault)
 		ColHeader = pair(colDefault, colDefault)
 		ColBorder = pair(colDefault, colDefault)
+		ColPreview = pair(colDefault, colDefault)
+		ColPreviewBorder = pair(colDefault, colDefault)
 	}
 }
 

src/update_assets.rb

@@ -1,19 +1,20 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # http://www.rubydoc.info/github/rest-client/rest-client/RestClient
 require 'rest_client'
 require 'json'
 
 if ARGV.length < 3
-  puts "usage: #$0 <token> <version> <files...>"
+  puts "usage: #{$PROGRAM_NAME} <token> <version> <files...>"
   exit 1
 end
 
 token, version, *files = ARGV
-base = "https://api.github.com/repos/junegunn/fzf-bin/releases"
+base = 'https://api.github.com/repos/junegunn/fzf-bin/releases'
 
 # List releases
-rels = JSON.parse(RestClient.get(base, :authorization => "token #{token}"))
+rels = JSON.parse(RestClient.get(base, authorization: "token #{token}"))
 rel = rels.find { |r| r['tag_name'] == version }
 unless rel
   puts "#{version} not found"
@@ -21,25 +22,26 @@ unless rel
 end
 
 # List assets
-assets = Hash[rel['assets'].map { |a| a.values_at *%w[name id] }]
+assets = Hash[rel['assets'].map { |a| a.values_at('name', 'id') }]
 
-files.select { |f| File.exists? f }.map do |file|
+files.select { |f| File.exist?(f) }.map do |file|
   Thread.new do
-    name = File.basename file
+    name = File.basename(file)
 
-    if asset_id = assets[name]
+    if asset_id = assets[name] # rubocop:todo Lint/AssignmentInCondition
       puts "#{name} found. Deleting asset id #{asset_id}."
-      RestClient.delete "#{base}/assets/#{asset_id}",
+      RestClient.delete("#{base}/assets/#{asset_id}",
-        :authorization => "token #{token}"
+                        authorization: "token #{token}")
     else
       puts "#{name} not found"
     end
 
     puts "Uploading #{name}"
     RestClient.post(
-      "#{base.sub 'api', 'uploads'}/#{rel['id']}/assets?name=#{name}",
+      "#{base.sub('api', 'uploads')}/#{rel['id']}/assets?name=#{name}",
       File.read(file),
-      :authorization => "token #{token}",
+      authorization: "token #{token}",
-      :content_type  => "application/octet-stream")
+      content_type: 'application/octet-stream'
+    )
   end
 end.each(&:join)

src/util/atomicbool.go

@@ -1,32 +1,34 @@
 package util
 
-import "sync"
+import (
+	"sync/atomic"
+)
+
+func convertBoolToInt32(b bool) int32 {
+	if b {
+		return 1
+	}
+	return 0
+}
 
 // AtomicBool is a boxed-class that provides synchronized access to the
 // underlying boolean value
 type AtomicBool struct {
-	mutex sync.Mutex
+	state int32 // "1" is true, "0" is false
-	state bool
 }
 
 // NewAtomicBool returns a new AtomicBool
 func NewAtomicBool(initialState bool) *AtomicBool {
-	return &AtomicBool{
+	return &AtomicBool{state: convertBoolToInt32(initialState)}
-		mutex: sync.Mutex{},
-		state: initialState}
 }
 
 // Get returns the current boolean value synchronously
 func (a *AtomicBool) Get() bool {
-	a.mutex.Lock()
+	return atomic.LoadInt32(&a.state) == 1
-	defer a.mutex.Unlock()
-	return a.state
 }
 
 // Set updates the boolean value synchronously
 func (a *AtomicBool) Set(newState bool) bool {
-	a.mutex.Lock()
+	atomic.StoreInt32(&a.state, convertBoolToInt32(newState))
-	defer a.mutex.Unlock()
+	return newState
-	a.state = newState
-	return a.state
 }

src/util/chars.go

@@ -130,6 +130,18 @@ func (chars *Chars) TrimLength() uint16 {
 	return chars.trimLength
 }
 
+func (chars *Chars) LeadingWhitespaces() int {
+	whitespaces := 0
+	for i := 0; i < chars.Length(); i++ {
+		char := chars.Get(i)
+		if !unicode.IsSpace(char) {
+			break
+		}
+		whitespaces++
+	}
+	return whitespaces
+}
+
 func (chars *Chars) TrailingWhitespaces() int {
 	whitespaces := 0
 	for i := chars.Length() - 1; i >= 0; i-- {
@@ -142,6 +154,11 @@ func (chars *Chars) TrailingWhitespaces() int {
 	return whitespaces
 }
 
+func (chars *Chars) TrimTrailingWhitespaces() {
+	whitespaces := chars.TrailingWhitespaces()
+	chars.slice = chars.slice[0 : len(chars.slice)-whitespaces]
+}
+
 func (chars *Chars) ToString() string {
 	if runes := chars.optionalRunes(); runes != nil {
 		return string(runes)
@@ -169,5 +186,13 @@ func (chars *Chars) CopyRunes(dest []rune) {
 	for idx, b := range chars.slice[:len(dest)] {
 		dest[idx] = rune(b)
 	}
-	return
+}
+
+func (chars *Chars) Prepend(prefix string) {
+	if runes := chars.optionalRunes(); runes != nil {
+		runes = append([]rune(prefix), runes...)
+		chars.slice = *(*[]byte)(unsafe.Pointer(&runes))
+	} else {
+		chars.slice = append([]byte(prefix), chars.slice...)
+	}
 }

src/util/util.go

@@ -112,3 +112,13 @@ func DurWithin(
 func IsTty() bool {
 	return isatty.IsTerminal(os.Stdin.Fd())
 }
+
+// Once returns a function that returns the specified boolean value only once
+func Once(nextResponse bool) func() bool {
+	state := nextResponse
+	return func() bool {
+		prevState := state
+		state = false
+		return prevState
+	}
+}

src/util/util_test.go

@@ -20,3 +20,21 @@ func TestContrain(t *testing.T) {
 		t.Error("Expected", 3)
 	}
 }
+
+func TestOnce(t *testing.T) {
+	o := Once(false)
+	if o() {
+		t.Error("Expected: false")
+	}
+	if o() {
+		t.Error("Expected: false")
+	}
+
+	o = Once(true)
+	if !o() {
+		t.Error("Expected: true")
+	}
+	if o() {
+		t.Error("Expected: false")
+	}
+}

src/util/util_unix.go

@@ -9,17 +9,26 @@ import (
 )
 
 // ExecCommand executes the given command with $SHELL
-func ExecCommand(command string) *exec.Cmd {
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
 	shell := os.Getenv("SHELL")
 	if len(shell) == 0 {
 		shell = "sh"
 	}
-	return ExecCommandWith(shell, command)
+	return ExecCommandWith(shell, command, setpgid)
 }
 
 // ExecCommandWith executes the given command with the specified shell
-func ExecCommandWith(shell string, command string) *exec.Cmd {
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
-	return exec.Command(shell, "-c", command)
+	cmd := exec.Command(shell, "-c", command)
+	if setpgid {
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	}
+	return cmd
+}
+
+// KillCommand kills the process for the given command
+func KillCommand(cmd *exec.Cmd) error {
+	return syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
 }
 
 // IsWindows returns true on Windows
@@ -27,7 +36,7 @@ func IsWindows() bool {
 	return false
 }
 
-// SetNonBlock executes syscall.SetNonblock on file descriptor
+// SetNonblock executes syscall.SetNonblock on file descriptor
 func SetNonblock(file *os.File, nonblock bool) {
 	syscall.SetNonblock(int(file.Fd()), nonblock)
 }

src/util/util_windows.go

@@ -10,13 +10,15 @@ import (
 )
 
 // ExecCommand executes the given command with cmd
-func ExecCommand(command string) *exec.Cmd {
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
-	return ExecCommandWith("cmd", command)
+	return ExecCommandWith("cmd", command, setpgid)
 }
 
 // ExecCommandWith executes the given command with cmd. _shell parameter is
 // ignored on Windows.
-func ExecCommandWith(_shell string, command string) *exec.Cmd {
+// FIXME: setpgid is unused. We set it in the Unix implementation so that we
+// can kill preview process with its child processes at once.
+func ExecCommandWith(_shell string, command string, setpgid bool) *exec.Cmd {
 	cmd := exec.Command("cmd")
 	cmd.SysProcAttr = &syscall.SysProcAttr{
 		HideWindow:    false,
@@ -26,12 +28,17 @@ func ExecCommandWith(_shell string, command string) *exec.Cmd {
 	return cmd
 }
 
+// KillCommand kills the process for the given command
+func KillCommand(cmd *exec.Cmd) error {
+	return cmd.Process.Kill()
+}
+
 // IsWindows returns true on Windows
 func IsWindows() bool {
 	return true
 }
 
-// SetNonBlock executes syscall.SetNonblock on file descriptor
+// SetNonblock executes syscall.SetNonblock on file descriptor
 func SetNonblock(file *os.File, nonblock bool) {
 	syscall.SetNonblock(syscall.Handle(file.Fd()), nonblock)
 }

test/fzf.vader

@@ -8,10 +8,13 @@ Execute (fzf#run with dir option):
   let cwd = getcwd()
   let result = fzf#run({ 'source': 'git ls-files', 'options': '--filter=vdr', 'dir': g:dir })
   AssertEqual ['fzf.vader'], result
+  AssertEqual 0, haslocaldir()
   AssertEqual getcwd(), cwd
 
+  execute 'lcd' fnameescape(cwd)
   let result = sort(fzf#run({ 'source': 'git ls-files', 'options': '--filter e', 'dir': g:dir }))
   AssertEqual ['fzf.vader', 'test_go.rb'], result
+  AssertEqual 1, haslocaldir()
   AssertEqual getcwd(), cwd
 
 Execute (fzf#run with Funcref command):
@@ -56,11 +59,11 @@ Execute (Incomplete fzf#run with dir option and autochdir):
   " No change in working directory even if &acd is set
   AssertEqual cwd, getcwd()
 
-Execute (fzf#run with dir option and autochdir):
+Execute (FIXME: fzf#run with dir option and autochdir):
   set acd
-  let cwd = getcwd()
   call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/tmp', 'options': '-1'})
   " Working directory changed due to &acd
+  AssertEqual '/foobar', expand('%')
   AssertEqual '/', getcwd()
 
 Execute (fzf#run with dir option and autochdir when final cwd is same as dir):