0.9.13

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

CHANGELOG.md

@@ -1,6 +1,30 @@
 CHANGELOG
 =========
 
+0.9.13
+------
+
+### New features
+
+- Color customization with the extended `--color` option
+
+### Bug fixes
+
+- Fixed premature termination of Reader in the presence of a long line which
+  is longer than 64KB
+
+0.9.12
+------
+
+### New features
+
+- Added `--bind` option for custom key bindings
+
+### Bug fixes
+
+- Fixed to update "inline-info" immediately after terminal resize
+- Fixed ANSI code offset calculation
+
 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.13
 
 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 "June 2015" "fzf 0.9.13" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -91,21 +91,38 @@ Enable processing of ANSI color codes
 .B "--no-mouse"
 Disable mouse
 .TP
-.B "--color=COL"
-Color scheme: [dark|light|16|bw]
-.br
-(default: dark on 256-color terminal, otherwise 16)
-.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
+.BI "--color=" "[BASE_SCHEME][,COLOR:ANSI]"
+Color configuration. The name of the base color scheme is followed by custom
+color mappings. Ansi color code of -1 denotes terminal default
+foreground/background color.
+
+.RS
+e.g. \fBfzf --color=bg+:24\fR
+     \fBfzf --color=light,fg:232,bg:255,bg+:116,info:27\fR
+.RE
+
+.RS
+.B BASE SCHEME:
+    (default: dark on 256-color terminal, otherwise 16)
+
+    \fBdark    \fRColor scheme for dark 256-color terminal
+    \fBlight   \fRColor scheme for light 256-color terminal
+    \fB16      \fRColor scheme for 16-color terminal
+    \fBbw      \fRNo colors
+
+.B COLOR:
+    \fBfg      \fRText
+    \fBbg      \fRBackground
+    \fBhl      \fRHighlighted substrings
+    \fBfg+     \fRText (current line)
+    \fBbg+     \fRBackground (current line)
+    \fBhl+     \fRHighlighted substrings (current line)
+    \fBinfo    \fRInfo
+    \fBprompt  \fRPrompt
+    \fBpointer \fRPointer to the current line
+    \fBmarker  \fRMulti-select marker
+    \fBspinner \fRStreaming input indicator
+.RE
 .TP
 .B "--black"
 Use black background
@@ -121,6 +138,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 +212,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.13"
 
 	// 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
@@ -96,15 +106,18 @@ const (
 )
 
 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
+	UseDefault   bool
+	Fg           int16
+	Bg           int16
+	DarkBg       int16
+	Prompt       int16
+	Match        int16
+	Current      int16
+	CurrentMatch int16
+	Spinner      int16
+	Info         int16
+	Cursor       int16
+	Selected     int16
 }
 
 type Event struct {
@@ -132,7 +145,10 @@ var (
 	Default16     *ColorTheme
 	Dark256       *ColorTheme
 	Light256      *ColorTheme
-	DarkBG        C.short
+	FG            int
+	CurrentFG     int
+	BG            int
+	DarkBG        int
 )
 
 func init() {
@@ -140,35 +156,44 @@ func init() {
 	_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}
+		UseDefault:   true,
+		Fg:           15,
+		Bg:           0,
+		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}
+		UseDefault:   true,
+		Fg:           15,
+		Bg:           0,
+		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}
+		UseDefault:   true,
+		Fg:           15,
+		Bg:           0,
+		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 {
@@ -258,23 +283,35 @@ func Init(theme *ColorTheme, black bool, mouse bool) {
 }
 
 func initPairs(theme *ColorTheme, black bool) {
-	var bg C.short
+	fg := C.short(theme.Fg)
+	bg := C.short(theme.Bg)
 	if black {
 		bg = C.COLOR_BLACK
-	} else {
-		C.use_default_colors()
+	} else if theme.UseDefault {
+		fg = -1
 		bg = -1
+		C.use_default_colors()
+	}
+	if theme.UseDefault {
+		FG = -1
+		BG = -1
+	} else {
+		FG = int(fg)
+		BG = int(bg)
+		C.assume_default_colors(C.int(theme.Fg), C.int(bg))
 	}
 
-	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)
+	CurrentFG = int(theme.Current)
+	DarkBG = int(theme.DarkBg)
+	darkBG := C.short(DarkBG)
+	C.init_pair(ColPrompt, C.short(theme.Prompt), bg)
+	C.init_pair(ColMatch, C.short(theme.Match), bg)
+	C.init_pair(ColCurrent, C.short(theme.Current), darkBG)
+	C.init_pair(ColCurrentMatch, C.short(theme.CurrentMatch), darkBG)
+	C.init_pair(ColSpinner, C.short(theme.Spinner), bg)
+	C.init_pair(ColInfo, C.short(theme.Info), bg)
+	C.init_pair(ColCursor, C.short(theme.Cursor), darkBG)
+	C.init_pair(ColSelected, C.short(theme.Selected), darkBG)
 }
 
 func Close() {
@@ -356,19 +393,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 +427,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 +435,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 +445,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/item.go

@@ -143,13 +143,25 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 					offset: Offset{int32(start), int32(idx)}, color: color, bold: bold})
 			} else {
 				ansi := item.colors[curr-1]
+				fg := ansi.color.fg
+				if fg == -1 {
+					if current {
+						fg = curses.CurrentFG
+					} else {
+						fg = curses.FG
+					}
+				}
 				bg := ansi.color.bg
-				if current && bg == -1 {
-					bg = int(curses.DarkBG)
+				if bg == -1 {
+					if current {
+						bg = curses.DarkBG
+					} else {
+						bg = curses.BG
+					}
 				}
 				offsets = append(offsets, colorOffset{
 					offset: Offset{int32(start), int32(idx)},
-					color:  curses.PairFor(ansi.color.fg, bg),
+					color:  curses.PairFor(fg, bg),
 					bold:   ansi.color.bold || bold})
 			}
 		}

src/options.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"regexp"
+	"strconv"
 	"strings"
 	"unicode/utf8"
 
@@ -35,13 +36,14 @@ const usage = `usage: fzf [options]
     -m, --multi           Enable multi-select with tab/shift-tab
         --ansi            Enable processing of ANSI color codes
         --no-mouse        Disable mouse
-        --color=COL       Color scheme; [dark|light|16|bw]
-                          (default: dark on 256-color terminal, otherwise 16)
+        --color=COLSPEC   Base scheme (dark|light|16|bw) and/or custom colors
         --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
@@ -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,21 +113,22 @@ 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
 }
 
-func defaultOptions() *Options {
-	var defaultTheme *curses.ColorTheme
+func defaultTheme() *curses.ColorTheme {
 	if strings.Contains(os.Getenv("TERM"), "256") {
-		defaultTheme = curses.Dark256
-	} else {
-		defaultTheme = curses.Default16
+		return curses.Dark256
 	}
+	return curses.Default16
+}
 
+func defaultOptions() *Options {
 	return &Options{
 		Mode:       ModeFuzzy,
 		Case:       CaseSmart,
@@ -139,7 +141,7 @@ func defaultOptions() *Options {
 		Multi:      false,
 		Ansi:       false,
 		Mouse:      true,
-		Theme:      defaultTheme,
+		Theme:      defaultTheme(),
 		Black:      false,
 		Reverse:    false,
 		Hscroll:    true,
@@ -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}
@@ -184,6 +187,14 @@ func nextString(args []string, i *int, message string) string {
 	return args[*i]
 }
 
+func optionalNextString(args []string, i *int) string {
+	if len(args) > *i+1 {
+		*i++
+		return args[*i]
+	}
+	return ""
+}
+
 func optionalNumeric(args []string, i *int) int {
 	if len(args) > *i+1 {
 		if strings.IndexAny(args[*i+1], "0123456789") == 0 {
@@ -274,28 +285,155 @@ func parseTiebreak(str string) tiebreak {
 	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 dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
+	dupe := *theme
+	return &dupe
 }
 
-func checkToggleSort(str string) int {
+func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme {
+	theme := dupeTheme(defaultTheme)
+	for _, str := range strings.Split(strings.ToLower(str), ",") {
+		switch str {
+		case "dark":
+			theme = dupeTheme(curses.Dark256)
+		case "light":
+			theme = dupeTheme(curses.Light256)
+		case "16":
+			theme = dupeTheme(curses.Default16)
+		case "bw", "no":
+			theme = nil
+		default:
+			fail := func() {
+				errorExit("invalid color specification: " + str)
+			}
+			// Color is disabled
+			if theme == nil {
+				errorExit("colors disabled; cannot customize colors")
+			}
+
+			pair := strings.Split(str, ":")
+			if len(pair) != 2 {
+				fail()
+			}
+			ansi32, err := strconv.Atoi(pair[1])
+			if err != nil || ansi32 < -1 || ansi32 > 255 {
+				fail()
+			}
+			ansi := int16(ansi32)
+			switch pair[0] {
+			case "fg":
+				theme.Fg = ansi
+				theme.UseDefault = theme.UseDefault && ansi < 0
+			case "bg":
+				theme.Bg = ansi
+				theme.UseDefault = theme.UseDefault && ansi < 0
+			case "fg+":
+				theme.Current = ansi
+			case "bg+":
+				theme.DarkBg = ansi
+			case "hl":
+				theme.Match = ansi
+			case "hl+":
+				theme.CurrentMatch = ansi
+			case "prompt":
+				theme.Prompt = ansi
+			case "spinner":
+				theme.Spinner = ansi
+			case "info":
+				theme.Info = ansi
+			case "pointer":
+				theme.Cursor = ansi
+			case "marker":
+				theme.Selected = ansi
+			default:
+				fail()
+			}
+		}
+	}
+	return theme
+}
+
+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 +457,18 @@ 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"))
+			spec := optionalNextString(allArgs, &i)
+			if len(spec) == 0 {
+				opts.Theme = defaultTheme()
+			} else {
+				opts.Theme = parseTheme(opts.Theme, spec)
+			}
 		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 +555,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)
+				opts.Theme = parseTheme(opts.Theme, 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,75 @@ 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])
+}
+
+func TestColorSpec(t *testing.T) {
+	theme := curses.Dark256
+	dark := parseTheme(theme, "dark")
+	if *dark != *theme {
+		t.Errorf("colors should be equivalent")
+	}
+	if dark == theme {
+		t.Errorf("point should not be equivalent")
+	}
+
+	light := parseTheme(theme, "dark,light")
+	if *light == *theme {
+		t.Errorf("should not be equivalent")
+	}
+	if *light != *curses.Light256 {
+		t.Errorf("colors should be equivalent")
+	}
+	if light == theme {
+		t.Errorf("point should not be equivalent")
+	}
+
+	customized := parseTheme(theme, "fg:231,bg:232")
+	if customized.Fg != 231 || customized.Bg != 232 {
+		t.Errorf("color not customized")
+	}
+	if *curses.Dark256 == *customized {
+		t.Errorf("colors should not be equivalent")
+	}
+	customized.Fg = curses.Dark256.Fg
+	customized.Bg = curses.Dark256.Bg
+	if *curses.Dark256 == *customized {
+		t.Errorf("colors should now be equivalent")
+	}
+
+	customized = parseTheme(theme, "fg:231,dark,bg:232")
+	if customized.Fg != curses.Dark256.Fg || customized.Bg == curses.Dark256.Bg {
+		t.Errorf("color not customized")
+	}
+	if customized.UseDefault {
+		t.Errorf("not using default colors")
+	}
+	if !curses.Dark256.UseDefault {
+		t.Errorf("using default colors")
+	}
+}

src/reader.go

@@ -30,9 +30,29 @@ func (r *Reader) ReadSource() {
 }
 
 func (r *Reader) feed(src io.Reader) {
-	if scanner := bufio.NewScanner(src); scanner != nil {
-		for scanner.Scan() {
-			r.pusher(scanner.Text())
+	reader := bufio.NewReader(src)
+	eof := false
+Loop:
+	for !eof {
+		buf := []byte{}
+		iter := 0 // TODO: max size?
+		for {
+			// "ReadLine either returns a non-nil line or it returns an error, never both"
+			line, isPrefix, err := reader.ReadLine()
+			eof = err == io.EOF
+			if eof {
+				break
+			} else if err != nil {
+				break Loop
+			}
+			iter++
+			buf = append(buf, line...)
+			if !isPrefix {
+				break
+			}
+		}
+		if iter > 0 {
+			r.pusher(string(buf))
 			r.eventBox.Set(EvtReadNew, nil)
 		}
 	}

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,28 @@ 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
+
+  def test_long_line
+    tempname = TEMPNAME + Time.now.to_f.to_s
+    data = '.' * 256 * 1024
+    File.open(tempname, 'w') do |f|
+      f << data
+    end
+    assert_equal data, `cat #{tempname} | #{FZF} -f .`.chomp
+  ensure
+    File.unlink tempname
+  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 +555,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 +590,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 +600,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 +671,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 +690,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