Fix ANSI offset calculation

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

CHANGELOG.md

@@ -1,6 +1,17 @@
 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
 ------
 

README.md

@@ -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
@@ -27,7 +27,7 @@ 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
@@ -173,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
 
@@ -294,7 +294,8 @@ of the selected items.
 | `dir`                      | string        | Working directory                                                |
 | `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
 | `window` (*Neovim only*)   | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
-| `launcher`                 | string        | External terminal emulator to start fzf with (Only used in GVim) |
+| `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._

bin/fzf-tmux

@@ -107,7 +107,7 @@ fail() {
 fzf="$(which fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [ -x "$fzf" ] || fail "fzf executable not found"
 
-envs=""
+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")"
 

fzf

@@ -206,10 +206,10 @@ class FZF
         @expect = true
       when /^--expect=(.*)$/
         @expect = true
-      when '--toggle-sort', '--tiebreak', '--color'
+      when '--toggle-sort', '--tiebreak', '--color', '--bind'
         argv.shift
       when '--tac', '--no-tac', '--sync', '--no-sync', '--hscroll', '--no-hscroll',
-           '--inline-info', '--no-inline-info',
+           '--inline-info', '--no-inline-info', /^--bind=(.*)$/,
            /^--color=(.*)$/, /^--toggle-sort=(.*)$/, /^--tiebreak=(.*)$/
         # XXX
       else

install

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-version=0.9.11
+version=0.9.12
 
 cd $(dirname $BASH_SOURCE)
 fzf_base=$(pwd)
@@ -176,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}\""
-  if [ $shell != bash -o $auto_completion -ne 0 ]; then
+  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
+  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 "April 2015" "fzf 0.9.11" "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
@@ -121,6 +121,51 @@ 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"
@@ -150,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

@@ -22,11 +22,9 @@
 " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 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:install = expand('<sfile>:h:h').'/install'
 let s:installed = 0
-let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
 let s:fzf_tmux = expand('<sfile>:h:h').'/bin/fzf-tmux'
 
 let s:cpo_save = &cpo
@@ -36,32 +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')
-      if !v:shell_error && !empty(path)
-        let s:exec = path[0]
-      elseif !s:installed && executable(s:install)
-        echohl WarningMsg
-        echo 'Downloading fzf binary. Please wait ...'
-        echohl None
-        let s:installed = 1
-        call system(s:install.' --bin')
-        return s:fzf_exec()
-      elseif executable(s:fzf_rb)
-        let s:exec = s:fzf_rb
-      else
-        call system('type fzf')
-        if v:shell_error
-          throw 'fzf executable not found'
-        else
-          let s:exec = 'fzf'
-        endif
-      endif
+      redraw
+      throw 'fzf executable not found'
     endif
-    return s:exec
-  else
-    return s:exec
   endif
+  return s:exec
 endfunction
 
 function! s:tmux_enabled()
@@ -86,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
@@ -202,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 command = printf(launcher, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
+    let Launcher = get(a:dict, 'launcher', get(g:, 'Fzf_launcher', get(g:, 'fzf_launcher', s:launcher)))
+    let fmt = type(Launcher) == 2 ? call(Launcher, []) : Launcher
+    let command = printf(fmt, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
   else
     let command = a:command
   endif
@@ -233,6 +236,7 @@ function! s:execute_tmux(dict, command, temps)
   endif
 
   call system(command)
+  redraw!
   return s:callback(a:dict, a:temps)
 endfunction
 
@@ -268,7 +272,7 @@ function! s:split(dict)
       tabnew
     endif
   finally
-    setlocal winfixwidth winfixheight
+    setlocal winfixwidth winfixheight buftype=nofile bufhidden=wipe nobuflisted
   endtry
 endfunction
 
@@ -279,12 +283,21 @@ function! s:execute_term(dict, command, temps)
   let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps }
   function! fzf.on_exit(id, code)
     let tab = tabpagenr()
-    execute 'bd!' self.buf
+    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)
@@ -298,6 +311,7 @@ function! s:execute_term(dict, command, temps)
 endfunction
 
 function! s:callback(dict, temps)
+try
   if !filereadable(a:temps.result)
     let lines = []
   else
@@ -321,6 +335,11 @@ function! s:callback(dict, temps)
   endfor
 
   return lines
+catch
+  if stridx(v:exception, ':E325:') < 0
+    echoerr v:exception
+  endif
+endtry
 endfunction
 
 let s:default_action = {

shell/completion.bash

@@ -29,13 +29,14 @@ _fzf_opts_completion() {
     +s --no-sort
     --tac
     --tiebreak
+    --bind
     -m --multi
     --no-mouse
-    +c --no-color
-    +2 --no-256
+    --color
     --black
     --reverse
     --no-hscroll
+    --inline-info
     --prompt
     -q --query
     -1 --select-1
@@ -51,6 +52,10 @@ _fzf_opts_completion() {
     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
@@ -83,7 +88,7 @@ _fzf_path_completion() {
   [ ${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}}
@@ -124,7 +129,7 @@ _fzf_list_completion() {
   [ ${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}}
@@ -179,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
 }
 
@@ -218,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

@@ -34,7 +34,11 @@ __fzf_cd__() {
 }
 
 __fzf_history__() {
-  HISTTIMEFORMAT= history | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r | sed "s/ *[0-9]* *//"
+  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
@@ -43,6 +47,7 @@ __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
@@ -52,13 +57,14 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u$(__fzf_history__)\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$(__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
@@ -70,7 +76,7 @@ else
   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$(__fzf_history__)\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

shell/key-bindings.fish

@@ -57,5 +57,11 @@ function fzf_key_bindings
   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

@@ -35,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 | $(__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')
-    LBUFFER=!$num
-    zle expand-history
+    num=$(echo "$selected" | head -n1 | awk '{print $1}' | sed 's/[^0-9]//g')
+    if [ -n "$num" ]; then
+      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/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/constants.go

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

src/core.go

@@ -47,10 +47,9 @@ 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
 

src/curses/curses.go

@@ -61,6 +61,16 @@ const (
 	PgUp
 	PgDn
 
+	Up
+	Down
+	Left
+	Right
+	Home
+	End
+
+	SLeft
+	SRight
+
 	F1
 	F2
 	F3
@@ -356,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:
@@ -390,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:
@@ -398,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}
@@ -408,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]

src/options.go

@@ -42,6 +42,8 @@ const usage = `usage: fzf [options]
         --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
@@ -50,7 +52,6 @@ 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
 
   Environment variables
@@ -112,8 +113,9 @@ type Options struct {
 	Select1    bool
 	Exit0      bool
 	Filter     *string
-	ToggleSort int
+	ToggleSort bool
 	Expect     []int
+	Keymap     map[int]actionType
 	PrintQuery bool
 	Sync       bool
 	Version    bool
@@ -149,8 +151,9 @@ func defaultOptions() *Options {
 		Select1:    false,
 		Exit0:      false,
 		Filter:     nil,
-		ToggleSort: 0,
+		ToggleSort: false,
 		Expect:     []int{},
+		Keymap:     defaultKeymap(),
 		PrintQuery: false,
 		Sync:       false,
 		Version:    false}
@@ -290,12 +293,87 @@ func parseTheme(str string) *curses.ColorTheme {
 	return nil
 }
 
-func checkToggleSort(str string) int {
+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) {
@@ -319,10 +397,13 @@ func parseOptions(opts *Options, allArgs []string) {
 			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":
@@ -409,13 +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/terminal.go

@@ -31,8 +31,9 @@ type Terminal struct {
 	input      []rune
 	multi      bool
 	sort       bool
-	toggleSort int
+	toggleSort bool
 	expect     []int
+	keymap     map[int]actionType
 	pressed    int
 	printQuery bool
 	count      int
@@ -80,6 +81,88 @@ const (
 	reqQuit
 )
 
+type actionType int
+
+const (
+	actIgnore actionType = iota
+	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)
@@ -97,6 +180,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		sort:       opts.Sort > 0,
 		toggleSort: opts.ToggleSort,
 		expect:     opts.Expect,
+		keymap:     opts.Keymap,
 		pressed:    0,
 		printQuery: opts.PrintQuery,
 		merger:     EmptyMerger,
@@ -249,7 +333,7 @@ func (t *Terminal) printInfo() {
 	}
 
 	output := fmt.Sprintf("%d/%d", t.merger.Length(), t.count)
-	if t.toggleSort > 0 {
+	if t.toggleSort {
 		if t.sort {
 			output += "/S"
 		} else {
@@ -436,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() {
@@ -601,105 +685,118 @@ func (t *Terminal) Loop() {
 				break
 			}
 		}
-		if t.toggleSort > 0 {
-			if keyMatch(t.toggleSort, event) {
-				t.sort = !t.sort
-				t.eventBox.Set(EvtSearchNew, t.sort)
-				t.mutex.Unlock()
-				continue
+
+		action := t.keymap[event.Type]
+		if event.Type == C.Rune {
+			code := int(event.Char) + int(C.AltZ)
+			if act, prs := t.keymap[code]; prs {
+				action = act
 			}
 		}
-		switch event.Type {
-		case C.Invalid:
+		switch action {
+		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:
-			t.delChar()
-		case C.PgUp:
+		case actPageUp:
 			t.vmove(t.maxItems() - 1)
 			req(reqList)
-		case C.PgDn:
+		case actPageDown:
 			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 {

test/test_go.rb

@@ -4,6 +4,8 @@
 require 'minitest/autorun'
 require 'fileutils'
 
+DEFAULT_TIMEOUT = 20
+
 base = File.expand_path('../../', __FILE__)
 Dir.chdir base
 FZF = "#{base}/bin/fzf"
@@ -22,26 +24,13 @@ class NilClass
   end
 end
 
-module Temp
-  def readonce
-    name = self.class::TEMPNAME
-    waited = 0
-    while waited < 5
-      begin
-        system 'sync'
-        data = File.read(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
+def wait
+  since = Time.now
+  while Time.now - since < DEFAULT_TIMEOUT
+    return if yield
+    sleep 0.05
   end
+  throw 'timeout'
 end
 
 class Shell
@@ -59,8 +48,6 @@ class Shell
 end
 
 class Tmux
-  include Temp
-
   TEMPNAME = '/tmp/fzf-test.txt'
 
   attr_reader :win
@@ -90,8 +77,10 @@ class Tmux
   end
 
   def close
-    send_keys 'C-c', 'C-u', 'exit', :Enter
-    wait { closed? }
+    wait do
+      send_keys 'C-c', 'C-u', 'exit', :Enter
+      closed?
+    end
   end
 
   def kill
@@ -111,68 +100,54 @@ class Tmux
     go("send-keys -t #{target} #{args}")
   end
 
-  def capture opts = {}
-    timeout, pane = defaults(opts).values_at(:timeout, :pane)
-    waited = 0
-    loop do
-      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME}")
-      break if $?.exitstatus == 0
-
-      if waited > timeout
-        raise "Window not found"
-      end
-      waited += 0.1
-      sleep 0.1
+  def capture pane = 0
+    File.unlink TEMPNAME while File.exists? TEMPNAME
+    wait do
+      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME} 2> /dev/null")
+      $?.exitstatus == 0
     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
-      yield lines = capture(opts)
+    begin
+      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
-    self.until { |lines| lines[-1].start_with?('hello') }
-    self.send_keys 'clear', :Enter
-    self.until { |lines| lines.empty? }
+    tries = 0
+    begin
+      self.send_keys 'C-u', 'hello', 'Right'
+      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
@@ -180,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)
@@ -214,8 +197,7 @@ class TestGoFZF < TestBase
 
   def test_vanilla
     tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
-    tmux.until(timeout: 20) { |lines|
-      lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
+    tmux.until { |lines| lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
     lines = tmux.capture
     assert_equal '  2',             lines[-4]
     assert_equal '> 1',             lines[-3]
@@ -320,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
@@ -341,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
@@ -360,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
 
@@ -382,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
 
@@ -425,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
@@ -434,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
@@ -452,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
@@ -462,16 +439,18 @@ class TestGoFZF < TestBase
   end
 
   def test_toggle_sort
-    tmux.send_keys "seq 1 111 | #{fzf '-m +s --tac --toggle-sort=ctrl-r -q11'}", :Enter
-    tmux.until { |lines| lines[-3].include? '> 111' }
-    tmux.send_keys :Tab
-    tmux.until { |lines| lines[-2].include? '4/111   (1)' }
-    tmux.send_keys 'C-R'
-    tmux.until { |lines| lines[-3].include? '> 11' }
-    tmux.send_keys :Tab
-    tmux.until { |lines| lines[-2].include? '4/111/S (2)' }
-    tmux.send_keys :Enter
-    assert_equal ['111', '11'], readonce.split($/)
+    ['--toggle-sort=ctrl-r', '--bind=ctrl-r:toggle-sort'].each do |opt|
+      tmux.send_keys "seq 1 111 | #{fzf "-m +s --tac #{opt} -q11"}", :Enter
+      tmux.until { |lines| lines[-3].include? '> 111' }
+      tmux.send_keys :Tab
+      tmux.until { |lines| lines[-2].include? '4/111   (1)' }
+      tmux.send_keys 'C-R'
+      tmux.until { |lines| lines[-3].include? '> 11' }
+      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
@@ -539,16 +518,17 @@ class TestGoFZF < TestBase
     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, timeout = 10
-    File.open(path, 'w') do |f|
-      f << lines.join($/)
-      f.sync
-    end
-    since = Time.now
-    while `cat #{path}`.split($/).length != lines.length && (Time.now - since) < 10
-      sleep 0.1
-    end
+  def writelines path, lines
+    File.unlink path while File.exists? path
+    File.open(path, 'w') { |f| f << lines.join($/) }
   end
 end
 
@@ -564,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, pane: 0
-    lines = tmux.until(pane: 1) { |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.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
@@ -600,9 +579,9 @@ module TestShell
     tmux.send_keys 'echo 3rd', :Enter; tmux.prepare
     tmux.send_keys 'echo 4th', :Enter; tmux.prepare
     tmux.send_keys 'C-r', pane: 0
-    tmux.until(pane: 1) { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys '3d', pane: 1
-    tmux.until(pane: 1) { |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, pane: 1
     tmux.until { |lines| lines[-1] == 'echo 3rd' }
     tmux.send_keys :Enter
@@ -610,40 +589,69 @@ module TestShell
   end
 end
 
-class TestBash < TestBase
-  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
-
+module CompletionTest
   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, pane: 0
-    tmux.until(pane: 1) { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys :BTab, :BTab, :Enter
     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, pane: 0
-    tmux.until(pane: 1) { |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(pane: 1) { |lines| lines[-2].start_with? '  1/' }
+    tmux.until(1) { |lines| lines[-2].start_with? '  1/' }
     tmux.send_keys :Enter
     tmux.until do |lines|
       tmux.send_keys 'C-L'
@@ -652,9 +660,11 @@ class TestBash < TestBase
     tmux.send_keys :xx
     tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
 
-    # Should not match regular files
-    tmux.send_keys :Tab
-    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
+    # Should not match regular files (bash-only)
+    if self.class == TestBash
+      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
@@ -669,19 +679,37 @@ class TestBash < TestBase
     pid = lines[-1].split.last
     tmux.prepare
     tmux.send_keys 'kill ', :Tab, pane: 0
-    tmux.until(pane: 1) { |lines| lines[-1].start_with? '>' }
+    tmux.until(1) { |lines| lines.item_count > 0 }
     tmux.send_keys 'sleep12345'
-    tmux.until(pane: 1) { |lines| lines[-3].include? 'sleep 12345' }
+    tmux.until(1) { |lines| lines[-3].include? 'sleep 12345' }
     tmux.send_keys :Enter
     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