Fix ANSI offset calculation

It may take long for find command to spot the temporary file created on
the home directory

.travis.yml

@@ -12,17 +12,13 @@ install:
 - sudo apt-get install -y zsh fish
 
 script: |
-  export GOROOT=~/go1.4
   export GOPATH=~/go
-  export FZF_BASE=~/go/src/github.com/junegunn/fzf
+  export FZF_BASE=$GOPATH/src/github.com/junegunn/fzf
 
-  mkdir -p ~/go/src/github.com/junegunn
+  mkdir -p $GOPATH/src/github.com/junegunn
   ln -s $(pwd) $FZF_BASE
 
-  curl https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | tar -xz
-  mv go $GOROOT
-
   cd $FZF_BASE/src && make test fzf/fzf-linux_amd64 install &&
   cd $FZF_BASE/bin && ln -sf fzf-linux_amd64 fzf-$(./fzf --version)-linux_amd64 &&
-  cd $FZF_BASE && yes | ./install &&
+  cd $FZF_BASE && yes | ./install && rm -f fzf &&
   tmux new "ruby test/test_go.rb > out && touch ok" && cat out && [ -e ok ]

CHANGELOG.md

@@ -1,6 +1,61 @@
 CHANGELOG
 =========
 
+0.9.12
+------
+
+### New features
+
+- Added `--bind` option for custom key bindings
+
+### Bug fixes
+
+- Fixed to update "inline-info" immediately after terminal resize
+
+0.9.11
+------
+
+### New features
+
+- Added `--inline-info` option for saving screen estate (#202)
+     - Useful inside Neovim
+     - e.g. `let $FZF_DEFAULT_OPTS = $FZF_DEFAULT_OPTS.' --inline-info'`
+
+### Bug fixes
+
+- Invalid mutation of input on case conversion (#209)
+- Smart-case for each term in extended-search mode (#208)
+- Fixed double-click result when scroll offset is positive
+
+0.9.10
+------
+
+### Improvements
+
+- Performance optimization
+- Less aggressive memoization to limit memory usage
+
+### New features
+
+- Added color scheme for light background: `--color=light`
+
+0.9.9
+-----
+
+### New features
+
+- Added `--tiebreak` option (#191)
+- Added `--no-hscroll` option (#193)
+- Visual indication of `--toggle-sort` (#194)
+
+0.9.8
+-----
+
+### Bug fixes
+
+- Fixed Unicode case handling (#186)
+- Fixed to terminate on RuneError (#185)
+
 0.9.7
 -----
 

README.md

@@ -1,4 +1,4 @@
-<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![travis-ci](https://travis-ci.org/junegunn/fzf.svg?branch=master)](https://travis-ci.org/junegunn/fzf)
+<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![travis-ci](https://travis-ci.org/junegunn/fzf.svg?branch=master)](https://travis-ci.org/junegunn/fzf) <a href="http://flattr.com/thing/3115381/junegunnfzf-on-GitHub" target="_blank"><img src="http://api.flattr.com/button/flattr-badge-large.png" alt="Flattr this" title="Flattr this" border="0" /></a>
 ===
 
 fzf is a general-purpose command-line fuzzy finder.
@@ -8,7 +8,7 @@ fzf is a general-purpose command-line fuzzy finder.
 Pros
 ----
 
-- No dependency
+- No dependencies
 - Blazingly fast
     - e.g. `locate / | fzf`
 - Flexible layout
@@ -16,7 +16,7 @@ Pros
 - The most comprehensive feature set
     - Try `fzf --help` and be surprised
 - Batteries included
-    - Vim plugin, key bindings and fuzzy auto-completion
+    - Vim/Neovim plugin, key bindings and fuzzy auto-completion
 
 Installation
 ------------
@@ -27,7 +27,8 @@ fzf project consists of the followings:
 - `fzf-tmux` script for launching fzf in a tmux pane
 - Shell extensions
     - Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
-    - Fuzzy auto-completion (bash only)
+    - Fuzzy auto-completion (bash, zsh)
+- Vim/Neovim plugin
 
 You can [download fzf executable][bin] alone, but it's recommended that you
 install the extra stuff using the attached install script.
@@ -44,26 +45,15 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-#### Using curl
-
-In case you don't have git installed:
-
-```sh
-mkdir -p ~/.fzf
-curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
-    tar xz --strip-components 1 -C ~/.fzf
-~/.fzf/install
-```
-
 #### Using Homebrew
 
 On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
 
 ```sh
-brew install fzf
+brew reinstall --HEAD fzf
 
-# Install shell extensions - this should be done whenever fzf is updated
+# Install shell extensions
-$(brew info fzf | grep /install)
+/usr/local/Cellar/fzf/HEAD/install
 ```
 
 #### Install as Vim plugin
@@ -88,7 +78,7 @@ while. Please follow the instruction below depending on the installation
 method.
 
 - git: `cd ~/.fzf && git pull && ./install`
-- brew: `brew update && brew upgrade fzf && $(brew info fzf | grep /install)`
+- brew: `brew reinstall --HEAD fzf`
 - vim-plug: `:PlugUpdate fzf`
 
 Usage
@@ -152,21 +142,18 @@ fish.
 
 - `CTRL-T` - Paste the selected file path(s) into the command line
 - `CTRL-R` - Paste the selected command from history into the command line
-    - Sort is disabled by default. Press `CTRL-R` again to toggle sort.
+    - Sort is disabled by default to respect chronological ordering
+    - Press `CTRL-R` again to toggle sort
 - `ALT-C` - cd into the selected directory
 
-If you're on a tmux session, `CTRL-T` will launch fzf in a new split-window. You
+If you're on a tmux session, fzf will start in a split pane. You may disable
-may disable this tmux integration by setting `FZF_TMUX` to 0, or change the
+this tmux integration by setting `FZF_TMUX` to 0, or change the height of the
-height of the window with `FZF_TMUX_HEIGHT` (e.g. `20`, `50%`).
+pane with `FZF_TMUX_HEIGHT` (e.g. `20`, `50%`).
 
 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.
 
-If you want to customize the key bindings, consider editing the
-installer-generated source code: `~/.fzf.bash`, `~/.fzf.zsh`, and
-`~/.config/fish/functions/fzf_key_bindings.fish`.
-
 `fzf-tmux` script
 -----------------
 
@@ -186,8 +173,8 @@ 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]`
 options, so you can invariably use `fzf-tmux` in your scripts.
 
-Fuzzy completion for bash
+Fuzzy completion for bash and zsh
--------------------------
+---------------------------------
 
 #### Files and directories
 
@@ -274,35 +261,20 @@ If you have set up fzf for Vim, `:FZF` command will be added.
 
 " With options
 :FZF --no-sort -m /tmp
+
+" Bang version starts in fullscreen instead of using tmux pane or Neovim split
+:FZF!
 ```
 
 Similarly to [ctrlp.vim](https://github.com/kien/ctrlp.vim), use enter key,
 `CTRL-T`, `CTRL-X` or `CTRL-V` to open selected files in the current window,
 in new tabs, in horizontal splits, or in vertical splits respectively.
 
-Note that the environment variables `FZF_DEFAULT_COMMAND` and `FZF_DEFAULT_OPTS`
+Note that the environment variables `FZF_DEFAULT_COMMAND` and
-also apply here.
+`FZF_DEFAULT_OPTS` also apply here. Refer to [the wiki page][fzf-config] for
+customization.
 
-If you're on a tmux session, `:FZF` will launch fzf in a new split-window whose
+[fzf-config]: https://github.com/junegunn/fzf/wiki/Configuring-FZF-command-(vim)
-height can be adjusted with `g:fzf_tmux_height` (default: '40%'). However, the
-bang version (`:FZF!`) will always start in fullscreen.
-
-In 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](https://github.com/junegunn/fzf/wiki/On-MacVim-with-iTerm2) to see
-
-how to set up.
 
 #### `fzf#run([options])`
 
@@ -317,10 +289,16 @@ of the selected items.
 | `source`                   | list          | Vim list as input to fzf                                         |
 | `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)       |
 | `sink`                     | funcref       | Reference to function to process each selected item              |
+| `sink*`                    | funcref       | Similar to `sink`, but takes the list of output lines at once    |
 | `options`                  | string        | Options to fzf                                                   |
 | `dir`                      | string        | Working directory                                                |
 | `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
-| `launcher`                 | string        | External terminal emulator to start fzf with (Only used in GVim) |
+| `window` (*Neovim only*)   | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
+| `launcher`                 | string        | External terminal emulator to start fzf with (GVim only)         |
+| `launcher`                 | funcref       | Function for generating `launcher` string (GVim only)            |
+
+_However on Neovim `fzf#run` is asynchronous and does not return values so you
+should use `sink` or `sink*` to process the output from fzf._
 
 ##### Examples
 
@@ -358,32 +336,28 @@ handy mapping that selects an open buffer.
 
 ```vim
 " List of buffers
-function! BufList()
+function! s:buflist()
   redir => ls
   silent ls
   redir END
   return split(ls, '\n')
 endfunction
 
-function! BufOpen(e)
+function! s:bufopen(e)
-  execute 'buffer '. matchstr(a:e, '^[ 0-9]*')
+  execute 'buffer' matchstr(a:e, '^[ 0-9]*')
 endfunction
 
 nnoremap <silent> <Leader><Enter> :call fzf#run({
-\   'source':  reverse(BufList()),
+\   'source':  reverse(<sid>buflist()),
-\   'sink':    function('BufOpen'),
+\   'sink':    function('<sid>bufopen'),
 \   'options': '+m',
-\   'down':    '40%'
+\   'down':    len(<sid>buflist()) + 2
 \ })<CR>
 ```
 
 More examples can be found on [the wiki
 page](https://github.com/junegunn/fzf/wiki/Examples-(vim)).
 
-#### Articles
-
-- [fzf+vim+tmux](http://junegunn.kr/2014/04/fzf+vim+tmux)
-
 Tips
 ----
 
@@ -392,13 +366,13 @@ Tips
 If you have any rendering issues, check the followings:
 
 1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
-  contains `256` (e.g. `xterm-256color`)
+   contains `256` (e.g. `xterm-256color`)
 2. If you're on screen or tmux, `$TERM` should be either `screen` or
-  `screen-256color`
+   `screen-256color`
 3. Some terminal emulators (e.g. mintty) have problem displaying default
-  background color and make some text unable to read. In that case, try `--black`
+   background color and make some text unable to read. In that case, try
-  option. And if it solves your problem, I recommend including it in
+   `--black` option. And if it solves your problem, I recommend including it
-  `FZF_DEFAULT_OPTS` for further convenience.
+   in `FZF_DEFAULT_OPTS` for further convenience.
 4. If you still have problem, try `--no-256` option or even `--no-color`.
 
 #### Respecting `.gitignore`, `.hgignore`, and `svn:ignore`
@@ -429,41 +403,6 @@ export FZF_DEFAULT_COMMAND='
    find * -name ".*" -prune -o -type f -print -o -type l -print) 2> /dev/null'
 ```
 
-#### Using fzf with tmux panes
-
-The supplied [fzf-tmux](bin/fzf-tmux) script should suffice in most of the
-cases, but if you want to be able to update command line like the default
-`CTRL-T` key binding, you'll have to use `send-keys` command of tmux. The
-following example will show you how it can be done.
-
-```sh
-# This is a helper function that splits the current pane to start the given
-# command ($1) and sends its output back to the original pane with any number of
-# optional keys (shift; $*).
-fzf_tmux_helper() {
-  [ -n "$TMUX_PANE" ] || return
-  local cmd=$1
-  shift
-  tmux split-window -p 40 \
-    "bash -c \"\$(tmux send-keys -t $TMUX_PANE \"\$(source ~/.fzf.bash; $cmd)\" $*)\""
-}
-
-# This is the function we are going to run in the split pane.
-# - "find" to list the directories
-# - "sed" will escape spaces in the paths.
-# - "paste" will join the selected paths into a single line
-fzf_tmux_dir() {
-  fzf_tmux_helper \
-    'find * -path "*/\.*" -prune -o -type d -print 2> /dev/null |
-     fzf --multi |
-     sed "s/ /\\\\ /g" |
-     paste -sd" " -' Space
-}
-
-# Bind CTRL-X-CTRL-D to fzf_tmux_dir
-bind '"\C-x\C-d": "$(fzf_tmux_dir)\e\C-e"'
-```
-
 #### Fish shell
 
 It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
@@ -472,19 +411,7 @@ simple `vim (fzf)` won't work as expected. The workaround is to store the result
 of fzf to a temporary file.
 
 ```sh
-function vimf
+fzf > $TMPDIR/fzf.result; and vim (cat $TMPDIR/fzf.result)
-  if fzf > $TMPDIR/fzf.result
-    vim (cat $TMPDIR/fzf.result)
-  end
-end
-
-function fe
-  set tmp $TMPDIR/fzf.result
-  fzf --query="$argv[1]" --select-1 --exit-0 > $tmp
-  if [ (cat $tmp | wc -l) -gt 0 ]
-    vim (cat $tmp)
-  end
-end
 ```
 
 #### Handling UTF-8 NFD paths on OSX

bin/fzf-tmux

@@ -89,16 +89,14 @@ fi
 
 set -e
 
-# Build arguments to fzf
-[ ${#args[@]} -gt 0 ] && fzf_args=$(printf '\\"%s\\" ' "${args[@]}"; echo '')
-
 # Clean up named pipes on exit
 id=$RANDOM
+argsf=/tmp/fzf-args-$id
 fifo1=/tmp/fzf-fifo1-$id
 fifo2=/tmp/fzf-fifo2-$id
 fifo3=/tmp/fzf-fifo3-$id
 cleanup() {
-  rm -f $fifo1 $fifo2 $fifo3
+  rm -f $argsf $fifo1 $fifo2 $fifo3
 }
 trap cleanup EXIT SIGINT SIGTERM
 
@@ -106,20 +104,31 @@ fail() {
   >&2 echo "$1"
   exit 1
 }
-fzf=$(which fzf 2> /dev/null) || fail "fzf executable not found"
+fzf="$(which fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
-envs=""
+[ -x "$fzf" ] || fail "fzf executable not found"
+
+envs="env "
 [ -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")"
 
 mkfifo $fifo2
 mkfifo $fifo3
+
+# Build arguments to fzf
+opts=""
+for arg in "${args[@]}"; do
+  opts="$opts \"${arg//\"/\\\"}\""
+done
+
 if [ -n "$term" -o -t 0 ]; then
+  cat <<< "$fzf $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
   tmux set-window-option -q synchronize-panes off \;\
-    split-window $opt "cd $(printf %q "$PWD");$envs"' sh -c "'$fzf' '"$fzf_args"' > '$fifo2'; echo \$? > '$fifo3' '"$close"'"' $swap
+    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap
 else
   mkfifo $fifo1
+  cat <<< "$fzf $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
   tmux set-window-option -q synchronize-panes off \;\
-    split-window $opt "$envs"' sh -c "'$fzf' '"$fzf_args"' < '$fifo1' > '$fifo2'; echo \$? > '$fifo3' '"$close"'"' $swap
+    split-window $opt "$envs bash $argsf" $swap
   cat <&0 > $fifo1 &
 fi
 cat $fifo2

fzf

@@ -206,9 +206,11 @@ class FZF
         @expect = true
       when /^--expect=(.*)$/
         @expect = true
-      when '--toggle-sort'
+      when '--toggle-sort', '--tiebreak', '--color', '--bind'
         argv.shift
-      when '--tac', '--sync', '--toggle-sort', /^--toggle-sort=(.*)$/
+      when '--tac', '--no-tac', '--sync', '--no-sync', '--hscroll', '--no-hscroll',
+           '--inline-info', '--no-inline-info', /^--bind=(.*)$/,
+           /^--color=(.*)$/, /^--toggle-sort=(.*)$/, /^--tiebreak=(.*)$/
         # XXX
       else
         usage 1, "illegal option: #{o}"

install

@@ -1,12 +1,19 @@
 #!/usr/bin/env bash
 
-version=0.9.7
+version=0.9.12
 
 cd $(dirname $BASH_SOURCE)
 fzf_base=$(pwd)
 
+# If stdin is a tty, we are "interactive".
+[ -t 0 ] && interactive=yes
+
 ask() {
-  read -p "$1 ([y]/n) " -n 1 -r
+  # non-interactive shell: wait for a linefeed
+  #     interactive shell: continue after a single keypress
+  [ -n "$interactive" ] && read_n='-n 1' || read_n=
+
+  read -p "$1 ([y]/n) " $read_n -r
   echo
   [[ ! $REPLY =~ ^[Nn]$ ]]
 }
@@ -154,6 +161,8 @@ if [ -n "$binary_error" ]; then
   echo "OK"
 fi
 
+[[ "$*" =~ "--bin" ]] && exit 0
+
 # Auto-completion
 ask "Do you want to add auto-completion support?"
 auto_completion=$?
@@ -167,8 +176,8 @@ for shell in bash zsh; do
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
-  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/shell/completion.${shell}\""
+  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
-  if [ $shell != bash -o $auto_completion -ne 0 ]; then
+  if [ $auto_completion -ne 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
 

man/man1/fzf.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "March 2015" "fzf 0.9.6" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "May 2015" "fzf 0.9.12" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -66,6 +66,20 @@ Reverse the order of the input
 .RS
 e.g. \fBhistory | fzf --tac --no-sort\fR
 .RE
+.TP
+.BI "--tiebreak=" "CRI"
+Sort criterion to use when the scores are tied
+.br
+.R ""
+.br
+.BR length "  Prefers item with shorter length"
+.br
+.BR begin "   Prefers item with matched substring closer to the beginning"
+.br
+.BR end "     Prefers item with matched substring closer to the end"
+.br
+.BR index "   Prefers item that appeared earlier in the input stream"
+.br
 .SS Interface
 .TP
 .B "-m, --multi"
@@ -77,11 +91,21 @@ Enable processing of ANSI color codes
 .B "--no-mouse"
 Disable mouse
 .TP
-.B "+c, --no-color"
+.B "--color=COL"
-Disable colors
+Color scheme: [dark|light|16|bw]
-.TP
+.br
-.B "+2, --no-256"
+(default: dark on 256-color terminal, otherwise 16)
-Disable 256-color
+.br
+.R ""
+.br
+.BR dark "    Color scheme for dark 256-color terminal"
+.br
+.BR light "   Color scheme for light 256-color terminal"
+.br
+.BR 16 "      Color scheme for 16-color terminal"
+.br
+.BR bw "      No colors"
+.br
 .TP
 .B "--black"
 Use black background
@@ -89,8 +113,59 @@ Use black background
 .B "--reverse"
 Reverse orientation
 .TP
+.B "--no-hscroll"
+Disable horizontal scroll
+.TP
+.B "--inline-info"
+Display finder info inline with the query
+.TP
 .BI "--prompt=" "STR"
 Input prompt (default: '> ')
+.TP
+.BI "--toggle-sort=" "KEY"
+Key to toggle sort (\fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR,
+or any single character)
+.TP
+.BI "--bind=" "KEYBINDS"
+Comma-separated list of custom key bindings. Each key binding expression
+follows the following format: \fBKEY:ACTION\fR
+.RS
+e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
+.RE
+
+.RS
+.B KEY:
+    \fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR, or any single character
+.RE
+
+.RS
+.B ACTION:
+    abort
+    accept
+    backward-char
+    backward-delete-char
+    backward-kill-word
+    backward-word
+    beginning-of-line
+    clear-screen
+    delete-char
+    down
+    end-of-line
+    forward-char
+    forward-word
+    kill-line (not bound)
+    kill-word
+    page-down
+    page-up
+    toggle (not bound)
+    toggle-down
+    toggle-sort (not bound; equivalent to \fB--toggle-sort\fR)
+    toggle-up
+    unix-line-discard
+    unix-word-rubout
+    up
+    yank
+.RE
 .SS Scripting
 .TP
 .BI "-q, --query=" "STR"
@@ -120,10 +195,6 @@ with the default enter key.
 e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s,f1,f2,~,@\fR
 .RE
 .TP
-.BI "--toggle-sort=" "KEY"
-Key to toggle sort (\fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR,
-or any single character)
-.TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
 ncurses finder only after the input stream is complete.

plugin/fzf.vim

@@ -21,12 +21,11 @@
 " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-let s:default_tmux_height = '40%'
+let s:default_height = '40%'
-let s:launcher = 'xterm -e bash -ic %s'
 let s:fzf_go = expand('<sfile>:h:h').'/bin/fzf'
-let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
+let s:install = expand('<sfile>:h:h').'/install'
+let s:installed = 0
 let s:fzf_tmux = expand('<sfile>:h:h').'/bin/fzf-tmux'
-let s:legacy = 0
 
 let s:cpo_save = &cpo
 set cpo&vim
@@ -35,26 +34,24 @@ function! s: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:installed && executable(s:install) &&
+          \ input('fzf executable not found. Download binary? (y/n) ') =~? '^y'
+      redraw
+      echo
+      echohl WarningMsg
+      echo 'Downloading fzf binary. Please wait ...'
+      echohl None
+      let s:installed = 1
+      call system(s:install.' --bin')
+      return s:fzf_exec()
     else
-      let path = split(system('which fzf 2> /dev/null'), '\n')
+      redraw
-      if !v:shell_error && !empty(path)
+      throw 'fzf executable not found'
-        let s:exec = path[0]
-      elseif executable(s:fzf_rb)
-        let s:exec = s:fzf_rb
-        let s:legacy = 1
-      else
-        call system('type fzf')
-        if v:shell_error
-          throw 'fzf executable not found'
-        else
-          let s:exec = 'fzf'
-        endif
-      endif
     endif
-    return s:exec
-  else
-    return s:exec
   endif
+  return s:exec
 endfunction
 
 function! s:tmux_enabled()
@@ -79,7 +76,7 @@ function! s:shellesc(arg)
 endfunction
 
 function! s:escape(path)
-  return substitute(a:path, ' ', '\\ ', 'g')
+  return escape(a:path, ' %#\')
 endfunction
 
 " Upgrade legacy options
@@ -98,6 +95,15 @@ function! s:upgrade(dict)
 endfunction
 
 function! fzf#run(...) abort
+try
+  let oshell = &shell
+  set shell=sh
+  if has('nvim') && bufexists('[FZF]')
+    echohl WarningMsg
+    echomsg 'FZF is already running!'
+    echohl None
+    return []
+  endif
   let dict   = exists('a:1') ? s:upgrade(a:1) : {}
   let temps  = { 'result': tempname() }
   let optstr = get(dict, 'options', '')
@@ -122,14 +128,23 @@ function! fzf#run(...) abort
   else
     let prefix = ''
   endif
-  let split = s:tmux_enabled() && s:tmux_splittable(dict)
+  let tmux = !has('nvim') && s:tmux_enabled() && s:splittable(dict)
-  let command = prefix.(split ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
+  let command = prefix.(tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
-  if split
+  try
-    return s:execute_tmux(dict, command, temps)
+    if tmux
-  else
+      return s:execute_tmux(dict, command, temps)
-    return s:execute(dict, command, temps)
+    elseif has('nvim')
-  endif
+      return s:execute_term(dict, command, temps)
+    else
+      return s:execute(dict, command, temps)
+    endif
+  finally
+    call s:popd(dict)
+  endtry
+finally
+  let &shell = oshell
+endtry
 endfunction
 
 function! s:present(dict, ...)
@@ -146,20 +161,26 @@ function! s:fzf_tmux(dict)
   for o in ['up', 'down', 'left', 'right']
     if s:present(a:dict, o)
       let size = '-'.o[0].(a:dict[o] == 1 ? '' : a:dict[o])
+      break
     endif
   endfor
   return printf('LINES=%d COLUMNS=%d %s %s %s --',
     \ &lines, &columns, s:fzf_tmux, size, (has_key(a:dict, 'source') ? '' : '-'))
 endfunction
 
-function! s:tmux_splittable(dict)
+function! s:splittable(dict)
   return s:present(a:dict, 'up', 'down', 'left', 'right')
 endfunction
 
 function! s:pushd(dict)
   if s:present(a:dict, 'dir')
-    let a:dict.prev_dir = getcwd()
+    let cwd = getcwd()
+    if get(a:dict, 'prev_dir', '') ==# cwd
+      return 1
+    endif
+    let a:dict.prev_dir = cwd
     execute 'chdir '.s:escape(a:dict.dir)
+    let a:dict.dir = getcwd()
     return 1
   endif
   return 0
@@ -171,12 +192,25 @@ function! s:popd(dict)
   endif
 endfunction
 
+function! s:xterm_launcher()
+  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"),
+    \ &columns, &lines/2, getwinposx(), getwinposy())
+endfunction
+unlet! s:launcher
+let s:launcher = function('s:xterm_launcher')
+
 function! s:execute(dict, command, temps)
   call s:pushd(a:dict)
   silent! !clear 2> /dev/null
   if has('gui_running')
-    let launcher = get(a:dict, 'launcher', get(g:, 'fzf_launcher', s:launcher))
+    let Launcher = get(a:dict, 'launcher', get(g:, 'Fzf_launcher', get(g:, 'fzf_launcher', s:launcher)))
-    let command = printf(launcher, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
+    let fmt = type(Launcher) == 2 ? call(Launcher, []) : Launcher
+    let command = printf(fmt, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
   else
     let command = a:command
   endif
@@ -194,14 +228,6 @@ function! s:execute(dict, command, temps)
   endif
 endfunction
 
-function! s:env_var(name)
-  if exists('$'.a:name)
-    return a:name . "='". substitute(expand('$'.a:name), "'", "'\\\\''", 'g') . "' "
-  else
-    return ''
-  endif
-endfunction
-
 function! s:execute_tmux(dict, command, temps)
   let command = a:command
   if s:pushd(a:dict)
@@ -210,10 +236,82 @@ function! s:execute_tmux(dict, command, temps)
   endif
 
   call system(command)
+  redraw!
   return s:callback(a:dict, a:temps)
 endfunction
 
+function! s:calc_size(max, val)
+  if a:val =~ '%$'
+    return a:max * str2nr(a:val[:-2]) / 100
+  else
+    return min([a:max, a:val])
+  endif
+endfunction
+
+function! s:split(dict)
+  let directions = {
+  \ 'up':    ['topleft', 'resize', &lines],
+  \ 'down':  ['botright', 'resize', &lines],
+  \ 'left':  ['vertical topleft', 'vertical resize', &columns],
+  \ 'right': ['vertical botright', 'vertical resize', &columns] }
+  let s:ptab = tabpagenr()
+  try
+    for [dir, triple] in items(directions)
+      let val = get(a:dict, dir, '')
+      if !empty(val)
+        let [cmd, resz, max] = triple
+        let sz = s:calc_size(max, val)
+        execute cmd sz.'new'
+        execute resz sz
+        return
+      endif
+    endfor
+    if s:present(a:dict, 'window')
+      execute a:dict.window
+    else
+      tabnew
+    endif
+  finally
+    setlocal winfixwidth winfixheight buftype=nofile bufhidden=wipe nobuflisted
+  endtry
+endfunction
+
+function! s:execute_term(dict, command, temps)
+  call s:split(a:dict)
+  call s:pushd(a:dict)
+
+  let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps }
+  function! fzf.on_exit(id, code)
+    let tab = tabpagenr()
+    if bufnr('') == self.buf
+      " We use close instead of bd! since Vim does not close the split when
+      " there's no other listed buffer
+      close
+      " FIXME This should be unnecessary due to `bufhidden=wipe` but in some
+      " cases Neovim fails to clean up the buffer and `bufexists('[FZF]')
+      " returns 1 even when it cannot be seen anywhere else. e.g. `FZF!`
+      silent! execute 'bd!' self.buf
+    endif
+    if s:ptab == tab
+      wincmd p
+    endif
+    call s:pushd(self.dict)
+    try
+      redraw!
+      call s:callback(self.dict, self.temps)
+    finally
+      call s:popd(self.dict)
+    endtry
+  endfunction
+
+  call termopen(a:command, fzf)
+  silent file [FZF]
+  startinsert
+  return []
+endfunction
+
 function! s:callback(dict, temps)
+try
   if !filereadable(a:temps.result)
     let lines = []
   else
@@ -227,55 +325,54 @@ function! s:callback(dict, temps)
         endif
       endfor
     endif
+    if has_key(a:dict, 'sink*')
+      call a:dict['sink*'](lines)
+    endif
   endif
 
   for tf in values(a:temps)
     silent! call delete(tf)
   endfor
 
-  call s:popd(a:dict)
-
   return lines
+catch
+  if stridx(v:exception, ':E325:') < 0
+    echoerr v:exception
+  endif
+endtry
+endfunction
+
+let s:default_action = {
+  \ 'ctrl-m': 'e',
+  \ 'ctrl-t': 'tabedit',
+  \ 'ctrl-x': 'split',
+  \ 'ctrl-v': 'vsplit' }
+
+function! s:cmd_callback(lines) abort
+  if empty(a:lines)
+    return
+  endif
+  let key = remove(a:lines, 0)
+  let cmd = get(s:action, key, 'e')
+  for item in a:lines
+    execute cmd s:escape(item)
+  endfor
 endfunction
 
 function! s:cmd(bang, ...) abort
-  let args = copy(a:000)
+  let s:action = get(g:, 'fzf_action', s:default_action)
-  if !s:legacy
+  let args = extend(['--expect='.join(keys(s:action), ',')], a:000)
-    let args = insert(args, '--expect=ctrl-t,ctrl-x,ctrl-v', 0)
-  endif
   let opts = {}
   if len(args) > 0 && isdirectory(expand(args[-1]))
     let opts.dir = remove(args, -1)
   endif
   if !a:bang
-    let opts.down = get(g:, 'fzf_tmux_height', s:default_tmux_height)
+    let opts.down = get(g:, 'fzf_height', get(g:, 'fzf_tmux_height', s:default_height))
-  endif
-
-  if s:legacy
-    call fzf#run(extend({ 'sink': 'e', 'options': join(args) }, opts))
-  else
-    let output = fzf#run(extend({ 'options': join(args) }, opts))
-    if empty(output)
-      return
-    endif
-    let key = remove(output, 0)
-    if     key == 'ctrl-t' | let cmd = 'tabedit'
-    elseif key == 'ctrl-x' | let cmd = 'split'
-    elseif key == 'ctrl-v' | let cmd = 'vsplit'
-    else                   | let cmd = 'e'
-    endif
-    try
-      call s:pushd(opts)
-      for item in output
-        execute cmd s:escape(item)
-      endfor
-    finally
-      call s:popd(opts)
-    endtry
   endif
+  call fzf#run(extend({'options': join(args), 'sink*': function('<sid>cmd_callback')}, opts))
 endfunction
 
-command! -nargs=* -complete=dir -bang FZF call s:cmd('<bang>' == '!', <f-args>)
+command! -nargs=* -complete=dir -bang FZF call s:cmd(<bang>0, <f-args>)
 
 let &cpo = s:cpo_save
 unlet s:cpo_save

shell/completion.bash

@@ -5,6 +5,8 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/-completion.bash
 #
+# - $FZF_TMUX               (default: 1)
+# - $FZF_TMUX_HEIGHT        (default: '40%')
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
@@ -14,9 +16,10 @@ _fzf_orig_completion_filter() {
 }
 
 _fzf_opts_completion() {
-  local cur opts
+  local cur prev opts
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
+  prev="${COMP_WORDS[COMP_CWORD-1]}"
   opts="
     -x --extended
     -e --extended-exact
@@ -25,20 +28,36 @@ _fzf_opts_completion() {
     -d --delimiter
     +s --no-sort
     --tac
+    --tiebreak
+    --bind
     -m --multi
     --no-mouse
-    +c --no-color
+    --color
-    +2 --no-256
     --black
     --reverse
+    --no-hscroll
+    --inline-info
     --prompt
     -q --query
     -1 --select-1
     -0 --exit-0
     -f --filter
     --print-query
+    --expect
+    --toggle-sort
     --sync"
 
+  case "${prev}" in
+  --tiebreak)
+    COMPREPLY=( $(compgen -W "length begin end index" -- ${cur}) )
+    return 0
+    ;;
+  --color)
+    COMPREPLY=( $(compgen -W "dark light 16 bw" -- ${cur}) )
+    return 0
+    ;;
+  esac
+
   if [[ ${cur} =~ ^-|\+ ]]; then
     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
     return 0
@@ -65,10 +84,11 @@ _fzf_handle_dynamic_completion() {
 }
 
 _fzf_path_completion() {
-  local cur base dir leftover matches trigger cmd
+  local cur base dir leftover matches trigger cmd fzf
+  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
   cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
+  trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ ${cur} == *"$trigger" ]]; then
     base=${cur:0:${#cur}-${#trigger}}
@@ -81,7 +101,7 @@ _fzf_path_completion() {
         leftover=${leftover/#\/}
         [ "$dir" = './' ] && dir=''
         tput sc
-        matches=$(find -L "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+        matches=$(find -L "$dir"* $1 2> /dev/null | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
           printf "%q$3 " "$item"
         done)
         matches=${matches% }
@@ -105,16 +125,17 @@ _fzf_path_completion() {
 }
 
 _fzf_list_completion() {
-  local cur selected trigger cmd src
+  local cur selected trigger cmd src fzf
+  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
   read -r src
   cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
+  trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ ${cur} == *"$trigger" ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
     tput sc
-    selected=$(eval "$src | fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
+    selected=$(eval "$src | $fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
     selected=${selected% }
     tput rc
 
@@ -149,9 +170,10 @@ _fzf_dir_completion() {
 _fzf_kill_completion() {
   [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
 
-  local selected
+  local selected fzf
+  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
   tput sc
-  selected=$(ps -ef | sed 1d | fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
+  selected=$(ps -ef | sed 1d | $fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
   tput rc
 
   if [ -n "$selected" ]; then
@@ -162,13 +184,13 @@ _fzf_kill_completion() {
 
 _fzf_telnet_completion() {
   _fzf_list_completion '+m' "$@" << "EOF"
-  \grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{if (length($2) > 0) {print $2}}' | sort -u
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
 EOF
 }
 
 _fzf_ssh_completion() {
   _fzf_list_completion '+m' "$@" << "EOF"
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i ^host | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts) | awk '{print $2}' | sort -u
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
 EOF
 }
 
@@ -201,11 +223,11 @@ a_cmds="
 x_cmds="kill ssh telnet unset unalias export"
 
 # Preserve existing completion
-if [ "$_fzf_completion_loaded" != '0.8.6-1' ]; then
+if [ "$_fzf_completion_loaded" != '0.9.12' ]; then
   # Really wish I could use associative array but OSX comes with bash 3.2 :(
   eval $(complete | \grep '\-F' | \grep -v _fzf_ |
     \grep -E " ($(echo $d_cmds $f_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
-  export _fzf_completion_loaded=0.8.6-1
+  export _fzf_completion_loaded=0.9.12
 fi
 
 if type _completion_loader > /dev/null 2>&1; then

shell/completion.zsh

@@ -0,0 +1,158 @@
+#!/bin/zsh
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/-completion.zsh
+#
+# - $FZF_TMUX               (default: 1)
+# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_COMPLETION_TRIGGER (default: '**')
+# - $FZF_COMPLETION_OPTS    (default: empty)
+
+_fzf_path_completion() {
+  local base lbuf find_opts fzf_opts suffix tail fzf dir leftover matches nnm
+  base=${(Q)1}
+  lbuf=$2
+  find_opts=$3
+  fzf_opts=$4
+  suffix=$5
+  tail=$6
+  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+
+  if ! setopt | grep nonomatch > /dev/null; then
+    nnm=1
+    setopt nonomatch
+  fi
+  dir="$base"
+  while [ 1 ]; do
+    if [ -z "$dir" -o -d ${~dir} ]; then
+      leftover=${base/#"$dir"}
+      leftover=${leftover/#\/}
+      [ "$dir" = './' ] && dir=''
+      dir=${~dir}
+      matches=$(\find -L $dir* ${=find_opts} 2> /dev/null | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
+        printf "%q$suffix " "$item"
+      done)
+      matches=${matches% }
+      if [ -n "$matches" ]; then
+        LBUFFER="$lbuf$matches$tail"
+      fi
+      zle redisplay
+      break
+    fi
+    dir=$(dirname "$dir")
+    dir=${dir%/}/
+  done
+  [ -n "$nnm" ] && unsetopt nonomatch
+}
+
+_fzf_all_completion() {
+  _fzf_path_completion "$1" "$2" \
+    "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
+    "-m" "" " "
+}
+
+_fzf_dir_completion() {
+  _fzf_path_completion "$1" "$2" \
+    "-name .git -prune -o -name .svn -prune -o -type d -print" \
+    "" "/" ""
+}
+
+_fzf_list_completion() {
+  local prefix lbuf fzf_opts src fzf matches
+  prefix=$1
+  lbuf=$2
+  fzf_opts=$3
+  read -r src
+  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+
+  matches=$(eval "$src" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$prefix")
+  if [ -n "$matches" ]; then
+    LBUFFER="$lbuf$matches "
+  fi
+  zle redisplay
+}
+
+_fzf_telnet_completion() {
+  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
+EOF
+}
+
+_fzf_ssh_completion() {
+  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
+EOF
+}
+
+_fzf_env_var_completion() {
+  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  declare -xp | sed 's/=.*//' | sed 's/.* //'
+EOF
+}
+
+_fzf_alias_completion() {
+  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  alias | sed 's/=.*//'
+EOF
+}
+
+fzf-completion() {
+  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds
+
+  # http://zsh.sourceforge.net/FAQ/zshfaq03.html
+  # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
+  tokens=(${(z)LBUFFER})
+  if [ ${#tokens} -lt 1 ]; then
+    eval "zle ${fzf_default_completion:-expand-or-complete}"
+    return
+  fi
+
+  cmd=${tokens[1]}
+
+  # Explicitly allow for empty trigger.
+  trigger=${FZF_COMPLETION_TRIGGER-'**'}
+  [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
+
+  tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
+  # Kill completion (do not require trigger sequence)
+  if [ $cmd = kill -a ${LBUFFER[-1]} = ' ' ]; then
+    [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+    matches=$(ps -ef | sed 1d | ${=fzf} ${=FZF_COMPLETION_OPTS} -m | awk '{print $2}' | tr '\n' ' ')
+    if [ -n "$matches" ]; then
+      LBUFFER="$LBUFFER$matches"
+    fi
+    zle redisplay
+  # Trigger sequence given
+  elif [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
+    d_cmds=(cd pushd rmdir)
+
+    [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
+    [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}
+
+    if [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
+      _fzf_dir_completion "$prefix" $lbuf
+    elif [ $cmd = telnet ]; then
+      _fzf_telnet_completion "$prefix" $lbuf
+    elif [ $cmd = ssh ]; then
+      _fzf_ssh_completion "$prefix" $lbuf
+    elif [ $cmd = unset -o $cmd = export ]; then
+      _fzf_env_var_completion "$prefix" $lbuf
+    elif [ $cmd = unalias ]; then
+      _fzf_alias_completion "$prefix" $lbuf
+    else
+      _fzf_all_completion "$prefix" $lbuf
+    fi
+  # Fall back to default completion
+  else
+    eval "zle ${fzf_default_completion:-expand-or-complete}"
+  fi
+}
+
+[ -z "$fzf_default_completion" ] &&
+  fzf_default_completion=$(bindkey '^I' | grep -v undefined-key | awk '{print $2}')
+
+zle     -N   fzf-completion
+bindkey '^I' fzf-completion
+

shell/key-bindings.bash

@@ -1,6 +1,6 @@
 # Key bindings
 # ------------
-__fsel() {
+__fzf_select__() {
   command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
     -o -type f -print \
     -o -type d -print \
@@ -12,7 +12,11 @@ __fsel() {
 
 if [[ $- =~ i ]]; then
 
-__fsel_tmux() {
+__fzfcmd() {
+  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+}
+
+__fzf_select_tmux__() {
   local height
   height=${FZF_TMUX_HEIGHT:-40%}
   if [[ $height =~ %$ ]]; then
@@ -20,13 +24,21 @@ __fsel_tmux() {
   else
     height="-l $height"
   fi
-  tmux split-window $height "cd $(printf %q "$PWD");bash -c 'source ~/.fzf.bash; tmux send-keys -t $TMUX_PANE \"\$(__fsel)\"'"
+  tmux split-window $height "cd $(printf %q "$PWD");bash -c 'source ~/.fzf.bash; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
 }
 
-__fcd() {
+__fzf_cd__() {
   local dir
   dir=$(command find -L ${1:-.} \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m) && printf 'cd %q' "$dir"
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m) && printf 'cd %q' "$dir"
+}
+
+__fzf_history__() {
+  local line
+  line=$(
+    HISTTIMEFORMAT= history |
+    $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r |
+    \grep '^ *[0-9]') && sed 's/ *\([0-9]*\)\** .*/!\1/' <<< "$line"
 }
 
 __use_tmux=0
@@ -35,38 +47,40 @@ __use_tmux=0
 if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   # Required to refresh the prompt after fzf
   bind '"\er": redraw-current-line'
+  bind '"\e^": history-expand-line'
 
   # CTRL-T - Paste the selected file path into the command line
   if [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": " \C-u \C-a\C-k$(__fsel_tmux)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
+    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$(__fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
+    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$(HISTTIMEFORMAT= history | fzf +s --tac +m -n2..,.. --toggle-sort=ctrl-r | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
+  bind '"\C-r": " \C-e\C-u$(__fzf_history__)\e\C-e\e^\er"'
 
   # ALT-C - cd into the selected directory
-  bind '"\ec": " \C-e\C-u$(__fcd)\e\C-e\er\C-m"'
+  bind '"\ec": " \C-e\C-u$(__fzf_cd__)\e\C-e\er\C-m"'
 else
   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
   if [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": "\e$a \eddi$(__fsel_tmux)\C-x\C-e\e0P$xa"'
+    bind '"\C-t": "\e$a \eddi$(__fzf_select_tmux__)\C-x\C-e\e0P$xa"'
   else
-    bind '"\C-t": "\e$a \eddi$(__fsel)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
+    bind '"\C-t": "\e$a \eddi$(__fzf_select__)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
   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": "\eddi$(HISTTIMEFORMAT= history | fzf +s --tac +m -n2..,.. | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
+  bind '"\C-r": "\eddi$(__fzf_history__)\C-x\C-e\C-x^\e$a\C-x\C-r"'
   bind -m vi-command '"\C-r": "i\C-r"'
 
   # ALT-C - cd into the selected directory
-  bind '"\ec": "\eddi$(__fcd)\C-x\C-e\C-x\C-r\C-m"'
+  bind '"\ec": "\eddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
   bind -m vi-command '"\ec": "i\ec"'
 fi
 

shell/key-bindings.fish

@@ -7,18 +7,6 @@ function fzf_key_bindings
     set -g TMPDIR /tmp
   end
 
-  function __fzf_list
-    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-      -o -type f -print \
-      -o -type d -print \
-      -o -type l -print 2> /dev/null | sed 1d | cut -b3-
-  end
-
-  function __fzf_list_dir
-    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) \
-      -prune -o -type d -print 2> /dev/null | sed 1d | cut -b3-
-  end
-
   function __fzf_escape
     while read item
       echo -n (echo -n "$item" | sed -E 's/([ "$~'\''([{<>})])/\\\\\\1/g')' '
@@ -26,25 +14,17 @@ function fzf_key_bindings
   end
 
   function __fzf_ctrl_t
-    if [ -n "$TMUX_PANE" -a "$FZF_TMUX" != "0" ]
+    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-      # FIXME need to handle directory with double-quotes
+      -o -type f -print \
-      tmux split-window (__fzf_tmux_height) "cd \"$PWD\";fish -c 'fzf_key_bindings; __fzf_ctrl_t_tmux \\$TMUX_PANE'"
+      -o -type d -print \
-    else
+      -o -type l -print 2> /dev/null | sed 1d | cut -b3- | eval (__fzfcmd) -m > $TMPDIR/fzf.result
-      __fzf_list | fzf -m > $TMPDIR/fzf.result
+    and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
-      and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
+    commandline -f repaint
-      commandline -f repaint
-      rm -f $TMPDIR/fzf.result
-    end
-  end
-
-  function __fzf_ctrl_t_tmux
-    __fzf_list | fzf -m > $TMPDIR/fzf.result
-    and tmux send-keys -t $argv[1] (cat $TMPDIR/fzf.result | __fzf_escape)
     rm -f $TMPDIR/fzf.result
   end
 
   function __fzf_ctrl_r
-    history | fzf +s +m --toggle-sort=ctrl-r > $TMPDIR/fzf.result
+    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r > $TMPDIR/fzf.result
     and commandline (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result
@@ -52,29 +32,36 @@ function fzf_key_bindings
 
   function __fzf_alt_c
     # Fish hangs if the command before pipe redirects (2> /dev/null)
-    __fzf_list_dir | fzf +m > $TMPDIR/fzf.result
+    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) \
+      -prune -o -type d -print 2> /dev/null | sed 1d | cut -b3- | eval (__fzfcmd) +m > $TMPDIR/fzf.result
     [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
     and cd (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result
   end
 
-  function __fzf_tmux_height
+  function __fzfcmd
-    if set -q FZF_TMUX_HEIGHT
+    set -q FZF_TMUX; or set FZF_TMUX 1
-      set height $FZF_TMUX_HEIGHT
+
+    if [ $FZF_TMUX -eq 1 ]
+      if set -q FZF_TMUX_HEIGHT
+        echo "fzf-tmux -d$FZF_TMUX_HEIGHT"
+      else
+        echo "fzf-tmux -d40%"
+      end
     else
-      set height 40%
+      echo "fzf"
     end
-    if echo $height | \grep -q -E '%$'
-      echo "-p "(echo $height | sed 's/%$//')
-    else
-      echo "-l $height"
-    end
-    set -e height
   end
 
   bind \ct '__fzf_ctrl_t'
   bind \cr '__fzf_ctrl_r'
   bind \ec '__fzf_alt_c'
+
+  if bind -M insert > /dev/null 2>&1
+    bind -M insert \ct '__fzf_ctrl_t'
+    bind -M insert \cr '__fzf_ctrl_r'
+    bind -M insert \ec '__fzf_alt_c'
+  end
 end
 

shell/key-bindings.zsh

@@ -5,38 +5,29 @@ __fsel() {
   command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
     -o -type f -print \
     -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) -m | while read item; do
     printf '%q ' "$item"
   done
   echo
 }
 
+__fzfcmd() {
+  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+}
+
 if [[ $- =~ i ]]; then
 
-if [ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ]; then
+fzf-file-widget() {
-  fzf-file-widget() {
+  LBUFFER="${LBUFFER}$(__fsel)"
-    local height
+  zle redisplay
-    height=${FZF_TMUX_HEIGHT:-40%}
+}
-    if [[ $height =~ %$ ]]; then
-      height="-p ${height%\%}"
-    else
-      height="-l $height"
-    fi
-    tmux split-window $height "cd $(printf %q "$PWD");zsh -c 'source ~/.fzf.zsh; tmux send-keys -t $TMUX_PANE \"\$(__fsel)\"'"
-  }
-else
-  fzf-file-widget() {
-    LBUFFER="${LBUFFER}$(__fsel)"
-    zle redisplay
-  }
-fi
 zle     -N   fzf-file-widget
 bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
   cd "${$(command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m):-.}"
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m):-.}"
   zle reset-prompt
 }
 zle     -N    fzf-cd-widget
@@ -44,11 +35,18 @@ bindkey '\ec' fzf-cd-widget
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  local selected
+  local selected restore_no_bang_hist
-  if selected=$(fc -l 1 | fzf +s --tac +m -n2..,.. --toggle-sort=ctrl-r -q "$LBUFFER"); then
+  if selected=$(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r -q "$LBUFFER"); then
-    num=$(echo "$selected" | head -1 | awk '{print $1}' | sed 's/[^0-9]//g')
+    num=$(echo "$selected" | head -n1 | awk '{print $1}' | sed 's/[^0-9]//g')
-    LBUFFER=!$num
+    if [ -n "$num" ]; then
-    zle expand-history
+      LBUFFER=!$num
+      if setopt | grep nobanghist > /dev/null; then
+        restore_no_bang_hist=1
+        unsetopt no_bang_hist
+      fi
+      zle expand-history
+      [ -n "$restore_no_bang_hist" ] && setopt no_bang_hist
+    fi
   fi
   zle redisplay
 }

src/algo/algo.go

@@ -1,6 +1,10 @@
 package algo
 
-import "strings"
+import (
+	"unicode"
+
+	"github.com/junegunn/fzf/src/util"
+)
 
 /*
  * String matching algorithms here do not use strings.ToLower to avoid
@@ -11,13 +15,11 @@ import "strings"
  */
 
 // FuzzyMatch performs fuzzy-match
-func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 	if len(pattern) == 0 {
 		return 0, 0
 	}
 
-	runes := []rune(*input)
-
 	// 0. (FIXME) How to find the shortest match?
 	//    a_____b__c__abc
 	//    ^^^^^^^^^^  ^^^
@@ -31,11 +33,18 @@ func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
 	sidx := -1
 	eidx := -1
 
-	for index, char := range runes {
+	for index, char := range *runes {
 		// This is considerably faster than blindly applying strings.ToLower to the
 		// whole string
-		if !caseSensitive && char >= 65 && char <= 90 {
+		if !caseSensitive {
-			char += 32
+			// Partially inlining `unicode.ToLower`. Ugly, but makes a noticeable
+			// difference in CPU cost. (Measured on Go 1.4.1. Also note that the Go
+			// compiler as of now does not inline non-leaf functions.)
+			if char >= 'A' && char <= 'Z' {
+				char += 32
+			} else if char > unicode.MaxASCII {
+				char = unicode.To(unicode.LowerCase, char)
+			}
 		}
 		if char == pattern[pidx] {
 			if sidx < 0 {
@@ -51,9 +60,13 @@ func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
 	if sidx >= 0 && eidx >= 0 {
 		pidx--
 		for index := eidx - 1; index >= sidx; index-- {
-			char := runes[index]
+			char := (*runes)[index]
-			if !caseSensitive && char >= 65 && char <= 90 {
+			if !caseSensitive {
-				char += 32
+				if char >= 'A' && char <= 'Z' {
+					char += 32
+				} else if char > unicode.MaxASCII {
+					char = unicode.To(unicode.LowerCase, char)
+				}
 			}
 			if char == pattern[pidx] {
 				if pidx--; pidx < 0 {
@@ -67,27 +80,6 @@ func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
 	return -1, -1
 }
 
-// ExactMatchStrings performs exact-match using strings package.
-// Currently not used.
-func ExactMatchStrings(caseSensitive bool, input *string, pattern []rune) (int, int) {
-	if len(pattern) == 0 {
-		return 0, 0
-	}
-
-	var str string
-	if caseSensitive {
-		str = *input
-	} else {
-		str = strings.ToLower(*input)
-	}
-
-	if idx := strings.Index(str, string(pattern)); idx >= 0 {
-		prefixRuneLen := len([]rune((*input)[:idx]))
-		return prefixRuneLen, prefixRuneLen + len(pattern)
-	}
-	return -1, -1
-}
-
 // ExactMatchNaive is a basic string searching algorithm that handles case
 // sensitivity. Although naive, it still performs better than the combination
 // of strings.ToLower + strings.Index for typical fzf use cases where input
@@ -95,13 +87,12 @@ func ExactMatchStrings(caseSensitive bool, input *string, pattern []rune) (int,
 //
 // We might try to implement better algorithms in the future:
 // http://en.wikipedia.org/wiki/String_searching_algorithm
-func ExactMatchNaive(caseSensitive bool, input *string, pattern []rune) (int, int) {
+func ExactMatchNaive(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 	if len(pattern) == 0 {
 		return 0, 0
 	}
 
-	runes := []rune(*input)
+	numRunes := len(*runes)
-	numRunes := len(runes)
 	plen := len(pattern)
 	if numRunes < plen {
 		return -1, -1
@@ -109,9 +100,13 @@ func ExactMatchNaive(caseSensitive bool, input *string, pattern []rune) (int, in
 
 	pidx := 0
 	for index := 0; index < numRunes; index++ {
-		char := runes[index]
+		char := (*runes)[index]
-		if !caseSensitive && char >= 65 && char <= 90 {
+		if !caseSensitive {
-			char += 32
+			if char >= 'A' && char <= 'Z' {
+				char += 32
+			} else if char > unicode.MaxASCII {
+				char = unicode.To(unicode.LowerCase, char)
+			}
 		}
 		if pattern[pidx] == char {
 			pidx++
@@ -127,16 +122,15 @@ func ExactMatchNaive(caseSensitive bool, input *string, pattern []rune) (int, in
 }
 
 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+func PrefixMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
-	runes := []rune(*input)
+	if len(*runes) < len(pattern) {
-	if len(runes) < len(pattern) {
 		return -1, -1
 	}
 
 	for index, r := range pattern {
-		char := runes[index]
+		char := (*runes)[index]
-		if !caseSensitive && char >= 65 && char <= 90 {
+		if !caseSensitive {
-			char += 32
+			char = unicode.ToLower(char)
 		}
 		if char != r {
 			return -1, -1
@@ -146,8 +140,8 @@ func PrefixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
 }
 
 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+func SuffixMatch(caseSensitive bool, input *[]rune, pattern []rune) (int, int) {
-	runes := []rune(strings.TrimRight(*input, " "))
+	runes := util.TrimRight(input)
 	trimmedLen := len(runes)
 	diff := trimmedLen - len(pattern)
 	if diff < 0 {
@@ -156,8 +150,8 @@ func SuffixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
 
 	for index, r := range pattern {
 		char := runes[index+diff]
-		if !caseSensitive && char >= 65 && char <= 90 {
+		if !caseSensitive {
-			char += 32
+			char = unicode.ToLower(char)
 		}
 		if char != r {
 			return -1, -1

src/algo/algo_test.go

@@ -5,11 +5,12 @@ import (
 	"testing"
 )
 
-func assertMatch(t *testing.T, fun func(bool, *string, []rune) (int, int), caseSensitive bool, input string, pattern string, sidx int, eidx int) {
+func assertMatch(t *testing.T, fun func(bool, *[]rune, []rune) (int, int), caseSensitive bool, input string, pattern string, sidx int, eidx int) {
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	s, e := fun(caseSensitive, &input, []rune(pattern))
+	runes := []rune(input)
+	s, e := fun(caseSensitive, &runes, []rune(pattern))
 	if s != sidx {
 		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", s, sidx, input, pattern)
 	}
@@ -45,7 +46,6 @@ func TestSuffixMatch(t *testing.T) {
 
 func TestEmptyPattern(t *testing.T) {
 	assertMatch(t, FuzzyMatch, true, "foobar", "", 0, 0)
-	assertMatch(t, ExactMatchStrings, true, "foobar", "", 0, 0)
 	assertMatch(t, ExactMatchNaive, true, "foobar", "", 0, 0)
 	assertMatch(t, PrefixMatch, true, "foobar", "", 0, 0)
 	assertMatch(t, SuffixMatch, true, "foobar", "", 6, 6)

src/ansi.go

@@ -50,7 +50,7 @@ func extractColor(str *string) (*string, []ansiOffset) {
 		if !newState.equals(state) {
 			if state != nil {
 				// Update last offset
-				(&offsets[len(offsets)-1]).offset[1] = int32(output.Len())
+				(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
 			}
 
 			if newState.colored() {

src/cache.go

@@ -2,23 +2,23 @@ package fzf
 
 import "sync"
 
-// QueryCache associates strings to lists of items
+// queryCache associates strings to lists of items
-type QueryCache map[string][]*Item
+type queryCache map[string][]*Item
 
 // ChunkCache associates Chunk and query string to lists of items
 type ChunkCache struct {
 	mutex sync.Mutex
-	cache map[*Chunk]*QueryCache
+	cache map[*Chunk]*queryCache
 }
 
 // NewChunkCache returns a new ChunkCache
 func NewChunkCache() ChunkCache {
-	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*QueryCache)}
+	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
 }
 
 // Add adds the list to the cache
 func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
-	if len(key) == 0 || !chunk.IsFull() {
+	if len(key) == 0 || !chunk.IsFull() || len(list) > queryCacheMax {
 		return
 	}
 
@@ -27,7 +27,7 @@ func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
 
 	qc, ok := cc.cache[chunk]
 	if !ok {
-		cc.cache[chunk] = &QueryCache{}
+		cc.cache[chunk] = &queryCache{}
 		qc = cc.cache[chunk]
 	}
 	(*qc)[key] = list

src/cache_test.go

@@ -4,7 +4,7 @@ import "testing"
 
 func TestChunkCache(t *testing.T) {
 	cache := NewChunkCache()
-	chunk2 := make(Chunk, ChunkSize)
+	chunk2 := make(Chunk, chunkSize)
 	chunk1p := &Chunk{}
 	chunk2p := &chunk2
 	items1 := []*Item{&Item{}}

src/chunklist.go

@@ -2,10 +2,7 @@ package fzf
 
 import "sync"
 
-// Capacity of each chunk
+// Chunk is a list of Item pointers whose size has the upper limit of chunkSize
-const ChunkSize int = 100
-
-// Chunk is a list of Item pointers whose size has the upper limit of ChunkSize
 type Chunk []*Item // >>> []Item
 
 // ItemBuilder is a closure type that builds Item object from a pointer to a
@@ -35,7 +32,7 @@ func (c *Chunk) push(trans ItemBuilder, data *string, index int) {
 
 // IsFull returns true if the Chunk is full
 func (c *Chunk) IsFull() bool {
-	return len(*c) == ChunkSize
+	return len(*c) == chunkSize
 }
 
 func (cl *ChunkList) lastChunk() *Chunk {
@@ -47,7 +44,7 @@ func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
 		return 0
 	}
-	return ChunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
+	return chunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
 }
 
 // Push adds the item to the list
@@ -56,7 +53,7 @@ func (cl *ChunkList) Push(data string) {
 	defer cl.mutex.Unlock()
 
 	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
-		newChunk := Chunk(make([]*Item, 0, ChunkSize))
+		newChunk := Chunk(make([]*Item, 0, chunkSize))
 		cl.chunks = append(cl.chunks, &newChunk)
 	}
 

src/chunklist_test.go

@@ -45,7 +45,7 @@ func TestChunkList(t *testing.T) {
 	}
 
 	// Add more data
-	for i := 0; i < ChunkSize*2; i++ {
+	for i := 0; i < chunkSize*2; i++ {
 		cl.Push(fmt.Sprintf("item %d", i))
 	}
 
@@ -57,7 +57,7 @@ func TestChunkList(t *testing.T) {
 	// New snapshot
 	snapshot, count = cl.Snapshot()
 	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
-		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != ChunkSize*2+2 {
+		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
 		t.Error("Expected two full chunks and one more chunk")
 	}
 	if len(*snapshot[2]) != 2 {

src/constants.go

@@ -1,11 +1,38 @@
 package fzf
 
 import (
+	"time"
+
 	"github.com/junegunn/fzf/src/util"
 )
 
-// Current version
+const (
-const Version = "0.9.7"
+	// Current version
+	Version = "0.9.12"
+
+	// Core
+	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
+	coordinatorDelayStep time.Duration = 10 * time.Millisecond
+
+	// Reader
+	defaultCommand = `find * -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null`
+
+	// Terminal
+	initialDelay    = 100 * time.Millisecond
+	spinnerDuration = 200 * time.Millisecond
+
+	// Matcher
+	progressMinDuration = 200 * time.Millisecond
+
+	// Capacity of each chunk
+	chunkSize int = 100
+
+	// Do not cache results of low selectivity queries
+	queryCacheMax int = chunkSize / 5
+
+	// Not to cache mergers with large lists
+	mergerCacheMax int = 100000
+)
 
 // fzf events
 const (

src/core.go

@@ -34,9 +34,6 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-const coordinatorDelayMax time.Duration = 100 * time.Millisecond
-const coordinatorDelayStep time.Duration = 10 * time.Millisecond
-
 func initProcs() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
 }
@@ -50,11 +47,11 @@ Matcher  -> EvtSearchFin      -> Terminal (update list)
 */
 
 // Run starts fzf
-func Run(options *Options) {
+func Run(opts *Options) {
 	initProcs()
 
-	opts := ParseOptions()
 	sort := opts.Sort > 0
+	rankTiebreak = opts.Tiebreak
 
 	if opts.Version {
 		fmt.Println(Version)
@@ -70,7 +67,7 @@ func Run(options *Options) {
 		return data, nil
 	}
 	if opts.Ansi {
-		if opts.Color {
+		if opts.Theme != nil {
 			ansiProcessor = func(data *string) (*string, []ansiOffset) {
 				return extractColor(data)
 			}
@@ -98,8 +95,9 @@ func Run(options *Options) {
 	} else {
 		chunkList = NewChunkList(func(data *string, index int) *Item {
 			tokens := Tokenize(data, opts.Delimiter)
+			trans := Transform(tokens, opts.WithNth)
 			item := Item{
-				text:     Transform(tokens, opts.WithNth).whole,
+				text:     joinTokens(trans),
 				origText: data,
 				index:    uint32(index),
 				colors:   nil,
@@ -194,8 +192,9 @@ func Run(options *Options) {
 					matcher.Reset(snapshot, terminal.Input(), false, !reading, sort)
 
 				case EvtSearchNew:
-					if value.(bool) {
+					switch val := value.(type) {
-						sort = !sort
+					case bool:
+						sort = val
 					}
 					snapshot, _ := chunkList.Snapshot()
 					matcher.Reset(snapshot, terminal.Input(), true, !reading, sort)

src/curses/curses.go

@@ -61,6 +61,16 @@ const (
 	PgUp
 	PgDn
 
+	Up
+	Down
+	Left
+	Right
+	Home
+	End
+
+	SLeft
+	SRight
+
 	F1
 	F2
 	F3
@@ -95,6 +105,18 @@ const (
 	doubleClickDuration = 500 * time.Millisecond
 )
 
+type ColorTheme struct {
+	darkBg       C.short
+	prompt       C.short
+	match        C.short
+	current      C.short
+	currentMatch C.short
+	spinner      C.short
+	info         C.short
+	cursor       C.short
+	selected     C.short
+}
+
 type Event struct {
 	Type       int
 	Char       rune
@@ -116,8 +138,10 @@ var (
 	_color        func(int, bool) C.int
 	_colorMap     map[int]int
 	_prevDownTime time.Time
-	_prevDownY    int
 	_clickY       []int
+	Default16     *ColorTheme
+	Dark256       *ColorTheme
+	Light256      *ColorTheme
 	DarkBG        C.short
 )
 
@@ -125,6 +149,36 @@ func init() {
 	_prevDownTime = time.Unix(0, 0)
 	_clickY = []int{}
 	_colorMap = make(map[int]int)
+	Default16 = &ColorTheme{
+		darkBg:       C.COLOR_BLACK,
+		prompt:       C.COLOR_BLUE,
+		match:        C.COLOR_GREEN,
+		current:      C.COLOR_YELLOW,
+		currentMatch: C.COLOR_GREEN,
+		spinner:      C.COLOR_GREEN,
+		info:         C.COLOR_WHITE,
+		cursor:       C.COLOR_RED,
+		selected:     C.COLOR_MAGENTA}
+	Dark256 = &ColorTheme{
+		darkBg:       236,
+		prompt:       110,
+		match:        108,
+		current:      254,
+		currentMatch: 151,
+		spinner:      148,
+		info:         144,
+		cursor:       161,
+		selected:     168}
+	Light256 = &ColorTheme{
+		darkBg:       251,
+		prompt:       25,
+		match:        66,
+		current:      237,
+		currentMatch: 23,
+		spinner:      65,
+		info:         101,
+		cursor:       161,
+		selected:     168}
 }
 
 func attrColored(pair int, bold bool) C.int {
@@ -174,7 +228,7 @@ func getch(nonblock bool) int {
 	return int(b[0])
 }
 
-func Init(color bool, color256 bool, black bool, mouse bool) {
+func Init(theme *ColorTheme, black bool, mouse bool) {
 	{
 		in, err := os.OpenFile("/dev/tty", syscall.O_RDONLY, 0)
 		if err != nil {
@@ -204,42 +258,35 @@ func Init(color bool, color256 bool, black bool, mouse bool) {
 		os.Exit(1)
 	}()
 
-	if color {
+	if theme != nil {
 		C.start_color()
-		var bg C.short
+		initPairs(theme, black)
-		if black {
-			bg = C.COLOR_BLACK
-		} else {
-			C.use_default_colors()
-			bg = -1
-		}
-		if color256 {
-			DarkBG = 236
-			C.init_pair(ColPrompt, 110, bg)
-			C.init_pair(ColMatch, 108, bg)
-			C.init_pair(ColCurrent, 254, DarkBG)
-			C.init_pair(ColCurrentMatch, 151, DarkBG)
-			C.init_pair(ColSpinner, 148, bg)
-			C.init_pair(ColInfo, 144, bg)
-			C.init_pair(ColCursor, 161, DarkBG)
-			C.init_pair(ColSelected, 168, DarkBG)
-		} else {
-			DarkBG = C.COLOR_BLACK
-			C.init_pair(ColPrompt, C.COLOR_BLUE, bg)
-			C.init_pair(ColMatch, C.COLOR_GREEN, bg)
-			C.init_pair(ColCurrent, C.COLOR_YELLOW, DarkBG)
-			C.init_pair(ColCurrentMatch, C.COLOR_GREEN, DarkBG)
-			C.init_pair(ColSpinner, C.COLOR_GREEN, bg)
-			C.init_pair(ColInfo, C.COLOR_WHITE, bg)
-			C.init_pair(ColCursor, C.COLOR_RED, DarkBG)
-			C.init_pair(ColSelected, C.COLOR_MAGENTA, DarkBG)
-		}
 		_color = attrColored
 	} else {
 		_color = attrMono
 	}
 }
 
+func initPairs(theme *ColorTheme, black bool) {
+	var bg C.short
+	if black {
+		bg = C.COLOR_BLACK
+	} else {
+		C.use_default_colors()
+		bg = -1
+	}
+
+	DarkBG = theme.darkBg
+	C.init_pair(ColPrompt, theme.prompt, bg)
+	C.init_pair(ColMatch, theme.match, bg)
+	C.init_pair(ColCurrent, theme.current, DarkBG)
+	C.init_pair(ColCurrentMatch, theme.currentMatch, DarkBG)
+	C.init_pair(ColSpinner, theme.spinner, bg)
+	C.init_pair(ColInfo, theme.info, bg)
+	C.init_pair(ColCursor, theme.cursor, DarkBG)
+	C.init_pair(ColSelected, theme.selected, DarkBG)
+}
+
 func Close() {
 	C.endwin()
 	C.swapOutput()
@@ -319,19 +366,19 @@ func escSequence(sz *int) Event {
 		*sz = 3
 		switch _buf[2] {
 		case 68:
-			return Event{CtrlB, 0, nil}
+			return Event{Left, 0, nil}
 		case 67:
-			return Event{CtrlF, 0, nil}
+			return Event{Right, 0, nil}
 		case 66:
-			return Event{CtrlJ, 0, nil}
+			return Event{Down, 0, nil}
 		case 65:
-			return Event{CtrlK, 0, nil}
+			return Event{Up, 0, nil}
 		case 90:
 			return Event{BTab, 0, nil}
 		case 72:
-			return Event{CtrlA, 0, nil}
+			return Event{Home, 0, nil}
 		case 70:
-			return Event{CtrlE, 0, nil}
+			return Event{End, 0, nil}
 		case 77:
 			return mouseSequence(sz)
 		case 80:
@@ -353,7 +400,7 @@ func escSequence(sz *int) Event {
 			case 51:
 				return Event{Del, 0, nil}
 			case 52:
-				return Event{CtrlE, 0, nil}
+				return Event{End, 0, nil}
 			case 53:
 				return Event{PgUp, 0, nil}
 			case 54:
@@ -361,7 +408,7 @@ func escSequence(sz *int) Event {
 			case 49:
 				switch _buf[3] {
 				case 126:
-					return Event{CtrlA, 0, nil}
+					return Event{Home, 0, nil}
 				case 59:
 					if len(_buf) != 6 {
 						return Event{Invalid, 0, nil}
@@ -371,16 +418,16 @@ func escSequence(sz *int) Event {
 					case 50:
 						switch _buf[5] {
 						case 68:
-							return Event{CtrlA, 0, nil}
+							return Event{Home, 0, nil}
 						case 67:
-							return Event{CtrlE, 0, nil}
+							return Event{End, 0, nil}
 						}
 					case 53:
 						switch _buf[5] {
 						case 68:
-							return Event{AltB, 0, nil}
+							return Event{SLeft, 0, nil}
 						case 67:
-							return Event{AltF, 0, nil}
+							return Event{SRight, 0, nil}
 						}
 					} // _buf[4]
 				} // _buf[3]
@@ -420,6 +467,9 @@ func GetChar() Event {
 		return Event{int(_buf[0]), 0, nil}
 	}
 	r, rsz := utf8.DecodeRune(_buf)
+	if r == utf8.RuneError {
+		return Event{ESC, 0, nil}
+	}
 	sz = rsz
 	return Event{Rune, r, nil}
 }

src/item.go

@@ -1,6 +1,8 @@
 package fzf
 
 import (
+	"math"
+
 	"github.com/junegunn/fzf/src/curses"
 )
 
@@ -17,7 +19,7 @@ type colorOffset struct {
 type Item struct {
 	text        *string
 	origText    *string
-	transformed *Transformed
+	transformed *[]Token
 	index       uint32
 	offsets     []Offset
 	colors      []ansiOffset
@@ -27,17 +29,21 @@ type Item struct {
 // Rank is used to sort the search result
 type Rank struct {
 	matchlen uint16
-	strlen   uint16
+	tiebreak uint16
 	index    uint32
 }
 
+// Tiebreak criterion to use. Never changes once fzf is started.
+var rankTiebreak tiebreak
+
 // Rank calculates rank of the Item
 func (i *Item) Rank(cache bool) Rank {
-	if cache && (i.rank.matchlen > 0 || i.rank.strlen > 0) {
+	if cache && (i.rank.matchlen > 0 || i.rank.tiebreak > 0) {
 		return i.rank
 	}
 	matchlen := 0
 	prevEnd := 0
+	minBegin := math.MaxUint16
 	for _, offset := range i.offsets {
 		begin := int(offset[0])
 		end := int(offset[1])
@@ -48,10 +54,30 @@ func (i *Item) Rank(cache bool) Rank {
 			prevEnd = end
 		}
 		if end > begin {
+			if begin < minBegin {
+				minBegin = begin
+			}
 			matchlen += end - begin
 		}
 	}
-	rank := Rank{uint16(matchlen), uint16(len(*i.text)), i.index}
+	var tiebreak uint16
+	switch rankTiebreak {
+	case byLength:
+		tiebreak = uint16(len(*i.text))
+	case byBegin:
+		// We can't just look at i.offsets[0][0] because it can be an inverse term
+		tiebreak = uint16(minBegin)
+	case byEnd:
+		if prevEnd > 0 {
+			tiebreak = uint16(1 + len(*i.text) - prevEnd)
+		} else {
+			// Empty offsets due to inverse terms.
+			tiebreak = 1
+		}
+	case byIndex:
+		tiebreak = 1
+	}
+	rank := Rank{uint16(matchlen), tiebreak, i.index}
 	if cache {
 		i.rank = rank
 	}
@@ -199,9 +225,9 @@ func compareRanks(irank Rank, jrank Rank, tac bool) bool {
 		return false
 	}
 
-	if irank.strlen < jrank.strlen {
+	if irank.tiebreak < jrank.tiebreak {
 		return true
-	} else if irank.strlen > jrank.strlen {
+	} else if irank.tiebreak > jrank.tiebreak {
 		return false
 	}
 

src/item_test.go

@@ -42,7 +42,7 @@ func TestItemRank(t *testing.T) {
 	strs := []string{"foo", "foobar", "bar", "baz"}
 	item1 := Item{text: &strs[0], index: 1, offsets: []Offset{}}
 	rank1 := item1.Rank(true)
-	if rank1.matchlen != 0 || rank1.strlen != 3 || rank1.index != 1 {
+	if rank1.matchlen != 0 || rank1.tiebreak != 3 || rank1.index != 1 {
 		t.Error(item1.Rank(true))
 	}
 	// Only differ in index

src/matcher.go

@@ -34,10 +34,6 @@ const (
 	reqReset
 )
 
-const (
-	progressMinDuration = 200 * time.Millisecond
-)
-
 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
 	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
@@ -100,7 +96,9 @@ func (m *Matcher) Loop() {
 		}
 
 		if !cancelled {
-			m.mergerCache[patternString] = merger
+			if merger.Cacheable() {
+				m.mergerCache[patternString] = merger
+			}
 			merger.final = request.final
 			m.eventBox.Set(EvtSearchFin, merger)
 		}

src/merger.go

@@ -61,8 +61,8 @@ func (mg *Merger) Get(idx int) *Item {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
-		chunk := (*mg.chunks)[idx/ChunkSize]
+		chunk := (*mg.chunks)[idx/chunkSize]
-		return (*chunk)[idx%ChunkSize]
+		return (*chunk)[idx%chunkSize]
 	}
 
 	if mg.sorted {
@@ -82,6 +82,10 @@ func (mg *Merger) Get(idx int) *Item {
 	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
 }
 
+func (mg *Merger) Cacheable() bool {
+	return mg.count < mergerCacheMax
+}
+
 func (mg *Merger) mergedGet(idx int) *Item {
 	for i := len(mg.merged); i <= idx; i++ {
 		minRank := Rank{0, 0, 0}

src/options.go

@@ -28,17 +28,22 @@ const usage = `usage: fzf [options]
   Search result
     +s, --no-sort         Do not sort the result
         --tac             Reverse the order of the input
-                          (e.g. 'history | fzf --tac --no-sort')
+        --tiebreak=CRI    Sort criterion when the scores are tied;
+                          [length|begin|end|index] (default: length)
 
   Interface
     -m, --multi           Enable multi-select with tab/shift-tab
         --ansi            Enable processing of ANSI color codes
         --no-mouse        Disable mouse
-    +c, --no-color        Disable colors
+        --color=COL       Color scheme; [dark|light|16|bw]
-    +2, --no-256          Disable 256-color
+                          (default: dark on 256-color terminal, otherwise 16)
         --black           Use black background
         --reverse         Reverse orientation
+        --no-hscroll      Disable horizontal scroll
+        --inline-info     Display finder info inline with the query
         --prompt=STR      Input prompt (default: '> ')
+        --toggle-sort=KEY Key to toggle sort
+        --bind=KEYBINDS   Custom key bindings. Refer to the man page.
 
   Scripting
     -q, --query=STR       Start the finder with the given query
@@ -47,9 +52,7 @@ const usage = `usage: fzf [options]
     -f, --filter=STR      Filter mode. Do not start interactive finder.
         --print-query     Print query as the first line
         --expect=KEYS     Comma-separated list of keys to complete fzf
-        --toggle-sort=KEY Key to toggle sort
         --sync            Synchronous search for multi-staged filtering
-                          (e.g. 'fzf --multi | fzf --sync')
 
   Environment variables
     FZF_DEFAULT_COMMAND   Default command to use when input is tty
@@ -77,6 +80,16 @@ const (
 	CaseRespect
 )
 
+// Sort criteria
+type tiebreak int
+
+const (
+	byLength tiebreak = iota
+	byBegin
+	byEnd
+	byIndex
+)
+
 // Options stores the values of command-line options
 type Options struct {
 	Mode       Mode
@@ -86,26 +99,36 @@ type Options struct {
 	Delimiter  *regexp.Regexp
 	Sort       int
 	Tac        bool
+	Tiebreak   tiebreak
 	Multi      bool
 	Ansi       bool
 	Mouse      bool
-	Color      bool
+	Theme      *curses.ColorTheme
-	Color256   bool
 	Black      bool
 	Reverse    bool
+	Hscroll    bool
+	InlineInfo bool
 	Prompt     string
 	Query      string
 	Select1    bool
 	Exit0      bool
 	Filter     *string
-	ToggleSort int
+	ToggleSort bool
 	Expect     []int
+	Keymap     map[int]actionType
 	PrintQuery bool
 	Sync       bool
 	Version    bool
 }
 
 func defaultOptions() *Options {
+	var defaultTheme *curses.ColorTheme
+	if strings.Contains(os.Getenv("TERM"), "256") {
+		defaultTheme = curses.Dark256
+	} else {
+		defaultTheme = curses.Default16
+	}
+
 	return &Options{
 		Mode:       ModeFuzzy,
 		Case:       CaseSmart,
@@ -114,20 +137,23 @@ func defaultOptions() *Options {
 		Delimiter:  nil,
 		Sort:       1000,
 		Tac:        false,
+		Tiebreak:   byLength,
 		Multi:      false,
 		Ansi:       false,
 		Mouse:      true,
-		Color:      true,
+		Theme:      defaultTheme,
-		Color256:   strings.Contains(os.Getenv("TERM"), "256"),
 		Black:      false,
 		Reverse:    false,
+		Hscroll:    true,
+		InlineInfo: false,
 		Prompt:     "> ",
 		Query:      "",
 		Select1:    false,
 		Exit0:      false,
 		Filter:     nil,
-		ToggleSort: 0,
+		ToggleSort: false,
 		Expect:     []int{},
+		Keymap:     defaultKeymap(),
 		PrintQuery: false,
 		Sync:       false,
 		Version:    false}
@@ -235,12 +261,119 @@ func parseKeyChords(str string, message string) []int {
 	return chords
 }
 
-func checkToggleSort(str string) int {
+func parseTiebreak(str string) tiebreak {
+	switch strings.ToLower(str) {
+	case "length":
+		return byLength
+	case "index":
+		return byIndex
+	case "begin":
+		return byBegin
+	case "end":
+		return byEnd
+	default:
+		errorExit("invalid sort criterion: " + str)
+	}
+	return byLength
+}
+
+func parseTheme(str string) *curses.ColorTheme {
+	switch strings.ToLower(str) {
+	case "dark":
+		return curses.Dark256
+	case "light":
+		return curses.Light256
+	case "16":
+		return curses.Default16
+	case "bw", "no":
+		return nil
+	default:
+		errorExit("invalid color scheme: " + str)
+	}
+	return nil
+}
+
+func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[int]actionType, bool) {
+	for _, pairStr := range strings.Split(str, ",") {
+		fail := func() {
+			errorExit("invalid key binding: " + pairStr)
+		}
+		pair := strings.Split(pairStr, ":")
+		if len(pair) != 2 {
+			fail()
+		}
+		keys := parseKeyChords(pair[0], "key name required")
+		if len(keys) != 1 {
+			fail()
+		}
+		key := keys[0]
+		act := strings.ToLower(pair[1])
+		switch act {
+		case "beginning-of-line":
+			keymap[key] = actBeginningOfLine
+		case "abort":
+			keymap[key] = actAbort
+		case "accept":
+			keymap[key] = actAccept
+		case "backward-char":
+			keymap[key] = actBackwardChar
+		case "backward-delete-char":
+			keymap[key] = actBackwardDeleteChar
+		case "backward-word":
+			keymap[key] = actBackwardWord
+		case "clear-screen":
+			keymap[key] = actClearScreen
+		case "delete-char":
+			keymap[key] = actDeleteChar
+		case "end-of-line":
+			keymap[key] = actEndOfLine
+		case "forward-char":
+			keymap[key] = actForwardChar
+		case "forward-word":
+			keymap[key] = actForwardWord
+		case "kill-line":
+			keymap[key] = actKillLine
+		case "kill-word":
+			keymap[key] = actKillWord
+		case "unix-line-discard", "line-discard":
+			keymap[key] = actUnixLineDiscard
+		case "unix-word-rubout", "word-rubout":
+			keymap[key] = actUnixWordRubout
+		case "yank":
+			keymap[key] = actYank
+		case "backward-kill-word":
+			keymap[key] = actBackwardKillWord
+		case "toggle-down":
+			keymap[key] = actToggleDown
+		case "toggle-up":
+			keymap[key] = actToggleUp
+		case "toggle":
+			keymap[key] = actToggle
+		case "down":
+			keymap[key] = actDown
+		case "up":
+			keymap[key] = actUp
+		case "page-up":
+			keymap[key] = actPageUp
+		case "page-down":
+			keymap[key] = actPageDown
+		case "toggle-sort":
+			keymap[key] = actToggleSort
+			toggleSort = true
+		default:
+			errorExit("unknown action: " + act)
+		}
+	}
+	return keymap, toggleSort
+}
+
+func checkToggleSort(keymap map[int]actionType, str string) map[int]actionType {
 	keys := parseKeyChords(str, "key name required")
 	if len(keys) != 1 {
 		errorExit("multiple keys specified")
 	}
-	return keys[0]
+	keymap[keys[0]] = actToggleSort
+	return keymap
 }
 
 func parseOptions(opts *Options, allArgs []string) {
@@ -262,8 +395,15 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Filter = &filter
 		case "--expect":
 			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
+		case "--tiebreak":
+			opts.Tiebreak = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
+		case "--bind":
+			opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, nextString(allArgs, &i, "bind expression required"))
+		case "--color":
+			opts.Theme = parseTheme(nextString(allArgs, &i, "color scheme name required"))
 		case "--toggle-sort":
-			opts.ToggleSort = checkToggleSort(nextString(allArgs, &i, "key name required"))
+			opts.Keymap = checkToggleSort(opts.Keymap, nextString(allArgs, &i, "key name required"))
+			opts.ToggleSort = true
 		case "-d", "--delimiter":
 			opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
 		case "-n", "--nth":
@@ -293,9 +433,9 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--no-mouse":
 			opts.Mouse = false
 		case "+c", "--no-color":
-			opts.Color = false
+			opts.Theme = nil
 		case "+2", "--no-256":
-			opts.Color256 = false
+			opts.Theme = curses.Default16
 		case "--black":
 			opts.Black = true
 		case "--no-black":
@@ -304,6 +444,14 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Reverse = true
 		case "--no-reverse":
 			opts.Reverse = false
+		case "--hscroll":
+			opts.Hscroll = true
+		case "--no-hscroll":
+			opts.Hscroll = false
+		case "--inline-info":
+			opts.InlineInfo = true
+		case "--no-inline-info":
+			opts.InlineInfo = false
 		case "-1", "--select-1":
 			opts.Select1 = true
 		case "+1", "--no-select-1":
@@ -342,9 +490,16 @@ func parseOptions(opts *Options, allArgs []string) {
 			} else if match, _ := optString(arg, "-s|--sort="); match {
 				opts.Sort = 1 // Don't care
 			} else if match, value := optString(arg, "--toggle-sort="); match {
-				opts.ToggleSort = checkToggleSort(value)
+				opts.Keymap = checkToggleSort(opts.Keymap, value)
+				opts.ToggleSort = true
 			} else if match, value := optString(arg, "--expect="); match {
 				opts.Expect = parseKeyChords(value, "key names required")
+			} else if match, value := optString(arg, "--tiebreak="); match {
+				opts.Tiebreak = parseTiebreak(value)
+			} else if match, value := optString(arg, "--color="); match {
+				opts.Theme = parseTheme(value)
+			} else if match, value := optString(arg, "--bind="); match {
+				opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, value)
 			} else {
 				errorExit("unknown option: " + arg)
 			}

src/options_test.go

@@ -129,3 +129,29 @@ func TestParseKeysWithComma(t *testing.T) {
 	check(len(keys), 1)
 	check(keys[0], curses.AltZ+',')
 }
+
+func TestBind(t *testing.T) {
+	check := func(action actionType, expected actionType) {
+		if action != expected {
+			t.Errorf("%d != %d", action, expected)
+		}
+	}
+	keymap := defaultKeymap()
+	check(actBeginningOfLine, keymap[curses.CtrlA])
+	keymap, toggleSort :=
+		parseKeymap(keymap, false,
+			"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down")
+	if !toggleSort {
+		t.Errorf("toggleSort not set")
+	}
+	check(actKillLine, keymap[curses.CtrlA])
+	check(actToggleSort, keymap[curses.CtrlB])
+	check(actPageUp, keymap[curses.AltZ+'c'])
+	check(actPageDown, keymap[curses.AltZ])
+
+	keymap, toggleSort = parseKeymap(keymap, false, "f1:abort")
+	if toggleSort {
+		t.Errorf("toggleSort set")
+	}
+	check(actAbort, keymap[curses.F1])
+}

src/pattern.go

@@ -8,8 +8,6 @@ import (
 	"github.com/junegunn/fzf/src/algo"
 )
 
-const uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
 // fuzzy
 // 'exact
 // ^exact-prefix
@@ -29,10 +27,11 @@ const (
 )
 
 type term struct {
-	typ      termType
+	typ           termType
-	inv      bool
+	inv           bool
-	text     []rune
+	text          []rune
-	origText []rune
+	caseSensitive bool
+	origText      []rune
 }
 
 // Pattern represents search pattern
@@ -44,7 +43,7 @@ type Pattern struct {
 	hasInvTerm    bool
 	delimiter     *regexp.Regexp
 	nth           []Range
-	procFun       map[termType]func(bool, *string, []rune) (int, int)
+	procFun       map[termType]func(bool, *[]rune, []rune) (int, int)
 }
 
 var (
@@ -89,34 +88,32 @@ func BuildPattern(mode Mode, caseMode Case,
 	caseSensitive, hasInvTerm := true, false
 	terms := []term{}
 
-	switch caseMode {
-	case CaseSmart:
-		if !strings.ContainsAny(asString, uppercaseLetters) {
-			runes, caseSensitive = []rune(strings.ToLower(asString)), false
-		}
-	case CaseIgnore:
-		runes, caseSensitive = []rune(strings.ToLower(asString)), false
-	}
-
 	switch mode {
 	case ModeExtended, ModeExtendedExact:
-		terms = parseTerms(mode, string(runes))
+		terms = parseTerms(mode, caseMode, asString)
 		for _, term := range terms {
 			if term.inv {
 				hasInvTerm = true
 			}
 		}
+	default:
+		lowerString := strings.ToLower(asString)
+		caseSensitive = caseMode == CaseRespect ||
+			caseMode == CaseSmart && lowerString != asString
+		if !caseSensitive {
+			asString = lowerString
+		}
 	}
 
 	ptr := &Pattern{
 		mode:          mode,
 		caseSensitive: caseSensitive,
-		text:          runes,
+		text:          []rune(asString),
 		terms:         terms,
 		hasInvTerm:    hasInvTerm,
 		nth:           nth,
 		delimiter:     delimiter,
-		procFun:       make(map[termType]func(bool, *string, []rune) (int, int))}
+		procFun:       make(map[termType]func(bool, *[]rune, []rune) (int, int))}
 
 	ptr.procFun[termFuzzy] = algo.FuzzyMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
@@ -127,11 +124,17 @@ func BuildPattern(mode Mode, caseMode Case,
 	return ptr
 }
 
-func parseTerms(mode Mode, str string) []term {
+func parseTerms(mode Mode, caseMode Case, str string) []term {
 	tokens := _splitRegex.Split(str, -1)
 	terms := []term{}
 	for _, token := range tokens {
 		typ, inv, text := termFuzzy, false, token
+		lowerText := strings.ToLower(text)
+		caseSensitive := caseMode == CaseRespect ||
+			caseMode == CaseSmart && text != lowerText
+		if !caseSensitive {
+			text = lowerText
+		}
 		origText := []rune(text)
 		if mode == ModeExtendedExact {
 			typ = termExact
@@ -157,10 +160,11 @@ func parseTerms(mode Mode, str string) []term {
 
 		if len(text) > 0 {
 			terms = append(terms, term{
-				typ:      typ,
+				typ:           typ,
-				inv:      inv,
+				inv:           inv,
-				text:     []rune(text),
+				text:          []rune(text),
-				origText: origText})
+				caseSensitive: caseSensitive,
+				origText:      origText})
 		}
 	}
 	return terms
@@ -274,7 +278,7 @@ func dupItem(item *Item, offsets []Offset) *Item {
 
 func (p *Pattern) fuzzyMatch(item *Item) (int, int) {
 	input := p.prepareInput(item)
-	return p.iter(algo.FuzzyMatch, input, p.text)
+	return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.text)
 }
 
 func (p *Pattern) extendedMatch(item *Item) []Offset {
@@ -282,7 +286,7 @@ func (p *Pattern) extendedMatch(item *Item) []Offset {
 	offsets := []Offset{}
 	for _, term := range p.terms {
 		pfun := p.procFun[term.typ]
-		if sidx, eidx := p.iter(pfun, input, term.text); sidx >= 0 {
+		if sidx, eidx := p.iter(pfun, input, term.caseSensitive, term.text); sidx >= 0 {
 			if term.inv {
 				break
 			}
@@ -294,30 +298,29 @@ func (p *Pattern) extendedMatch(item *Item) []Offset {
 	return offsets
 }
 
-func (p *Pattern) prepareInput(item *Item) *Transformed {
+func (p *Pattern) prepareInput(item *Item) *[]Token {
 	if item.transformed != nil {
 		return item.transformed
 	}
 
-	var ret *Transformed
+	var ret *[]Token
 	if len(p.nth) > 0 {
 		tokens := Tokenize(item.text, p.delimiter)
 		ret = Transform(tokens, p.nth)
 	} else {
-		trans := Transformed{
+		runes := []rune(*item.text)
-			whole: item.text,
+		trans := []Token{Token{text: &runes, prefixLength: 0}}
-			parts: []Token{Token{text: item.text, prefixLength: 0}}}
 		ret = &trans
 	}
 	item.transformed = ret
 	return ret
 }
 
-func (p *Pattern) iter(pfun func(bool, *string, []rune) (int, int),
+func (p *Pattern) iter(pfun func(bool, *[]rune, []rune) (int, int),
-	inputs *Transformed, pattern []rune) (int, int) {
+	tokens *[]Token, caseSensitive bool, pattern []rune) (int, int) {
-	for _, part := range inputs.parts {
+	for _, part := range *tokens {
 		prefixLength := part.prefixLength
-		if sidx, eidx := pfun(p.caseSensitive, part.text, pattern); sidx >= 0 {
+		if sidx, eidx := pfun(caseSensitive, part.text, pattern); sidx >= 0 {
 			return sidx + prefixLength, eidx + prefixLength
 		}
 	}

src/pattern_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestParseTermsExtended(t *testing.T) {
-	terms := parseTerms(ModeExtended,
+	terms := parseTerms(ModeExtended, CaseSmart,
 		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
 	if len(terms) != 8 ||
 		terms[0].typ != termFuzzy || terms[0].inv ||
@@ -31,7 +31,7 @@ func TestParseTermsExtended(t *testing.T) {
 }
 
 func TestParseTermsExtendedExact(t *testing.T) {
-	terms := parseTerms(ModeExtendedExact,
+	terms := parseTerms(ModeExtendedExact, CaseSmart,
 		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
 	if len(terms) != 8 ||
 		terms[0].typ != termExact || terms[0].inv || len(terms[0].text) != 3 ||
@@ -47,7 +47,7 @@ func TestParseTermsExtendedExact(t *testing.T) {
 }
 
 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(ModeExtended, "' $ ^ !' !^ !$")
+	terms := parseTerms(ModeExtended, CaseSmart, "' $ ^ !' !^ !$")
 	if len(terms) != 0 {
 		t.Errorf("%s", terms)
 	}
@@ -58,8 +58,8 @@ func TestExact(t *testing.T) {
 	clearPatternCache()
 	pattern := BuildPattern(ModeExtended, CaseSmart,
 		[]Range{}, nil, []rune("'abc"))
-	str := "aabbcc abc"
+	runes := []rune("aabbcc abc")
-	sidx, eidx := algo.ExactMatchNaive(pattern.caseSensitive, &str, pattern.terms[0].text)
+	sidx, eidx := algo.ExactMatchNaive(pattern.caseSensitive, &runes, pattern.terms[0].text)
 	if sidx != 7 || eidx != 10 {
 		t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
 	}

src/reader.go

@@ -9,8 +9,6 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-const defaultCommand = `find * -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null`
-
 // Reader reads from command or standard input
 type Reader struct {
 	pusher   func(string)

src/terminal.go

@@ -20,23 +20,27 @@ import (
 
 // Terminal represents terminal input/output
 type Terminal struct {
+	inlineInfo bool
 	prompt     string
 	reverse    bool
+	hscroll    bool
 	cx         int
 	cy         int
 	offset     int
 	yanked     []rune
 	input      []rune
 	multi      bool
-	toggleSort int
+	sort       bool
+	toggleSort bool
 	expect     []int
+	keymap     map[int]actionType
 	pressed    int
 	printQuery bool
 	count      int
 	progress   int
 	reading    bool
 	merger     *Merger
-	selected   map[*string]selectedItem
+	selected   map[uint32]selectedItem
 	reqBox     *util.EventBox
 	eventBox   *util.EventBox
 	mutex      sync.Mutex
@@ -77,36 +81,117 @@ const (
 	reqQuit
 )
 
+type actionType int
+
 const (
-	initialDelay    = 100 * time.Millisecond
+	actIgnore actionType = iota
-	spinnerDuration = 200 * time.Millisecond
+	actInvalid
+	actRune
+	actMouse
+	actBeginningOfLine
+	actAbort
+	actAccept
+	actBackwardChar
+	actBackwardDeleteChar
+	actBackwardWord
+	actClearScreen
+	actDeleteChar
+	actEndOfLine
+	actForwardChar
+	actForwardWord
+	actKillLine
+	actKillWord
+	actUnixLineDiscard
+	actUnixWordRubout
+	actYank
+	actBackwardKillWord
+	actToggle
+	actToggleDown
+	actToggleUp
+	actDown
+	actUp
+	actPageUp
+	actPageDown
+	actToggleSort
 )
 
+func defaultKeymap() map[int]actionType {
+	keymap := make(map[int]actionType)
+	keymap[C.Invalid] = actInvalid
+	keymap[C.CtrlA] = actBeginningOfLine
+	keymap[C.CtrlB] = actBackwardChar
+	keymap[C.CtrlC] = actAbort
+	keymap[C.CtrlG] = actAbort
+	keymap[C.CtrlQ] = actAbort
+	keymap[C.ESC] = actAbort
+	keymap[C.CtrlD] = actDeleteChar
+	keymap[C.CtrlE] = actEndOfLine
+	keymap[C.CtrlF] = actForwardChar
+	keymap[C.CtrlH] = actBackwardDeleteChar
+	keymap[C.Tab] = actToggleDown
+	keymap[C.BTab] = actToggleUp
+	keymap[C.CtrlJ] = actDown
+	keymap[C.CtrlK] = actUp
+	keymap[C.CtrlL] = actClearScreen
+	keymap[C.CtrlM] = actAccept
+	keymap[C.CtrlN] = actDown
+	keymap[C.CtrlP] = actUp
+	keymap[C.CtrlU] = actUnixLineDiscard
+	keymap[C.CtrlW] = actUnixWordRubout
+	keymap[C.CtrlY] = actYank
+
+	keymap[C.AltB] = actBackwardWord
+	keymap[C.SLeft] = actBackwardWord
+	keymap[C.AltF] = actForwardWord
+	keymap[C.SRight] = actForwardWord
+	keymap[C.AltD] = actKillWord
+	keymap[C.AltBS] = actBackwardKillWord
+
+	keymap[C.Up] = actUp
+	keymap[C.Down] = actDown
+	keymap[C.Left] = actBackwardChar
+	keymap[C.Right] = actForwardChar
+
+	keymap[C.Home] = actBeginningOfLine
+	keymap[C.End] = actEndOfLine
+	keymap[C.Del] = actDeleteChar // FIXME Del vs. CTRL-D
+	keymap[C.PgUp] = actPageUp
+	keymap[C.PgDn] = actPageDown
+
+	keymap[C.Rune] = actRune
+	keymap[C.Mouse] = actMouse
+	return keymap
+}
+
 // NewTerminal returns new Terminal object
 func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 	input := []rune(opts.Query)
 	return &Terminal{
+		inlineInfo: opts.InlineInfo,
 		prompt:     opts.Prompt,
 		reverse:    opts.Reverse,
+		hscroll:    opts.Hscroll,
 		cx:         len(input),
 		cy:         0,
 		offset:     0,
 		yanked:     []rune{},
 		input:      input,
 		multi:      opts.Multi,
+		sort:       opts.Sort > 0,
 		toggleSort: opts.ToggleSort,
 		expect:     opts.Expect,
+		keymap:     opts.Keymap,
 		pressed:    0,
 		printQuery: opts.PrintQuery,
 		merger:     EmptyMerger,
-		selected:   make(map[*string]selectedItem),
+		selected:   make(map[uint32]selectedItem),
 		reqBox:     util.NewEventBox(),
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
 		suppress:   true,
 		startChan:  make(chan bool, 1),
 		initFunc: func() {
-			C.Init(opts.Color, opts.Color256, opts.Black, opts.Mouse)
+			C.Init(opts.Theme, opts.Black, opts.Mouse)
 		}}
 }
 
@@ -230,15 +315,31 @@ func (t *Terminal) printPrompt() {
 }
 
 func (t *Terminal) printInfo() {
-	t.move(1, 0, true)
+	if t.inlineInfo {
-	if t.reading {
+		t.move(0, len(t.prompt)+displayWidth(t.input)+1, true)
-		duration := int64(spinnerDuration)
+		if t.reading {
-		idx := (time.Now().UnixNano() % (duration * int64(len(_spinner)))) / duration
+			C.CPrint(C.ColSpinner, true, " < ")
-		C.CPrint(C.ColSpinner, true, _spinner[idx])
+		} else {
+			C.CPrint(C.ColPrompt, true, " < ")
+		}
+	} else {
+		t.move(1, 0, true)
+		if t.reading {
+			duration := int64(spinnerDuration)
+			idx := (time.Now().UnixNano() % (duration * int64(len(_spinner)))) / duration
+			C.CPrint(C.ColSpinner, true, _spinner[idx])
+		}
+		t.move(1, 2, false)
 	}
 
-	t.move(1, 2, false)
 	output := fmt.Sprintf("%d/%d", t.merger.Length(), t.count)
+	if t.toggleSort {
+		if t.sort {
+			output += "/S"
+		} else {
+			output += "  "
+		}
+	}
 	if t.multi && len(t.selected) > 0 {
 		output += fmt.Sprintf(" (%d)", len(t.selected))
 	}
@@ -251,10 +352,16 @@ func (t *Terminal) printInfo() {
 func (t *Terminal) printList() {
 	t.constrain()
 
-	maxy := maxItems()
+	maxy := t.maxItems()
 	count := t.merger.Length() - t.offset
 	for i := 0; i < maxy; i++ {
-		t.move(i+2, 0, true)
+		var line int
+		if t.inlineInfo {
+			line = i + 1
+		} else {
+			line = i + 2
+		}
+		t.move(line, 0, true)
 		if i < count {
 			t.printItem(t.merger.Get(i+t.offset), i == t.cy-t.offset)
 		}
@@ -262,7 +369,7 @@ func (t *Terminal) printList() {
 }
 
 func (t *Terminal) printItem(item *Item, current bool) {
-	_, selected := t.selected[item.text]
+	_, selected := t.selected[item.index]
 	if current {
 		C.CPrint(C.ColCursor, true, ">")
 		if selected {
@@ -318,7 +425,7 @@ func trimLeft(runes []rune, width int) ([]rune, int32) {
 	return runes, trimmed
 }
 
-func (*Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, current bool) {
+func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, current bool) {
 	var maxe int32
 	for _, offset := range item.offsets {
 		if offset[1] > maxe {
@@ -332,30 +439,40 @@ func (*Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, cur
 	maxWidth := C.MaxX() - 3
 	fullWidth := displayWidth(text)
 	if fullWidth > maxWidth {
-		// Stri..
+		if t.hscroll {
-		matchEndWidth := displayWidth(text[:maxe])
+			// Stri..
-		if matchEndWidth <= maxWidth-2 {
+			matchEndWidth := displayWidth(text[:maxe])
+			if matchEndWidth <= maxWidth-2 {
+				text, _ = trimRight(text, maxWidth-2)
+				text = append(text, []rune("..")...)
+			} else {
+				// Stri..
+				if matchEndWidth < fullWidth-2 {
+					text = append(text[:maxe], []rune("..")...)
+				}
+				// ..ri..
+				var diff int32
+				text, diff = trimLeft(text, maxWidth-2)
+
+				// Transform offsets
+				for idx, offset := range offsets {
+					b, e := offset.offset[0], offset.offset[1]
+					b += 2 - diff
+					e += 2 - diff
+					b = util.Max32(b, 2)
+					offsets[idx].offset[0] = b
+					offsets[idx].offset[1] = util.Max32(b, e)
+				}
+				text = append([]rune(".."), text...)
+			}
+		} else {
 			text, _ = trimRight(text, maxWidth-2)
 			text = append(text, []rune("..")...)
-		} else {
-			// Stri..
-			if matchEndWidth < fullWidth-2 {
-				text = append(text[:maxe], []rune("..")...)
-			}
-			// ..ri..
-			var diff int32
-			text, diff = trimLeft(text, maxWidth-2)
 
-			// Transform offsets
 			for idx, offset := range offsets {
-				b, e := offset.offset[0], offset.offset[1]
+				offsets[idx].offset[0] = util.Min32(offset.offset[0], int32(maxWidth-2))
-				b += 2 - diff
+				offsets[idx].offset[1] = util.Min32(offset.offset[1], int32(maxWidth))
-				e += 2 - diff
-				b = util.Max32(b, 2)
-				offsets[idx].offset[0] = b
-				offsets[idx].offset[1] = util.Max32(b, e)
 			}
-			text = append([]rune(".."), text...)
 		}
 	}
 
@@ -403,8 +520,8 @@ func processTabs(runes []rune, prefixWidth int) (string, int) {
 
 func (t *Terminal) printAll() {
 	t.printList()
-	t.printInfo()
 	t.printPrompt()
+	t.printInfo()
 }
 
 func (t *Terminal) refresh() {
@@ -499,6 +616,9 @@ func (t *Terminal) Loop() {
 					switch req {
 					case reqPrompt:
 						t.printPrompt()
+						if t.inlineInfo {
+							t.printInfo()
+						}
 					case reqInfo:
 						t.printInfo()
 					case reqList:
@@ -544,16 +664,16 @@ func (t *Terminal) Loop() {
 		toggle := func() {
 			if t.cy < t.merger.Length() {
 				item := t.merger.Get(t.cy)
-				if _, found := t.selected[item.text]; !found {
+				if _, found := t.selected[item.index]; !found {
 					var strptr *string
 					if item.origText != nil {
 						strptr = item.origText
 					} else {
 						strptr = item.text
 					}
-					t.selected[item.text] = selectedItem{time.Now(), strptr}
+					t.selected[item.index] = selectedItem{time.Now(), strptr}
 				} else {
-					delete(t.selected, item.text)
+					delete(t.selected, item.index)
 				}
 				req(reqInfo)
 			}
@@ -565,109 +685,127 @@ func (t *Terminal) Loop() {
 				break
 			}
 		}
-		if t.toggleSort > 0 {
+
-			if keyMatch(t.toggleSort, event) {
+		action := t.keymap[event.Type]
-				t.eventBox.Set(EvtSearchNew, true)
+		if event.Type == C.Rune {
-				t.mutex.Unlock()
+			code := int(event.Char) + int(C.AltZ)
-				continue
+			if act, prs := t.keymap[code]; prs {
+				action = act
 			}
 		}
-		switch event.Type {
+		switch action {
-		case C.Invalid:
+		case actInvalid:
 			t.mutex.Unlock()
 			continue
-		case C.CtrlA:
+		case actToggleSort:
+			t.sort = !t.sort
+			t.eventBox.Set(EvtSearchNew, t.sort)
+			t.mutex.Unlock()
+			continue
+		case actBeginningOfLine:
 			t.cx = 0
-		case C.CtrlB:
+		case actBackwardChar:
 			if t.cx > 0 {
 				t.cx--
 			}
-		case C.CtrlC, C.CtrlG, C.CtrlQ, C.ESC:
+		case actAbort:
 			req(reqQuit)
-		case C.CtrlD:
+		case actDeleteChar:
 			if !t.delChar() && t.cx == 0 {
 				req(reqQuit)
 			}
-		case C.CtrlE:
+		case actEndOfLine:
 			t.cx = len(t.input)
-		case C.CtrlF:
+		case actForwardChar:
 			if t.cx < len(t.input) {
 				t.cx++
 			}
-		case C.CtrlH:
+		case actBackwardDeleteChar:
 			if t.cx > 0 {
 				t.input = append(t.input[:t.cx-1], t.input[t.cx:]...)
 				t.cx--
 			}
-		case C.Tab:
+		case actToggle:
+			if t.multi && t.merger.Length() > 0 {
+				toggle()
+				req(reqList)
+			}
+		case actToggleDown:
 			if t.multi && t.merger.Length() > 0 {
 				toggle()
 				t.vmove(-1)
 				req(reqList)
 			}
-		case C.BTab:
+		case actToggleUp:
 			if t.multi && t.merger.Length() > 0 {
 				toggle()
 				t.vmove(1)
 				req(reqList)
 			}
-		case C.CtrlJ, C.CtrlN:
+		case actDown:
 			t.vmove(-1)
 			req(reqList)
-		case C.CtrlK, C.CtrlP:
+		case actUp:
 			t.vmove(1)
 			req(reqList)
-		case C.CtrlM:
+		case actAccept:
 			req(reqClose)
-		case C.CtrlL:
+		case actClearScreen:
 			req(reqRedraw)
-		case C.CtrlU:
+		case actUnixLineDiscard:
 			if t.cx > 0 {
 				t.yanked = copySlice(t.input[:t.cx])
 				t.input = t.input[t.cx:]
 				t.cx = 0
 			}
-		case C.CtrlW:
+		case actUnixWordRubout:
 			if t.cx > 0 {
 				t.rubout("\\s\\S")
 			}
-		case C.AltBS:
+		case actBackwardKillWord:
 			if t.cx > 0 {
 				t.rubout("[^[:alnum:]][[:alnum:]]")
 			}
-		case C.CtrlY:
+		case actYank:
 			suffix := copySlice(t.input[t.cx:])
 			t.input = append(append(t.input[:t.cx], t.yanked...), suffix...)
 			t.cx += len(t.yanked)
-		case C.Del:
+		case actPageUp:
-			t.delChar()
+			t.vmove(t.maxItems() - 1)
-		case C.PgUp:
-			t.vmove(maxItems() - 1)
 			req(reqList)
-		case C.PgDn:
+		case actPageDown:
-			t.vmove(-(maxItems() - 1))
+			t.vmove(-(t.maxItems() - 1))
 			req(reqList)
-		case C.AltB:
+		case actBackwardWord:
 			t.cx = findLastMatch("[^[:alnum:]][[:alnum:]]", string(t.input[:t.cx])) + 1
-		case C.AltF:
+		case actForwardWord:
 			t.cx += findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
-		case C.AltD:
+		case actKillWord:
 			ncx := t.cx +
 				findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
 			if ncx > t.cx {
 				t.yanked = copySlice(t.input[t.cx:ncx])
 				t.input = append(t.input[:t.cx], t.input[ncx:]...)
 			}
-		case C.Rune:
+		case actKillLine:
+			if t.cx < len(t.input) {
+				t.yanked = copySlice(t.input[t.cx:])
+				t.input = t.input[:t.cx]
+			}
+		case actRune:
 			prefix := copySlice(t.input[:t.cx])
 			t.input = append(append(prefix, event.Char), t.input[t.cx:]...)
 			t.cx++
-		case C.Mouse:
+		case actMouse:
 			me := event.MouseEvent
 			mx, my := util.Constrain(me.X-len(t.prompt), 0, len(t.input)), me.Y
 			if !t.reverse {
 				my = C.MaxY() - my - 1
 			}
+			min := 2
+			if t.inlineInfo {
+				min = 1
+			}
 			if me.S != 0 {
 				// Scroll
 				if t.merger.Length() > 0 {
@@ -679,8 +817,8 @@ func (t *Terminal) Loop() {
 				}
 			} else if me.Double {
 				// Double-click
-				if my >= 2 {
+				if my >= min {
-					if t.vset(my-2) && t.cy < t.merger.Length() {
+					if t.vset(t.offset+my-min) && t.cy < t.merger.Length() {
 						req(reqClose)
 					}
 				}
@@ -688,9 +826,9 @@ func (t *Terminal) Loop() {
 				if my == 0 && mx >= 0 {
 					// Prompt
 					t.cx = mx
-				} else if my >= 2 {
+				} else if my >= min {
 					// List
-					if t.vset(t.offset+my-2) && t.multi && me.Mod {
+					if t.vset(t.offset+my-min) && t.multi && me.Mod {
 						toggle()
 					}
 					req(reqList)
@@ -701,7 +839,7 @@ func (t *Terminal) Loop() {
 		t.mutex.Unlock() // Must be unlocked before touching reqBox
 
 		if changed {
-			t.eventBox.Set(EvtSearchNew, false)
+			t.eventBox.Set(EvtSearchNew, t.sort)
 		}
 		for _, event := range events {
 			t.reqBox.Set(event, nil)
@@ -711,7 +849,7 @@ func (t *Terminal) Loop() {
 
 func (t *Terminal) constrain() {
 	count := t.merger.Length()
-	height := C.MaxY() - 2
+	height := t.maxItems()
 	diffpos := t.cy - t.offset
 
 	t.cy = util.Constrain(t.cy, 0, count-1)
@@ -744,6 +882,10 @@ func (t *Terminal) vset(o int) bool {
 	return t.cy == o
 }
 
-func maxItems() int {
+func (t *Terminal) maxItems() int {
-	return C.MaxY() - 2
+	if t.inlineInfo {
+		return C.MaxY() - 1
+	} else {
+		return C.MaxY() - 2
+	}
 }

src/tokenizer.go

@@ -16,15 +16,9 @@ type Range struct {
 	end   int
 }
 
-// Transformed holds the result of tokenization and transformation
-type Transformed struct {
-	whole *string
-	parts []Token
-}
-
 // Token contains the tokenized part of the strings and its prefix length
 type Token struct {
-	text         *string
+	text         *[]rune
 	prefixLength int
 }
 
@@ -81,8 +75,8 @@ func withPrefixLengths(tokens []string, begin int) []Token {
 	for idx, token := range tokens {
 		// Need to define a new local variable instead of the reused token to take
 		// the pointer to it
-		str := token
+		runes := []rune(token)
-		ret[idx] = Token{text: &str, prefixLength: prefixLength}
+		ret[idx] = Token{text: &runes, prefixLength: prefixLength}
 		prefixLength += len([]rune(token))
 	}
 	return ret
@@ -142,33 +136,40 @@ func Tokenize(str *string, delimiter *regexp.Regexp) []Token {
 	return withPrefixLengths(tokens, 0)
 }
 
-func joinTokens(tokens []Token) string {
+func joinTokens(tokens *[]Token) *string {
 	ret := ""
-	for _, token := range tokens {
+	for _, token := range *tokens {
-		ret += *token.text
+		ret += string(*token.text)
 	}
-	return ret
+	return &ret
+}
+
+func joinTokensAsRunes(tokens *[]Token) *[]rune {
+	ret := []rune{}
+	for _, token := range *tokens {
+		ret = append(ret, *token.text...)
+	}
+	return &ret
 }
 
 // Transform is used to transform the input when --with-nth option is given
-func Transform(tokens []Token, withNth []Range) *Transformed {
+func Transform(tokens []Token, withNth []Range) *[]Token {
 	transTokens := make([]Token, len(withNth))
 	numTokens := len(tokens)
-	whole := ""
 	for idx, r := range withNth {
-		part := ""
+		part := []rune{}
 		minIdx := 0
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				part += joinTokens(tokens)
+				part = append(part, *joinTokensAsRunes(&tokens)...)
 			} else {
 				if idx < 0 {
 					idx += numTokens + 1
 				}
 				if idx >= 1 && idx <= numTokens {
 					minIdx = idx - 1
-					part += *tokens[idx-1].text
+					part = append(part, *tokens[idx-1].text...)
 				}
 			}
 		} else {
@@ -195,11 +196,10 @@ func Transform(tokens []Token, withNth []Range) *Transformed {
 			minIdx = util.Max(0, begin-1)
 			for idx := begin; idx <= end; idx++ {
 				if idx >= 1 && idx <= numTokens {
-					part += *tokens[idx-1].text
+					part = append(part, *tokens[idx-1].text...)
 				}
 			}
 		}
-		whole += part
 		var prefixLength int
 		if minIdx < numTokens {
 			prefixLength = tokens[minIdx].prefixLength
@@ -208,7 +208,5 @@ func Transform(tokens []Token, withNth []Range) *Transformed {
 		}
 		transTokens[idx] = Token{&part, prefixLength}
 	}
-	return &Transformed{
+	return &transTokens
-		whole: &whole,
-		parts: transTokens}
 }

src/tokenizer_test.go

@@ -44,13 +44,13 @@ func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
 	tokens := Tokenize(&input, nil)
-	if *tokens[0].text != "abc:  " || tokens[0].prefixLength != 2 {
+	if string(*tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 {
 		t.Errorf("%s", tokens)
 	}
 
 	// With delimiter
 	tokens = Tokenize(&input, delimiterRegexp(":"))
-	if *tokens[0].text != "  abc:" || tokens[0].prefixLength != 0 {
+	if string(*tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 {
 		t.Errorf("%s", tokens)
 	}
 }
@@ -62,19 +62,19 @@ func TestTransform(t *testing.T) {
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
-			if *tx.whole != "abc:  def:  ghi:  " {
+			if *joinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", *tx)
 			}
 		}
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if *tx.whole != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
+			if *joinTokens(tx) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
-				len(tx.parts) != 4 ||
+				len(*tx) != 4 ||
-				*tx.parts[0].text != "abc:  def:  " || tx.parts[0].prefixLength != 2 ||
+				string(*(*tx)[0].text) != "abc:  def:  " || (*tx)[0].prefixLength != 2 ||
-				*tx.parts[1].text != "ghi:  " || tx.parts[1].prefixLength != 14 ||
+				string(*(*tx)[1].text) != "ghi:  " || (*tx)[1].prefixLength != 14 ||
-				*tx.parts[2].text != "def:  ghi:  jkl" || tx.parts[2].prefixLength != 8 ||
+				string(*(*tx)[2].text) != "def:  ghi:  jkl" || (*tx)[2].prefixLength != 8 ||
-				*tx.parts[3].text != "abc:  " || tx.parts[3].prefixLength != 2 {
+				string(*(*tx)[3].text) != "abc:  " || (*tx)[3].prefixLength != 2 {
 				t.Errorf("%s", *tx)
 			}
 		}
@@ -84,12 +84,12 @@ func TestTransform(t *testing.T) {
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if *tx.whole != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+			if *joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
-				len(tx.parts) != 4 ||
+				len(*tx) != 4 ||
-				*tx.parts[0].text != "  abc:  def:" || tx.parts[0].prefixLength != 0 ||
+				string(*(*tx)[0].text) != "  abc:  def:" || (*tx)[0].prefixLength != 0 ||
-				*tx.parts[1].text != "  ghi:" || tx.parts[1].prefixLength != 12 ||
+				string(*(*tx)[1].text) != "  ghi:" || (*tx)[1].prefixLength != 12 ||
-				*tx.parts[2].text != "  def:  ghi:  jkl" || tx.parts[2].prefixLength != 6 ||
+				string(*(*tx)[2].text) != "  def:  ghi:  jkl" || (*tx)[2].prefixLength != 6 ||
-				*tx.parts[3].text != "  abc:" || tx.parts[3].prefixLength != 0 {
+				string(*(*tx)[3].text) != "  abc:" || (*tx)[3].prefixLength != 0 {
 				t.Errorf("%s", *tx)
 			}
 		}

src/util/util.go

@@ -19,6 +19,14 @@ func Max(first int, items ...int) int {
 	return max
 }
 
+// Max32 returns the smallest 32-bit integer
+func Min32(first int32, second int32) int32 {
+	if first <= second {
+		return first
+	}
+	return second
+}
+
 // Max32 returns the largest 32-bit integer
 func Max32(first int32, second int32) int32 {
 	if first > second {
@@ -69,3 +77,14 @@ func Between(val int, min int, max int) bool {
 func IsTty() bool {
 	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
 }
+
+func TrimRight(runes *[]rune) []rune {
+	var i int
+	for i = len(*runes) - 1; i >= 0; i-- {
+		char := (*runes)[i]
+		if char != ' ' && char != '\t' {
+			break
+		}
+	}
+	return (*runes)[0 : i+1]
+}

test/fzf.vader

@@ -3,11 +3,14 @@ Execute (Setup):
   Log 'Test directory: ' . g:dir
 
 Execute (fzf#run with dir option):
+  let cwd = getcwd()
   let result = fzf#run({ 'options': '--filter=vdr', 'dir': g:dir })
   AssertEqual ['fzf.vader'], result
+  AssertEqual getcwd(), cwd
 
   let result = sort(fzf#run({ 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], result
+  AssertEqual ['fzf.vader', 'test_go.rb'], result
+  AssertEqual getcwd(), cwd
 
 Execute (fzf#run with Funcref command):
   let g:ret = []
@@ -15,8 +18,8 @@ Execute (fzf#run with Funcref command):
     call add(g:ret, a:e)
   endfunction
   let result = sort(fzf#run({ 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], result
+  AssertEqual ['fzf.vader', 'test_go.rb'], result
-  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], sort(g:ret)
+  AssertEqual ['fzf.vader', 'test_go.rb'], sort(g:ret)
 
 Execute (fzf#run with string source):
   let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))

test/test_go.rb

@@ -4,7 +4,11 @@
 require 'minitest/autorun'
 require 'fileutils'
 
-Dir.chdir File.expand_path('../../', __FILE__)
+DEFAULT_TIMEOUT = 20
+
+base = File.expand_path('../../', __FILE__)
+Dir.chdir base
+FZF = "#{base}/bin/fzf"
 
 class NilClass
   def include? str
@@ -20,25 +24,13 @@ class NilClass
   end
 end
 
-module Temp
+def wait
-  def readonce
+  since = Time.now
-    name = self.class::TEMPNAME
+  while Time.now - since < DEFAULT_TIMEOUT
-    waited = 0
+    return if yield
-    while waited < 5
+    sleep 0.05
-      begin
-        data = `cat #{name}`
-        return data unless data.empty?
-      rescue
-        sleep 0.1
-        waited += 0.1
-      end
-    end
-    raise "failed to read tempfile"
-  ensure
-    while File.exists? name
-      File.unlink name rescue nil
-    end
   end
+  throw 'timeout'
 end
 
 class Shell
@@ -56,8 +48,6 @@ class Shell
 end
 
 class Tmux
-  include Temp
-
   TEMPNAME = '/tmp/fzf-test.txt'
 
   attr_reader :win
@@ -87,8 +77,10 @@ class Tmux
   end
 
   def close
-    send_keys 'C-c', 'C-u', 'exit', :Enter
+    wait do
-    wait { closed? }
+      send_keys 'C-c', 'C-u', 'exit', :Enter
+      closed?
+    end
   end
 
   def kill
@@ -108,68 +100,54 @@ class Tmux
     go("send-keys -t #{target} #{args}")
   end
 
-  def capture opts = {}
+  def capture pane = 0
-    timeout, pane = defaults(opts).values_at(:timeout, :pane)
+    File.unlink TEMPNAME while File.exists? TEMPNAME
-    waited = 0
+    wait do
-    loop do
+      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME} 2> /dev/null")
-      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME}")
+      $?.exitstatus == 0
-      break if $?.exitstatus == 0
-
-      if waited > timeout
-        raise "Window not found"
-      end
-      waited += 0.1
-      sleep 0.1
     end
-    readonce.split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
+    File.read(TEMPNAME).split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
   end
 
-  def until opts = {}
+  def until pane = 0
     lines = nil
-    wait(opts) do
+    begin
-      yield lines = capture(opts)
+      wait do
+        lines = capture(pane)
+        class << lines
+          def item_count
+            self[-2] ? self[-2].strip.split('/').last.to_i : 0
+          end
+        end
+        yield lines
+      end
+    rescue Exception
+      puts $!.backtrace
+      puts '>' * 80
+      puts lines
+      puts '<' * 80
+      raise
     end
     lines
   end
 
   def prepare
-    self.send_keys 'echo hello', :Enter
+    tries = 0
-    self.until { |lines| lines[-1].start_with?('hello') }
+    begin
-    self.send_keys 'clear', :Enter
+      self.send_keys 'C-u', 'hello', 'Right'
-    self.until { |lines| lines.empty? }
+      self.until { |lines| lines[-1].end_with?('hello') }
+    rescue Exception
+      (tries += 1) < 5 ? retry : raise
+    end
+    self.send_keys 'C-u'
   end
 private
-  def defaults opts
-    { timeout: 10, pane: 0 }.merge(opts)
-  end
-
-  def wait opts = {}
-    timeout, pane = defaults(opts).values_at(:timeout, :pane)
-    waited = 0
-    until yield
-      if waited > timeout
-        hl = '=' * 10
-        puts hl
-        capture(opts).each_with_index do |line, idx|
-          puts [idx.to_s.rjust(2), line].join(': ')
-        end
-        puts hl
-        raise "timeout"
-      end
-      waited += 0.1
-      sleep 0.1
-    end
-  end
-
   def go *args
     %x[tmux #{args.join ' '}].split($/)
   end
 end
 
 class TestBase < Minitest::Test
-  include Temp
-
-  FIN = 'FIN'
   TEMPNAME = '/tmp/output'
 
   attr_reader :tmux
@@ -177,10 +155,18 @@ class TestBase < Minitest::Test
   def setup
     ENV.delete 'FZF_DEFAULT_OPTS'
     ENV.delete 'FZF_DEFAULT_COMMAND'
+    File.unlink TEMPNAME while File.exists?(TEMPNAME)
+  end
+
+  def readonce
+    wait { File.exists?(TEMPNAME) }
+    File.read(TEMPNAME)
+  ensure
+    File.unlink TEMPNAME while File.exists?(TEMPNAME)
   end
 
   def fzf(*opts)
-    fzf!(*opts) + " > #{TEMPNAME} && echo #{FIN}"
+    fzf!(*opts) + " > #{TEMPNAME}.tmp; mv #{TEMPNAME}.tmp #{TEMPNAME}"
   end
 
   def fzf!(*opts)
@@ -195,7 +181,7 @@ class TestBase < Minitest::Test
         nil
       end
     }.compact
-    "fzf #{opts.join ' '}"
+    "#{FZF} #{opts.join ' '}"
   end
 end
 
@@ -211,8 +197,7 @@ class TestGoFZF < TestBase
 
   def test_vanilla
     tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
-    tmux.until(timeout: 20) { |lines|
+    tmux.until { |lines| lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
-      lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
     lines = tmux.capture
     assert_equal '  2',             lines[-4]
     assert_equal '> 1',             lines[-3]
@@ -243,7 +228,7 @@ class TestGoFZF < TestBase
   end
 
   def test_key_bindings
-    tmux.send_keys "fzf -q 'foo bar foo-bar'", :Enter
+    tmux.send_keys "#{FZF} -q 'foo bar foo-bar'", :Enter
     tmux.until { |lines| lines.last =~ /^>/ }
 
     # CTRL-A
@@ -317,7 +302,6 @@ class TestGoFZF < TestBase
                    :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
     tmux.until { |lines| lines[-2].include? '(6)' }
     tmux.send_keys "C-M"
-    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal %w[3 2 5 6 8 7], readonce.split($/)
     tmux.close
   end
@@ -338,13 +322,11 @@ class TestGoFZF < TestBase
       # However, the output must not be transformed
       if multi
         tmux.send_keys :BTab, :BTab, :Enter
-        tmux.until { |lines| lines[-1].include?(FIN) }
         assert_equal ['  1st 2nd 3rd/', '  first second third/'], readonce.split($/)
       else
         tmux.send_keys '^', '3'
         tmux.until { |lines| lines[-2].include?('1/2') }
         tmux.send_keys :Enter
-        tmux.until { |lines| lines[-1].include?(FIN) }
         assert_equal ['  1st 2nd 3rd/'], readonce.split($/)
       end
     end
@@ -357,20 +339,17 @@ class TestGoFZF < TestBase
       tmux.send_keys *110.times.map { rev ? :Down : :Up }
       tmux.until { |lines| lines.include? '> 100' }
       tmux.send_keys :Enter
-      tmux.until { |lines| lines[-1].include?(FIN) }
       assert_equal '100', readonce.chomp
     end
   end
 
   def test_select_1
     tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 5555, :'1'}", :Enter
-    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['5555', '55'], readonce.split($/)
   end
 
   def test_exit_0
     tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 555555, :'0'}", :Enter
-    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['555555'], readonce.split($/)
   end
 
@@ -379,16 +358,14 @@ class TestGoFZF < TestBase
       tmux.send_keys "seq 1 100 | #{fzf :print_query, :multi, :q, 5, *opt}", :Enter
       tmux.until { |lines| lines.last =~ /^> 5/ }
       tmux.send_keys :BTab, :BTab, :BTab, :Enter
-      tmux.until { |lines| lines[-1].include?(FIN) }
       assert_equal ['5', '5', '15', '25'], readonce.split($/)
     end
   end
 
   def test_query_unicode
     tmux.send_keys "(echo abc; echo 가나다) | #{fzf :query, '가다'}", :Enter
-    tmux.until { |lines| lines.last.start_with? '>' }
+    tmux.until { |lines| lines[-2].include? '1/2' }
     tmux.send_keys :Enter
-    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['가나다'], readonce.split($/)
   end
 
@@ -422,6 +399,7 @@ class TestGoFZF < TestBase
     tmux.send_keys "seq 1 1000 | #{fzf :tac, :no_sort, :multi}", :Enter
     tmux.until { |lines| lines[-2].include? '1000/1000' }
     tmux.send_keys '00'
+    tmux.until { |lines| lines[-2].include? '10/1000' }
     tmux.send_keys :BTab, :BTab, :BTab, :Enter
     assert_equal %w[1000 900 800], readonce.split($/)
   end
@@ -431,6 +409,7 @@ class TestGoFZF < TestBase
       tmux.send_keys "seq 1 100 | #{fzf :expect, key}", :Enter
       tmux.until { |lines| lines[-2].include? '100/100' }
       tmux.send_keys '55'
+      tmux.until { |lines| lines[-2].include? '1/100' }
       tmux.send_keys *feed
       assert_equal [expected, '55'], readonce.split($/)
     end
@@ -449,6 +428,7 @@ class TestGoFZF < TestBase
     tmux.send_keys "seq 1 100 | #{fzf '--expect=alt-z', :print_query}", :Enter
     tmux.until { |lines| lines[-2].include? '100/100' }
     tmux.send_keys '55'
+    tmux.until { |lines| lines[-2].include? '1/100' }
     tmux.send_keys :Escape, :z
     assert_equal ['55', 'alt-z', '55'], readonce.split($/)
   end
@@ -459,16 +439,96 @@ class TestGoFZF < TestBase
   end
 
   def test_toggle_sort
-    tmux.send_keys "seq 1 111 | #{fzf '-m +s --tac --toggle-sort=ctrl-r -q11'}", :Enter
+    ['--toggle-sort=ctrl-r', '--bind=ctrl-r:toggle-sort'].each do |opt|
-    tmux.until { |lines| lines[-3].include? '> 111' }
+      tmux.send_keys "seq 1 111 | #{fzf "-m +s --tac #{opt} -q11"}", :Enter
-    tmux.send_keys :Tab
+      tmux.until { |lines| lines[-3].include? '> 111' }
-    tmux.until { |lines| lines[-2].include? '4/111 (1)' }
+      tmux.send_keys :Tab
-    tmux.send_keys 'C-R'
+      tmux.until { |lines| lines[-2].include? '4/111   (1)' }
-    tmux.until { |lines| lines[-3].include? '> 11' }
+      tmux.send_keys 'C-R'
-    tmux.send_keys :Tab
+      tmux.until { |lines| lines[-3].include? '> 11' }
-    tmux.until { |lines| lines[-2].include? '4/111 (2)' }
+      tmux.send_keys :Tab
+      tmux.until { |lines| lines[-2].include? '4/111/S (2)' }
+      tmux.send_keys :Enter
+      assert_equal ['111', '11'], readonce.split($/)
+    end
+  end
+
+  def test_unicode_case
+    tempname = TEMPNAME + Time.now.to_f.to_s
+    writelines tempname, %w[строКА1 СТРОКА2 строка3 Строка4]
+    assert_equal %w[СТРОКА2 Строка4], `cat #{tempname} | #{FZF} -fС`.split($/)
+    assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `cat #{tempname} | #{FZF} -fс`.split($/)
+  rescue
+    File.unlink tempname
+  end
+
+  def test_tiebreak
+    tempname = TEMPNAME + Time.now.to_f.to_s
+    input = %w[
+      --foobar--------
+      -----foobar---
+      ----foobar--
+      -------foobar-
+    ]
+    writelines tempname, input
+
+    assert_equal input, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=index`.split($/)
+
+    by_length = %w[
+      ----foobar--
+      -----foobar---
+      -------foobar-
+      --foobar--------
+    ]
+    assert_equal by_length, `cat #{tempname} | #{FZF} -ffoobar`.split($/)
+    assert_equal by_length, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=length`.split($/)
+
+    by_begin = %w[
+      --foobar--------
+      ----foobar--
+      -----foobar---
+      -------foobar-
+    ]
+    assert_equal by_begin, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=begin`.split($/)
+    assert_equal by_begin, `cat #{tempname} | #{FZF} -f"!z foobar" -x --tiebreak begin`.split($/)
+
+    assert_equal %w[
+      -------foobar-
+      ----foobar--
+      -----foobar---
+      --foobar--------
+    ], `cat #{tempname} | #{FZF} -ffoobar --tiebreak end`.split($/)
+
+    assert_equal input, `cat #{tempname} | #{FZF} -f"!z" -x --tiebreak end`.split($/)
+  rescue
+    File.unlink tempname
+  end
+
+  def test_invalid_cache
+    tmux.send_keys "(echo d; echo D; echo x) | #{fzf '-q d'}", :Enter
+    tmux.until { |lines| lines[-2].include? '2/3' }
+    tmux.send_keys :BSpace
+    tmux.until { |lines| lines[-2].include? '3/3' }
+    tmux.send_keys :D
+    tmux.until { |lines| lines[-2].include? '1/3' }
     tmux.send_keys :Enter
-    assert_equal ['111', '11'], readonce.split($/)
+  end
+
+  def test_smart_case_for_each_term
+    assert_equal 1, `echo Foo bar | #{FZF} -x -f "foo Fbar" | wc -l`.to_i
+  end
+
+  def test_bind
+    tmux.send_keys "seq 1 1000 | #{
+      fzf '-m --bind=ctrl-j:accept,u:up,T:toggle-up,t:toggle'}", :Enter
+    tmux.until { |lines| lines[-2].end_with? '/1000' }
+    tmux.send_keys 'uuu', 'TTT', 'tt', 'uu', 'ttt', 'C-j'
+    assert_equal %w[4 5 6 9], readonce.split($/)
+  end
+private
+  def writelines path, lines
+    File.unlink path while File.exists? path
+    File.open(path, 'w') { |f| f << lines.join($/) }
   end
 end
 
@@ -484,32 +544,31 @@ module TestShell
   def test_ctrl_t
     tmux.prepare
     tmux.send_keys 'C-t', pane: 0
-    lines = tmux.until(pane: 1) { |lines| lines[-1].start_with? '>' }
+    lines = tmux.until(1) { |lines| lines.item_count > 1 }
     expected = lines.values_at(-3, -4).map { |line| line[2..-1] }.join(' ')
     tmux.send_keys :BTab, :BTab, :Enter, pane: 1
-    tmux.until(pane: 0) { |lines| lines[-1].include? expected }
+    tmux.until(0) { |lines| lines[-1].include? expected }
     tmux.send_keys 'C-c'
 
     # FZF_TMUX=0
     new_shell
     tmux.send_keys 'C-t', pane: 0
-    lines = tmux.until(pane: 0) { |lines| lines[-1].start_with? '>' }
+    lines = tmux.until(0) { |lines| lines.item_count > 1 }
     expected = lines.values_at(-3, -4).map { |line| line[2..-1] }.join(' ')
     tmux.send_keys :BTab, :BTab, :Enter, pane: 0
-    tmux.until(pane: 0) { |lines| lines[-1].include? expected }
+    tmux.until(0) { |lines| lines[-1].include? expected }
     tmux.send_keys 'C-c', 'C-d'
   end
 
   def test_alt_c
     tmux.prepare
-    tmux.send_keys :Escape, :c
+    tmux.send_keys :Escape, :c, pane: 0
-    lines = tmux.until { |lines| lines[-1].start_with? '>' }
+    lines = tmux.until(1) { |lines| lines.item_count > 0 }
     expected = lines[-3][2..-1]
-    p expected
+    tmux.send_keys :Enter, pane: 1
-    tmux.send_keys :Enter
     tmux.prepare
     tmux.send_keys :pwd, :Enter
-    tmux.until { |lines| p lines; lines[-1].end_with?(expected) }
+    tmux.until { |lines| lines[-1].end_with?(expected) }
   end
 
   def test_ctrl_r
@@ -519,58 +578,93 @@ module TestShell
     tmux.send_keys 'echo 3d',  :Enter; tmux.prepare
     tmux.send_keys 'echo 3rd', :Enter; tmux.prepare
     tmux.send_keys 'echo 4th', :Enter; tmux.prepare
-    tmux.send_keys 'C-r'
+    tmux.send_keys 'C-r', pane: 0
-    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
-    tmux.send_keys '3d'
+    tmux.send_keys '3d', pane: 1
-    tmux.until { |lines| lines[-3].end_with? 'echo 3rd' } # --no-sort
+    tmux.until(1) { |lines| lines[-3].end_with? 'echo 3rd' } # --no-sort
-    tmux.send_keys :Enter
+    tmux.send_keys :Enter, pane: 1
     tmux.until { |lines| lines[-1] == 'echo 3rd' }
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1] == '3rd' }
   end
 end
 
-class TestBash < TestBase
+module CompletionTest
-  include TestShell
-
-  def new_shell
-    tmux.send_keys "FZF_TMUX=0 #{Shell.bash}", :Enter
-    tmux.prepare
-  end
-
-  def setup
-    super
-    @tmux = Tmux.new :bash
-  end
-
   def test_file_completion
-    tmux.send_keys 'mkdir -p /tmp/fzf-test; touch /tmp/fzf-test/{1..100}', :Enter
+    FileUtils.mkdir_p '/tmp/fzf-test'
+    FileUtils.mkdir_p '/tmp/fzf test'
+    (1..100).each { |i| FileUtils.touch "/tmp/fzf-test/#{i}" }
+    ['no~such~user', '/tmp/fzf test/foobar', '~/.fzf-home'].each do |f|
+      FileUtils.touch File.expand_path(f)
+    end
     tmux.prepare
-    tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab
+    tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab, pane: 0
-    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys :BTab, :BTab, :Enter
-    tmux.until { |lines|
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
       lines[-1].include?('/tmp/fzf-test/10') &&
       lines[-1].include?('/tmp/fzf-test/100')
-    }
+    end
+
+    # ~USERNAME**<TAB>
+    tmux.send_keys 'C-u'
+    tmux.send_keys "cat ~#{ENV['USER']}**", :Tab, pane: 0
+    tmux.until(1) { |lines| lines.item_count > 0 }
+    tmux.send_keys '.fzf-home'
+    tmux.until(1) { |lines| lines[-3].end_with? '.fzf-home' }
+    tmux.send_keys :Enter
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1].end_with?('.fzf-home')
+    end
+
+    # ~INVALID_USERNAME**<TAB>
+    tmux.send_keys 'C-u'
+    tmux.send_keys "cat ~such**", :Tab, pane: 0
+    tmux.until(1) { |lines| lines[-3].end_with? 'no~such~user' }
+    tmux.send_keys :Enter
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1].end_with?('no~such~user')
+    end
+
+    # /tmp/fzf\ test**<TAB>
+    tmux.send_keys 'C-u'
+    tmux.send_keys 'cat /tmp/fzf\ test/**', :Tab, pane: 0
+    tmux.until(1) { |lines| lines.item_count > 0 }
+    tmux.send_keys :Enter
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1].end_with?('/tmp/fzf\ test/foobar')
+    end
+  ensure
+    ['/tmp/fzf-test', '/tmp/fzf test', '~/.fzf-home', 'no~such~user'].each do |f|
+      FileUtils.rm_rf File.expand_path(f)
+    end
   end
 
   def test_dir_completion
     tmux.send_keys 'mkdir -p /tmp/fzf-test/d{1..100}; touch /tmp/fzf-test/d55/xxx', :Enter
     tmux.prepare
-    tmux.send_keys 'cd /tmp/fzf-test/**', :Tab
+    tmux.send_keys 'cd /tmp/fzf-test/**', :Tab, pane: 0
-    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys :BTab, :BTab # BTab does not work here
     tmux.send_keys 55
-    tmux.until { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
     tmux.send_keys :Enter
-    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' }
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1] == 'cd /tmp/fzf-test/d55/'
+    end
     tmux.send_keys :xx
     tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
 
-    # Should not match regular files
+    # Should not match regular files (bash-only)
-    tmux.send_keys :Tab
+    if self.class == TestBash
-    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
+      tmux.send_keys :Tab
+      tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
+    end
 
     # Fail back to plusdirs
     tmux.send_keys :BSpace, :BSpace, :BSpace
@@ -584,17 +678,38 @@ class TestBash < TestBase
     lines = tmux.until { |lines| lines[-1].start_with? '[1]' }
     pid = lines[-1].split.last
     tmux.prepare
-    tmux.send_keys 'kill ', :Tab
+    tmux.send_keys 'kill ', :Tab, pane: 0
-    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys 'sleep12345'
-    tmux.until { |lines| lines[-3].include? 'sleep 12345' }
+    tmux.until(1) { |lines| lines[-3].include? 'sleep 12345' }
     tmux.send_keys :Enter
-    tmux.until { |lines| lines[-1] == "kill #{pid}" }
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1] == "kill #{pid}"
+    end
+  ensure
+    Process.kill 'KILL', pid.to_i rescue nil if pid
+  end
+end
+
+class TestBash < TestBase
+  include TestShell
+  include CompletionTest
+
+  def new_shell
+    tmux.send_keys "FZF_TMUX=0 #{Shell.bash}", :Enter
+    tmux.prepare
+  end
+
+  def setup
+    super
+    @tmux = Tmux.new :bash
   end
 end
 
 class TestZsh < TestBase
   include TestShell
+  include CompletionTest
 
   def new_shell
     tmux.send_keys "FZF_TMUX=0 #{Shell.zsh}", :Enter