0.12.0

Based on the patch by Matt Westcott (@mjwestcott).
But with a more conservative approach:
- Does not use linearly increasing penalties; It is agreed upon that we
  should prefer matching characters at the beginnings of the words, but
  it's not always clear that the relevance is inversely proportional to
  the distance from the beginning.
- The approach here is more conservative in that the bonus is never
  large enough to override the matchlen, so it can be thought of as the
  first implicit tiebreak criterion.
- One may argue the change breaks the contract of --tiebreak, but the
  judgement depends on the definition of "tie".

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,29 @@
+<!-- Check all that apply [x] -->
+- Category
+    - [ ] fzf binary
+    - [ ] fzf-tmux script
+    - [ ] Key bindings
+    - [ ] Completion
+    - [ ] Vim
+    - [ ] Neovim
+    - [ ] Etc.
+- OS
+    - [ ] Linux
+    - [ ] Mac OS X
+    - [ ] Windows
+    - [ ] Etc.
+- Shell
+    - [ ] bash
+    - [ ] zsh
+    - [ ] fish
+
+<!--
+### Before submitting
+
+- Make sure that you have the latest version of fzf
+- If you use tmux, make sure $TERM is set to screen or screen-256color
+- For more Vim stuff, check out https://github.com/junegunn/fzf.vim
+
+Describe your problem or suggestion from here ...
+-->
+

.gitignore

@@ -1,5 +1,6 @@
 bin
-src/fzf/fzf_*
+src/fzf/fzf-*
+gopath
 pkg
 Gemfile.lock
 .DS_Store

CHANGELOG.md

@@ -1,6 +1,28 @@
 CHANGELOG
 =========
 
+0.12.0
+------
+
+- Enhanced ranking algorithm
+- Minor bug fixes
+
+0.11.4
+------
+
+- Added `--hscroll-off=COL` option (default: 10) (#513)
+- Some fixes in Vim plugin and shell extensions
+
+0.11.3
+------
+
+- Graceful exit on SIGTERM (#482)
+- `$SHELL` instead of `sh` for `execute` action and `$FZF_DEFAULT_COMMAND` (#481)
+- Changes in fuzzy completion API
+    - [`_fzf_compgen_{path,dir}`](https://github.com/junegunn/fzf/commit/9617647)
+    - [`_fzf_complete_COMMAND_post`](https://github.com/junegunn/fzf/commit/8206746)
+      for post-processing
+
 0.11.2
 ------
 

README.md

@@ -21,7 +21,7 @@ Pros
 Installation
 ------------
 
-fzf project consists of the followings:
+fzf project consists of the following:
 
 - `fzf` executable
 - `fzf-tmux` script for launching fzf in a tmux pane
@@ -259,6 +259,14 @@ export FZF_COMPLETION_TRIGGER='~~'
 
 # Options to fzf command
 export FZF_COMPLETION_OPTS='+c -x'
+
+# Use ag instead of the default find command for listing candidates.
+# - The first argument to the function is the base path to start traversal
+# - Note that ag only lists files not directories
+# - See the source code (completion.{bash,zsh}) for the details.
+_fzf_compgen_path() {
+  ag -g "" "$1"
+}
 ```
 
 #### Supported commands
@@ -335,7 +343,7 @@ Tips
 
 #### Rendering issues
 
-If you have any rendering issues, check the followings:
+If you have any rendering issues, check the following:
 
 1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
    contains `256` (e.g. `xterm-256color`)

bin/fzf-tmux

@@ -140,15 +140,17 @@ done
 
 if [ -n "$term" -o -t 0 ]; then
   cat <<< "$fzf $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option -q synchronize-panes off \;\
+  tmux set-window-option synchronize-panes off \;\
-    set-window-option -q remain-on-exit off \;\
+    set-window-option remain-on-exit off \;\
-    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap
+    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap \
+    > /dev/null 2>&1
 else
   mkfifo $fifo1
   cat <<< "$fzf $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option -q synchronize-panes off \;\
+  tmux set-window-option synchronize-panes off \;\
-    set-window-option -q remain-on-exit off \;\
+    set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash $argsf" $swap
+    split-window $opt "$envs bash $argsf" $swap \
+    > /dev/null 2>&1
   cat <&0 > $fifo1 &
 fi
 cat $fifo2

install

@@ -2,12 +2,12 @@
 
 set -u
 
-[[ "$@" =~ --pre ]] && version=0.11.2 pre=1 ||
+[[ "$@" =~ --pre ]] && version=0.12.0 pre=1 ||
-                       version=0.11.2 pre=0
+                       version=0.12.0 pre=0
 
 auto_completion=
 key_bindings=
-update_config=1
+update_config=2
 binary_arch=
 
 help() {
@@ -27,7 +27,7 @@ usage: $0 [OPTIONS]
 EOF
 }
 
-for opt in $@; do
+for opt in "$@"; do
   case $opt in
     --help)
       help
@@ -46,7 +46,7 @@ for opt in $@; do
     --no-update-rc)    update_config=0   ;;
     --32)              binary_arch=386   ;;
     --64)              binary_arch=amd64 ;;
-    --bin)             ;;
+    --bin|--pre)       ;;
     *)
       echo "unknown option: $opt"
       help
@@ -55,17 +55,14 @@ for opt in $@; do
   esac
 done
 
-cd $(dirname $BASH_SOURCE)
+cd "$(dirname "${BASH_SOURCE[0]}")"
 fzf_base="$(pwd)"
 
-# If stdin is a tty, we are "interactive".
-interactive=
-[ -t 0 ] && interactive=yes
-
 ask() {
+  # If stdin is a tty, we are "interactive".
   # non-interactive shell: wait for a linefeed
   #     interactive shell: continue after a single keypress
-  [ -n "$interactive" ] && read_n='-n 1' || read_n=
+  read_n=$([ -t 0 ] && echo "-n 1")
 
   read -p "$1 ([y]/n) " $read_n -r
   echo
@@ -102,6 +99,16 @@ symlink() {
   fi
 }
 
+link_fzf_in_path() {
+  if which_fzf="$(command -v fzf)"; then
+    echo "  - Found in \$PATH"
+    echo "  - Creating symlink: $which_fzf -> bin/fzf"
+    (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
+    check_binary && return
+  fi
+  return 1
+}
+
 download() {
   echo "Downloading bin/fzf ..."
   if [ $pre = 0 ]; then
@@ -112,12 +119,7 @@ download() {
     if [ -x "$fzf_base"/bin/$1 ]; then
       symlink $1 && check_binary && return
     fi
-    if which_fzf="$(which fzf 2> /dev/null)"; then
+    link_fzf_in_path && return
-      echo "  - Found in \$PATH"
-      echo "  - Creating symlink: $which_fzf -> bin/fzf"
-      (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
-      check_binary && return
-    fi
   fi
   mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
   if [ $? -ne 0 ]; then
@@ -126,9 +128,9 @@ download() {
   fi
 
   local url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}.tgz
-  if which curl > /dev/null; then
+  if command -v curl > /dev/null; then
     curl -fL $url | tar -xz
-  elif which wget > /dev/null; then
+  elif command -v wget > /dev/null; then
     wget -O - $url | tar -xz
   else
     binary_error="curl or wget not found"
@@ -155,19 +157,12 @@ case "$archi" in
   *)              binary_available=0 binary_error=1  ;;
 esac
 
-cd "$fzf_base"
+install_ruby_fzf() {
-if [ -n "$binary_error" ]; then
-  if [ $binary_available -eq 0 ]; then
-    echo "No prebuilt binary for $archi ... "
-  else
-    echo "  - $binary_error !!!"
-    exit 1
-  fi
   echo "Installing legacy Ruby version ..."
 
   # ruby executable
   echo -n "Checking Ruby executable ... "
-  ruby=`which ruby`
+  ruby=$(command -v ruby)
   if [ $? -ne 0 ]; then
     echo "ruby executable not found !!!"
     exit 1
@@ -175,7 +170,7 @@ if [ -n "$binary_error" ]; then
 
   # System ruby is preferred
   system_ruby=/usr/bin/ruby
-  if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
+  if [ -x $system_ruby ] && [ $system_ruby != "$ruby" ]; then
     $system_ruby --disable-gems -rcurses -e0 2> /dev/null
     [ $? -eq 0 ] && ruby=$system_ruby
   fi
@@ -228,6 +223,29 @@ if [ -n "$binary_error" ]; then
   echo "$fzf_cmd \"\$@\"" >> "$fzf_base"/bin/fzf
   chmod +x "$fzf_base"/bin/fzf
   echo "OK"
+}
+
+cd "$fzf_base"
+if [ -n "$binary_error" ]; then
+  if [ $binary_available -eq 0 ]; then
+    echo "No prebuilt binary for $archi ..."
+    if command -v go > /dev/null; then
+      echo -n "Building binary (go get github.com/junegunn/fzf/src/fzf) ... "
+      if go get github.com/junegunn/fzf/src/fzf; then
+        echo "OK"
+        link_fzf_in_path
+      else
+        echo "Failed to build binary ..."
+        install_ruby_fzf
+      fi
+    else
+      echo "go executable not found. Cannot build binary ..."
+      install_ruby_fzf
+    fi
+  else
+    echo "  - $binary_error !!!"
+    exit 1
+  fi
 fi
 
 [[ "$*" =~ "--bin" ]] && exit 0
@@ -245,7 +263,9 @@ if [ -z "$key_bindings" ]; then
 fi
 
 echo
-for shell in bash zsh; do
+has_zsh=$(command -v zsh > /dev/null && echo 1 || echo 0)
+shells=$([ $has_zsh -eq 1 ] && echo "bash zsh" || echo "bash")
+for shell in $shells; do
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
@@ -285,9 +305,8 @@ EOF
 done
 
 # fish
-has_fish=0
+has_fish=$(command -v fish > /dev/null && echo 1 || echo 0)
-if [ -n "$(which fish 2> /dev/null)" ]; then
+if [ $has_fish -eq 1 ]; then
-  has_fish=1
   echo -n "Update fish_user_paths ... "
   fish << EOF
   echo \$fish_user_paths | grep $fzf_base/bin > /dev/null
@@ -316,8 +335,8 @@ fi
 append_line() {
   set -e
 
-  local skip line file pat lno
+  local update line file pat lno
-  skip="$1"
+  update="$1"
   line="$2"
   file="$3"
   pat="${4:-}"
@@ -333,7 +352,7 @@ append_line() {
   if [ -n "$lno" ]; then
     echo "    - Already exists: line #$lno"
   else
-    if [ $skip -eq 1 ]; then
+    if [ $update -eq 1 ]; then
       echo >> "$file"
       echo "$line" >> "$file"
       echo "    + Added"
@@ -345,26 +364,30 @@ append_line() {
   set +e
 }
 
+if [ $update_config -eq 2 ]; then
+  echo
+  ask "Do you want to update your shell configuration files?"
+  update_config=$?
+fi
 echo
-for shell in bash zsh; do
+for shell in $shells; do
   [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
   append_line $update_config "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" "$dest" "~/.fzf.${shell}"
 done
 
-if [ $key_bindings -eq 1 -a $has_fish -eq 1 ]; then
+if [ $key_bindings -eq 1 ] && [ $has_fish -eq 1 ]; then
   bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
   append_line $update_config "fzf_key_bindings" "$bind_file"
 fi
 
-cat << EOF
+if [ $update_config -eq 1 ]; then
-Finished. Restart your shell or reload config file.
+  echo 'Finished. Restart your shell or reload config file.'
-   source ~/.bashrc  # bash
+  echo '   source ~/.bashrc  # bash'
-   source ${ZDOTDIR:-~}/.zshrc   # zsh
+  [ $has_zsh  -eq 1 ] && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
-EOF
+  [ $has_fish -eq 1 ] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
-[ $has_fish -eq 1 ] && echo "   fzf_key_bindings  # fish"; cat << EOF
+  echo
-
+  echo 'Use uninstall script to remove fzf.'
-Use uninstall script to remove fzf.
+  echo
-
+fi
-For more information, see: https://github.com/junegunn/fzf
+echo 'For more information, see: https://github.com/junegunn/fzf'
-EOF
 

man/man1/fzf.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Jan 2016" "fzf 0.11.2" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Apr 2016" "fzf 0.12.0" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -71,7 +71,7 @@ e.g. \fBhistory | fzf --tac --no-sort\fR
 .BI "--tiebreak=" "CRI[,..]"
 Comma-separated list of sort criteria to apply when the scores are tied.
 .br
-.R ""
+
 .br
 .BR length "  Prefers item with shorter length"
 .br
@@ -81,7 +81,7 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .br
 .BR index "   Prefers item that appeared earlier in the input stream"
 .br
-.R ""
+
 .br
 - Each criterion should appear only once in the list
 .br
@@ -144,7 +144,7 @@ Reverse orientation
 .BI "--margin=" MARGIN
 Comma-separated expression for margins around the finder.
 .br
-.R ""
+
 .br
 .RS
 .BR TRBL "     Same margin for top, right, bottom, and left"
@@ -155,12 +155,12 @@ Comma-separated expression for margins around the finder.
 .br
 .BR T,R,B,L "  Top, right, bottom, left margin"
 .br
-.R ""
+
 .br
 Each part can be given in absolute number or in percentage relative to the
 terminal size with \fB%\fR suffix.
 .br
-.R ""
+
 .br
 e.g. \fBfzf --margin 10%\fR
      \fBfzf --margin 1,5%\fR
@@ -175,6 +175,11 @@ Enable cyclic scroll
 .B "--no-hscroll"
 Disable horizontal scroll
 .TP
+.BI "--hscroll-off=" "COL"
+Number of screen columns to keep to the right of the highlighted substring
+(default: 10). Setting it to a large value will cause the text to be positioned
+on the center of the screen.
+.TP
 .B "--inline-info"
 Display finder info inline with the query
 .TP
@@ -364,7 +369,11 @@ Default options. e.g. \fBexport FZF_DEFAULT_OPTS="--extended --cycle"\fR
 .SH EXIT STATUS
 .BR 0 "      Normal exit"
 .br
-.BR 1 "      Interrupted with \fBCTRL-C\fR or \fBESC\fR"
+.BR 1 "      No match"
+.br
+.BR 2 "      Error"
+.br
+.BR 130 "    Interrupted with \fBCTRL-C\fR or \fBESC\fR"
 
 .SH FIELD INDEX EXPRESSION
 
@@ -431,7 +440,7 @@ Junegunn Choi (\fIjunegunn.c@gmail.com\fR)
 .I https://github.com/junegunn/fzf
 .RE
 .br
-.R ""
+
 .br
 .B Extra Vim plugin:
 .RS

plugin/fzf.vim

@@ -74,7 +74,7 @@ function! s:shellesc(arg)
 endfunction
 
 function! s:escape(path)
-  return escape(a:path, ' %#''"\')
+  return escape(a:path, ' $%#''"\')
 endfunction
 
 " Upgrade legacy options
@@ -239,7 +239,7 @@ function! s:exit_handler(code, command, ...)
   return 1
 endfunction
 
-function! s:execute(dict, command, temps)
+function! s:execute(dict, command, temps) abort
   call s:pushd(a:dict)
   silent! !clear 2> /dev/null
   let escaped = escape(substitute(a:command, '\n', '\\n', 'g'), '%#')
@@ -255,7 +255,7 @@ function! s:execute(dict, command, temps)
   return s:exit_handler(v:shell_error, command) ? s:callback(a:dict, a:temps) : []
 endfunction
 
-function! s:execute_tmux(dict, command, temps)
+function! s:execute_tmux(dict, command, temps) abort
   let command = a:command
   if s:pushd(a:dict)
     " -c '#{pane_current_path}' is only available on tmux 1.9 or above
@@ -285,7 +285,7 @@ function! s:calc_size(max, val, dict)
 endfunction
 
 function! s:getpos()
-  return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$')}
+  return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
 endfunction
 
 function! s:split(dict)
@@ -313,14 +313,14 @@ function! s:split(dict)
     if s:present(a:dict, 'window')
       execute a:dict.window
     else
-      tabnew
+      execute (tabpagenr()-1).'tabnew'
     endif
   finally
     setlocal winfixwidth winfixheight buftype=nofile bufhidden=wipe nobuflisted
   endtry
 endfunction
 
-function! s:execute_term(dict, command, temps)
+function! s:execute_term(dict, command, temps) abort
   call s:split(a:dict)
 
   let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps, 'name': 'FZF' }
@@ -344,6 +344,7 @@ function! s:execute_term(dict, command, temps)
     endif
 
     call s:pushd(self.dict)
+    let ret = []
     try
       let ret = s:callback(self.dict, self.temps)
 
@@ -368,11 +369,10 @@ function! s:execute_term(dict, command, temps)
   return []
 endfunction
 
-function! s:callback(dict, temps)
+function! s:callback(dict, temps) abort
+let lines = []
 try
-  if !filereadable(a:temps.result)
+  if filereadable(a:temps.result)
-    let lines = []
-  else
     let lines = readfile(a:temps.result)
     if has_key(a:dict, 'sink')
       for line in lines
@@ -391,12 +391,12 @@ try
   for tf in values(a:temps)
     silent! call delete(tf)
   endfor
-
-  return lines
 catch
   if stridx(v:exception, ':E325:') < 0
     echoerr v:exception
   endif
+finally
+  return lines
 endtry
 endfunction
 

shell/completion.bash

@@ -10,6 +10,26 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+if ! declare -f _fzf_compgen_path > /dev/null; then
+  _fzf_compgen_path() {
+    echo "$1"
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+###########################################################
+
 _fzf_orig_completion_filter() {
   sed 's/^\(.*-F\) *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\3="\1 %s \3 #\2";/' |
   awk -F= '{gsub(/[^a-z0-9_= ;]/, "_", $1); print $1"="$2}'
@@ -55,11 +75,11 @@ _fzf_opts_completion() {
 
   case "${prev}" in
   --tiebreak)
-    COMPREPLY=( $(compgen -W "length begin end index" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "length begin end index" -- "$cur") )
     return 0
     ;;
   --color)
-    COMPREPLY=( $(compgen -W "dark light 16 bw" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "dark light 16 bw" -- "$cur") )
     return 0
     ;;
   --history)
@@ -68,8 +88,8 @@ _fzf_opts_completion() {
     ;;
   esac
 
-  if [[ ${cur} =~ ^-|\+ ]]; then
+  if [[ "$cur" =~ ^-|\+ ]]; then
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "${opts}" -- "$cur") )
     return 0
   fi
 
@@ -88,32 +108,32 @@ _fzf_handle_dynamic_completion() {
   elif [ -n "$_fzf_completion_loader" ]; then
     _completion_loader "$@"
     ret=$?
-    eval $(complete | \grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)
+    eval "$(complete | \grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)"
-    source $BASH_SOURCE
+    source "${BASH_SOURCE[0]}"
     return $ret
   fi
 }
 
 __fzf_generic_path_completion() {
   local cur base dir leftover matches trigger cmd fzf
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
+  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]]; then
     base=${cur:0:${#cur}-${#trigger}}
-    eval base=$base
+    eval "base=$base"
 
     dir="$base"
-    while [ 1 ]; do
+    while true; do
-      if [ -z "$dir" -o -d "$dir" ]; then
+      if [ -z "$dir" ] || [ -d "$dir" ]; then
         leftover=${base/#"$dir"}
         leftover=${leftover/#\/}
         [ -z "$dir" ] && dir='.'
         [ "$dir" != "/" ] && dir="${dir/%\//}"
         tput sc
-        matches=$(\find -L "$dir" $1 -a -not -path "$dir" -print 2> /dev/null | sed 's@^\./@@' | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+        matches=$(eval "$1 $(printf %q "$dir")" | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read -r item; do
           printf "%q$3 " "$item"
         done)
         matches=${matches% }
@@ -136,29 +156,22 @@ __fzf_generic_path_completion() {
   fi
 }
 
-_fzf_feed_fifo() (
-  rm -f "$fifo"
-  mkfifo "$fifo"
-  cat <&0 > "$fifo" &
-)
-
 _fzf_complete() {
-  local fifo cur selected trigger cmd fzf
+  local cur selected trigger cmd fzf post
-  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
+  post="$(caller 0 | awk '{print $2}')_post"
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  type -t "$post" > /dev/null 2>&1 || post=cat
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
-  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
+  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
-    _fzf_feed_fifo "$fifo"
     tput sc
-    selected=$(eval "cat '$fifo' | $fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
+    selected=$(cat | $fzf $FZF_COMPLETION_OPTS $1 -q "$cur" | $post | tr '\n' ' ')
     selected=${selected% } # Strip trailing space not to repeat "-o nospace"
     tput rc
-    rm -f "$fifo"
 
     if [ -n "$selected" ]; then
       COMPREPLY=("$selected")
@@ -171,28 +184,23 @@ _fzf_complete() {
 }
 
 _fzf_path_completion() {
-  __fzf_generic_path_completion \
+  __fzf_generic_path_completion _fzf_compgen_path "-m" "" "$@"
-    "-name .git -prune -o -name .svn -prune -o ( -type d -o -type f -o -type l )" \
-    "-m" "" "$@"
 }
 
+# Deprecated. No file only completion.
 _fzf_file_completion() {
-  __fzf_generic_path_completion \
+  _fzf_path_completion "$@"
-    "-name .git -prune -o -name .svn -prune -o ( -type f -o -type l )" \
-    "-m" "" "$@"
 }
 
 _fzf_dir_completion() {
-  __fzf_generic_path_completion \
+  __fzf_generic_path_completion _fzf_compgen_dir "" "/" "$@"
-    "-name .git -prune -o -name .svn -prune -o -type d" \
-    "" "/" "$@"
 }
 
 _fzf_complete_kill() {
   [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
 
   local selected fzf
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
   tput sc
   selected=$(ps -ef | sed 1d | $fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
   tput rc
@@ -239,13 +247,12 @@ _fzf_complete_unalias() {
 # fzf options
 complete -o default -F _fzf_opts_completion fzf
 
-d_cmds="cd pushd rmdir"
+d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
-f_cmds="
+a_cmds="
   awk cat diff diff3
   emacs emacsclient ex file ftp g++ gcc gvim head hg java
   javac ld less more mvim nvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc xdg-open"
+  sed sftp sort source tail tee uniq vi view vim wc xdg-open
-a_cmds="
   basename bunzip2 bzip2 chmod chown curl cp dirname du
   find git grep gunzip gzip hg jar
   ln ls mv open rm rsync scp
@@ -253,11 +260,11 @@ a_cmds="
 x_cmds="kill ssh telnet unset unalias export"
 
 # Preserve existing completion
-if [ "$_fzf_completion_loaded" != '0.10.8' ]; then
+if [ "$_fzf_completion_loaded" != '0.11.3' ]; 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)
+    \grep -E " ($(echo $d_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
-  export _fzf_completion_loaded=0.10.8
+  export _fzf_completion_loaded=0.11.3
 fi
 
 if type _completion_loader > /dev/null 2>&1; then
@@ -278,21 +285,16 @@ _fzf_defc() {
   fi
 }
 
-# Directory
-for cmd in $d_cmds; do
-  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
-done
-
-# File
-for cmd in $f_cmds; do
-  _fzf_defc "$cmd" _fzf_file_completion "-o default -o bashdefault"
-done
-
 # Anything
 for cmd in $a_cmds; do
   _fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
 done
 
+# Directory
+for cmd in $d_cmds; do
+  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
+done
+
 unset _fzf_defc
 
 # Kill completion
@@ -307,4 +309,4 @@ complete -F _fzf_complete_unset -o default -o bashdefault unset
 complete -F _fzf_complete_export -o default -o bashdefault export
 complete -F _fzf_complete_unalias -o default -o bashdefault unalias
 
-unset cmd d_cmds f_cmds a_cmds x_cmds
+unset cmd d_cmds a_cmds x_cmds

shell/completion.zsh

@@ -10,12 +10,32 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+if ! declare -f _fzf_compgen_path > /dev/null; then
+  _fzf_compgen_path() {
+    echo "$1"
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+###########################################################
+
 __fzf_generic_path_completion() {
-  local base lbuf find_opts fzf_opts suffix tail fzf dir leftover matches nnm
+  local base lbuf compgen fzf_opts suffix tail fzf dir leftover matches nnm
   # (Q) flag removes a quoting level: "foo\ bar" => "foo bar"
   base=${(Q)1}
   lbuf=$2
-  find_opts=$3
+  compgen=$3
   fzf_opts=$4
   suffix=$5
   tail=$6
@@ -33,7 +53,7 @@ __fzf_generic_path_completion() {
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
       dir=${~dir}
-      matches=$(\find -L "$dir" ${=find_opts} -a -not -path "$dir" -print 2> /dev/null | sed 's@^\./@@' | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
+      matches=$(eval "$compgen $(printf %q "$dir")" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
         printf "%q$suffix " "$item"
       done)
       matches=${matches% }
@@ -50,32 +70,33 @@ __fzf_generic_path_completion() {
 }
 
 _fzf_path_completion() {
-  __fzf_generic_path_completion "$1" "$2" \
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_path \
-    "-name .git -prune -o -name .svn -prune -o ( -type d -o -type f -o -type l )" \
     "-m" "" " "
 }
 
 _fzf_dir_completion() {
-  __fzf_generic_path_completion "$1" "$2" \
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_dir \
-    "-name .git -prune -o -name .svn -prune -o -type d" \
     "" "/" ""
 }
 
 _fzf_feed_fifo() (
-  rm -f "$fifo"
+  rm -f "$1"
-  mkfifo "$fifo"
+  mkfifo "$1"
-  cat <&0 > "$fifo" &
+  cat <&0 > "$1" &
 )
 
 _fzf_complete() {
-  local fifo fzf_opts lbuf fzf matches
+  local fifo fzf_opts lbuf fzf matches post
   fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
   fzf_opts=$1
   lbuf=$2
+  post="${funcstack[2]}_post"
+  type $post > /dev/null 2>&1 || post=cat
+
   [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
   _fzf_feed_fifo "$fifo"
-  matches=$(cat "$fifo" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "${(Q)prefix}" | tr '\n' ' ')
+  matches=$(cat "$fifo" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "${(Q)prefix}" | $post | tr '\n' ' ')
   if [ -n "$matches" ]; then
     LBUFFER="$lbuf$matches"
   fi
@@ -124,7 +145,7 @@ fzf-completion() {
   # 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}"
+    zle ${fzf_default_completion:-expand-or-complete}
     return
   fi
 
@@ -145,7 +166,7 @@ fzf-completion() {
     zle redisplay
   # Trigger sequence given
   elif [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
-    d_cmds=(cd pushd rmdir)
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})
 
     [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
     [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}
@@ -159,7 +180,7 @@ fzf-completion() {
     fi
   # Fall back to default completion
   else
-    eval "zle ${fzf_default_completion:-expand-or-complete}"
+    zle ${fzf_default_completion:-expand-or-complete}
   fi
 }
 

shell/key-bindings.bash

@@ -5,7 +5,7 @@ __fzf_select__() {
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
-  eval "$cmd" | fzf -m | while read item; do
+  eval "$cmd" | fzf -m | while read -r item; do
     printf '%q ' "$item"
   done
   echo
@@ -14,7 +14,7 @@ __fzf_select__() {
 if [[ $- =~ i ]]; then
 
 __fzfcmd() {
-  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+  [ "${FZF_TMUX:-1}" != 0 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
 }
 
 __fzf_select_tmux__() {
@@ -30,10 +30,10 @@ __fzf_select_tmux__() {
 }
 
 __fzf_select_tmux_auto__() {
-  if [ ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ]; then
+  if [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ]; then
     __fzf_select_tmux__
   else
-    tmux send-keys -t $TMUX_PANE "$(__fzf_select__)"
+    tmux send-keys -t "$TMUX_PANE" "$(__fzf_select__)"
   fi
 }
 
@@ -49,7 +49,7 @@ __fzf_history__() (
   shopt -u nocaseglob nocasematch
   line=$(
     HISTTIMEFORMAT= history |
-    $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r |
+    $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS |
     \grep '^ *[0-9]') &&
     if [[ $- =~ H ]]; then
       sed 's/^ *\([0-9]*\)\** .*/!\1/' <<< "$line"
@@ -61,7 +61,7 @@ __fzf_history__() (
 __use_tmux=0
 __use_tmux_auto=0
 if [ -n "$TMUX_PANE" ]; then
-  [ ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
+  [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ] && __use_tmux=1
   [ $BASH_VERSINFO -gt 3 ] && __use_tmux_auto=1
 fi
 
@@ -85,6 +85,15 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   # ALT-C - cd into the selected directory
   bind '"\ec": " \C-e\C-u$(__fzf_cd__)\e\C-e\er\C-m"'
 else
+  # We'd usually use "\e" to enter vi-movement-mode so we can do our magic,
+  # but this incurs a very noticeable delay of a half second or so,
+  # because many other commands start with "\e".
+  # Instead, we bind an unused key, "\C-x\C-a",
+  # to also enter vi-movement-mode,
+  # and then use that thereafter.
+  # (We imagine that "\C-x\C-a" is relatively unlikely to be in use.)
+  bind '"\C-x\C-a": vi-movement-mode'
+
   bind '"\C-x\C-e": shell-expand-line'
   bind '"\C-x\C-r": redraw-current-line'
   bind '"\C-x^": history-expand-line'
@@ -94,19 +103,19 @@ else
   if [ $__use_tmux_auto -eq 1 ]; then
     bind -x '"\C-t": "__fzf_select_tmux_auto__"'
   elif [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": "\e$a \eddi$(__fzf_select_tmux__)\C-x\C-e\e0P$xa"'
+    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select_tmux__)\C-x\C-e\C-x\C-a0P$xa"'
   else
-    bind '"\C-t": "\e$a \eddi$(__fzf_select__)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
+    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select__)\C-x\C-e\C-x\C-a0Px$a \C-x\C-r\C-x\C-axa "'
   fi
   bind -m vi-command '"\C-t": "i\C-t"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\eddi$(__fzf_history__)\C-x\C-e\C-x^\e$a\C-x\C-r"'
+  bind '"\C-r": "\C-x\C-addi$(__fzf_history__)\C-x\C-e\C-x^\C-x\C-a$a\C-x\C-r"'
   bind -m vi-command '"\C-r": "i\C-r"'
 
   # ALT-C - cd into the selected directory
-  bind '"\ec": "\eddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
+  bind '"\ec": "\C-x\C-addi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
-  bind -m vi-command '"\ec": "i\ec"'
+  bind -m vi-command '"\ec": "ddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
 fi
 
 unset -v __use_tmux __use_tmux_auto

shell/key-bindings.fish

@@ -27,7 +27,7 @@ function fzf_key_bindings
   end
 
   function __fzf_ctrl_r
-    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r > $TMPDIR/fzf.result
+    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS > $TMPDIR/fzf.result
     and commandline (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result

shell/key-bindings.zsh

@@ -38,7 +38,7 @@ bindkey '\ec' fzf-cd-widget
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
   local selected num
-  selected=( $(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r -q "${LBUFFER//$/\\$}") )
+  selected=( $(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r ${=FZF_CTRL_R_OPTS} -q "${LBUFFER//$/\\$}") )
   if [ -n "$selected" ]; then
     num=$selected[1]
     if [ -n "$num" ]; then

src/Dockerfile.android

@@ -11,7 +11,6 @@ RUN cd / && curl \
     tar -xz && mv go go1.4 && \
     sed -i 's@#define PTHREAD_KEYS_MAX 128@@' /go1.4/src/runtime/cgo/gcc_android_arm.c
 
-ENV GOPATH /go
 ENV GOROOT /go1.4
 ENV PATH /go1.4/bin:$PATH
 
@@ -37,8 +36,5 @@ RUN cd / && curl \
     make install && \
     mv /ndk/sysroot/usr/lib/libncursesw.a /ndk/sysroot/usr/lib/libncurses.a
 
-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash

src/Dockerfile.arch

@@ -10,7 +10,6 @@ RUN cd / && curl \
     https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
-ENV GOPATH /go
 ENV GOROOT /go1.4
 ENV PATH /go1.4/bin:$PATH
 
@@ -20,9 +19,6 @@ RUN echo '[multilib]' >> /etc/pacman.conf && \
     pacman-db-upgrade && yes | pacman -Sy gcc-multilib lib32-ncurses && \
     cd $GOROOT/src && GOARCH=386 ./make.bash
 
-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash
 

src/Dockerfile.centos

@@ -13,20 +13,20 @@ RUN cd / && curl \
 
 # Install Go 1.5
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.5.1.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.5.3.linux-amd64.tar.gz | \
     tar -xz && mv go go1.5
 
+# Install RPMs for building static 32-bit binary
+RUN curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/ncurses-static-5.7-4.20090207.el6.i686.rpm -o rpm && rpm -i rpm && \
+    curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/gpm-static-1.20.6-12.el6.i686.rpm -o rpm && rpm -i rpm
+
 ENV GOROOT_BOOTSTRAP /go1.4
 ENV GOROOT /go1.5
-ENV GOPATH /go
 ENV PATH /go1.5/bin:$PATH
 
 # For i386 build
 RUN cd $GOROOT/src && GOARCH=386 ./make.bash
 
-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash
 

src/Dockerfile.ubuntu

@@ -10,7 +10,6 @@ RUN cd / && curl \
     https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
-ENV GOPATH /go
 ENV GOROOT /go1.4
 ENV PATH /go1.4/bin:$PATH
 
@@ -18,9 +17,6 @@ ENV PATH /go1.4/bin:$PATH
 RUN apt-get install -y lib32ncurses5-dev && \
     cd $GOROOT/src && GOARCH=386 ./make.bash
 
-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash
 

src/Makefile

@@ -1,7 +1,3 @@
-ifndef GOPATH
-$(error GOPATH is undefined)
-endif
-
 ifndef GOOS
 UNAME_S := $(shell uname -s)
 ifeq ($(UNAME_S),Darwin)
@@ -15,33 +11,44 @@ ifneq ($(shell uname -m),x86_64)
 $(error "Build on $(UNAME_M) is not supported, yet.")
 endif
 
-SOURCES   := $(wildcard *.go */*.go)
+SOURCES     := $(wildcard *.go */*.go)
-BINDIR    := ../bin
+ROOTDIR     := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
-
+BINDIR      := $(shell dirname $(ROOTDIR))/bin
+GOPATH      := $(shell dirname $(ROOTDIR))/gopath
+SRCDIR      := $(GOPATH)/src/github.com/junegunn/fzf/src
+DOCKEROPTS  := -i -t -v $(ROOTDIR):/fzf/src
 BINARY32    := fzf-$(GOOS)_386
 BINARY64    := fzf-$(GOOS)_amd64
 BINARYARM7  := fzf-$(GOOS)_arm7
 VERSION     := $(shell awk -F= '/version =/ {print $$2}' constants.go | tr -d "\" ")
-RELEASE32   = fzf-$(VERSION)-$(GOOS)_386
+RELEASE32   := fzf-$(VERSION)-$(GOOS)_386
-RELEASE64   = fzf-$(VERSION)-$(GOOS)_amd64
+RELEASE64   := fzf-$(VERSION)-$(GOOS)_amd64
-RELEASEARM7 = fzf-$(VERSION)-$(GOOS)_arm7
+RELEASEARM7 := fzf-$(VERSION)-$(GOOS)_arm7
+export GOPATH
 
 all: release
 
-release: build
+release: test build
 	-cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
 	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
 	rm -f $(RELEASE32) $(RELEASE64)
 
-build: test fzf/$(BINARY32) fzf/$(BINARY64)
+build: fzf/$(BINARY32) fzf/$(BINARY64)
 
-android-build:
+$(SRCDIR):
-	cd fzf && GOARCH=arm GOARM=7 CGO_ENABLED=1 go build -a -ldflags="-extldflags=-pie" -o $(BINARYARM7)
+	mkdir -p $(shell dirname $(SRCDIR))
-	cd fzf && cp $(BINARYARM7) $(RELEASEARM7) && tar -czf $(RELEASEARM7).tgz $(RELEASEARM7) && \
+	ln -s $(ROOTDIR) $(SRCDIR)
+
+deps: $(SRCDIR) $(SOURCES)
+	cd $(SRCDIR) && go get
+
+android-build: $(SRCDIR)
+	cd $(SRCDIR) && GOARCH=arm GOARM=7 CGO_ENABLED=1 go get
+	cd $(SRCDIR)/fzf && GOARCH=arm GOARM=7 CGO_ENABLED=1 go build -a -ldflags="-extldflags=-pie" -o $(BINARYARM7)
+	cd $(SRCDIR)/fzf && cp $(BINARYARM7) $(RELEASEARM7) && tar -czf $(RELEASEARM7).tgz $(RELEASEARM7) && \
 	rm -f $(RELEASEARM7)
 
-test:
+test: deps
-	go get
 	SHELL=/bin/sh go test -v ./...
 
 install: $(BINDIR)/fzf
@@ -52,10 +59,10 @@ uninstall:
 clean:
 	cd fzf && rm -f fzf-*
 
-fzf/$(BINARY32): $(SOURCES)
+fzf/$(BINARY32): deps
-	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -o $(BINARY32)
+	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -tags "$(TAGS)" -o $(BINARY32)
 
-fzf/$(BINARY64): $(SOURCES)
+fzf/$(BINARY64): deps
 	cd fzf && go build -a -tags "$(TAGS)" -o $(BINARY64)
 
 $(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
@@ -78,29 +85,29 @@ docker-android:
 	docker build -t junegunn/android-sandbox - < Dockerfile.android
 
 arch: docker-arch
-	docker run -i -t -v $(GOPATH):/go junegunn/$@-sandbox \
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+		sh -c 'cd /fzf/src; /bin/bash'
 
 ubuntu: docker-ubuntu
-	docker run -i -t -v $(GOPATH):/go junegunn/$@-sandbox \
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+		sh -c 'cd /fzf/src; /bin/bash'
 
 centos: docker-centos
-	docker run -i -t -v $(GOPATH):/go junegunn/$@-sandbox \
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+		sh -c 'cd /fzf/src; /bin/bash'
 
 linux: docker-centos
-	docker run -i -t -v $(GOPATH):/go junegunn/centos-sandbox \
+	docker run $(DOCKEROPTS) junegunn/centos-sandbox \
-		/bin/bash -ci 'cd /go/src/github.com/junegunn/fzf/src; make TAGS=static'
+		/bin/bash -ci 'cd /fzf/src; make TAGS=static'
 
 ubuntu-android: docker-android
-	docker run -i -t -v $(GOPATH):/go junegunn/android-sandbox \
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
-		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+		sh -c 'cd /fzf/src; /bin/bash'
 
 android: docker-android
-	docker run -i -t -v $(GOPATH):/go junegunn/android-sandbox \
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
-		/bin/bash -ci 'cd /go/src/github.com/junegunn/fzf/src; GOOS=android make android-build'
+		/bin/bash -ci 'cd /fzf/src; GOOS=android make android-build'
 
-.PHONY: all build release test install uninstall clean docker \
+.PHONY: all build deps release test install uninstall clean \
 	linux arch ubuntu centos docker-arch docker-ubuntu docker-centos \
 	android-build docker-android ubuntu-android android

src/algo/algo.go

@@ -22,10 +22,30 @@ func runeAt(runes []rune, index int, max int, forward bool) rune {
 	return runes[max-index-1]
 }
 
+// Result conatins the results of running a match function.
+type Result struct {
+	Start int32
+	End   int32
+
+	// Items are basically sorted by the lengths of matched substrings.
+	// But we slightly adjust the score with bonus for better results.
+	Bonus int32
+}
+
+type charClass int
+
+const (
+	charNonWord charClass = iota
+	charLower
+	charUpper
+	charLetter
+	charNumber
+)
+
 // FuzzyMatch performs fuzzy-match
-func FuzzyMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) (int, int) {
+func FuzzyMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
 	if len(pattern) == 0 {
-		return 0, 0
+		return Result{0, 0, 0}
 	}
 
 	// 0. (FIXME) How to find the shortest match?
@@ -90,12 +110,76 @@ func FuzzyMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune)
 				}
 			}
 		}
-		if forward {
+
-			return sidx, eidx
+		// Calculate the bonus. This can't be done at the same time as the
+		// pattern scan above because 'forward' may be false.
+		if !forward {
+			sidx, eidx = lenRunes-eidx, lenRunes-sidx
 		}
-		return lenRunes - eidx, lenRunes - sidx
+
+		var bonus int32
+		pidx := 0
+		consecutive := false
+		prevClass := charNonWord
+		for index := 0; index < eidx; index++ {
+			char := runes[index]
+			var class charClass
+			if unicode.IsLower(char) {
+				class = charLower
+			} else if unicode.IsUpper(char) {
+				class = charUpper
+			} else if unicode.IsLetter(char) {
+				class = charLetter
+			} else if unicode.IsNumber(char) {
+				class = charNumber
+			} else {
+				class = charNonWord
+			}
+
+			var point int32
+			if prevClass == charNonWord && class != charNonWord {
+				// Word boundary
+				point = 2
+			} else if prevClass == charLower && class == charUpper ||
+				prevClass != charNumber && class == charNumber {
+				// camelCase letter123
+				point = 1
+			}
+			prevClass = class
+
+			if index >= sidx {
+				if !caseSensitive {
+					if char >= 'A' && char <= 'Z' {
+						char += 32
+					} else if char > unicode.MaxASCII {
+						char = unicode.To(unicode.LowerCase, char)
+					}
+				}
+				pchar := pattern[pidx]
+				if pchar == char {
+					// Boost bonus for the first character in the pattern
+					if pidx == 0 {
+						point *= 2
+					}
+					// Bonus to consecutive matching chars
+					if consecutive {
+						point++
+					}
+					bonus += point
+
+					if pidx++; pidx == lenPattern {
+						break
+					}
+					consecutive = true
+				} else {
+					consecutive = false
+				}
+			}
+		}
+
+		return Result{int32(sidx), int32(eidx), bonus}
 	}
-	return -1, -1
+	return Result{-1, -1, 0}
 }
 
 // ExactMatchNaive is a basic string searching algorithm that handles case
@@ -105,16 +189,17 @@ func FuzzyMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune)
 //
 // We might try to implement better algorithms in the future:
 // http://en.wikipedia.org/wiki/String_searching_algorithm
-func ExactMatchNaive(caseSensitive bool, forward bool, runes []rune, pattern []rune) (int, int) {
+func ExactMatchNaive(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: ExactMatchNaive always return a zero bonus.
 	if len(pattern) == 0 {
-		return 0, 0
+		return Result{0, 0, 0}
 	}
 
 	lenRunes := len(runes)
 	lenPattern := len(pattern)
 
 	if lenRunes < lenPattern {
-		return -1, -1
+		return Result{-1, -1, 0}
 	}
 
 	pidx := 0
@@ -132,22 +217,23 @@ func ExactMatchNaive(caseSensitive bool, forward bool, runes []rune, pattern []r
 			pidx++
 			if pidx == lenPattern {
 				if forward {
-					return index - lenPattern + 1, index + 1
+					return Result{int32(index - lenPattern + 1), int32(index + 1), 0}
 				}
-				return lenRunes - (index + 1), lenRunes - (index - lenPattern + 1)
+				return Result{int32(lenRunes - (index + 1)), int32(lenRunes - (index - lenPattern + 1)), 0}
 			}
 		} else {
 			index -= pidx
 			pidx = 0
 		}
 	}
-	return -1, -1
+	return Result{-1, -1, 0}
 }
 
 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) (int, int) {
+func PrefixMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: PrefixMatch always return a zero bonus.
 	if len(runes) < len(pattern) {
-		return -1, -1
+		return Result{-1, -1, 0}
 	}
 
 	for index, r := range pattern {
@@ -156,19 +242,20 @@ func PrefixMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune)
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return -1, -1
+			return Result{-1, -1, 0}
 		}
 	}
-	return 0, len(pattern)
+	return Result{0, int32(len(pattern)), 0}
 }
 
 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, forward bool, input []rune, pattern []rune) (int, int) {
+func SuffixMatch(caseSensitive bool, forward bool, input []rune, pattern []rune) Result {
+	// Note: SuffixMatch always return a zero bonus.
 	runes := util.TrimRight(input)
 	trimmedLen := len(runes)
 	diff := trimmedLen - len(pattern)
 	if diff < 0 {
-		return -1, -1
+		return Result{-1, -1, 0}
 	}
 
 	for index, r := range pattern {
@@ -177,23 +264,24 @@ func SuffixMatch(caseSensitive bool, forward bool, input []rune, pattern []rune)
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return -1, -1
+			return Result{-1, -1, 0}
 		}
 	}
-	return trimmedLen - len(pattern), trimmedLen
+	return Result{int32(trimmedLen - len(pattern)), int32(trimmedLen), 0}
 }
 
 // EqualMatch performs equal-match
-func EqualMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) (int, int) {
+func EqualMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: EqualMatch always return a zero bonus.
 	if len(runes) != len(pattern) {
-		return -1, -1
+		return Result{-1, -1, 0}
 	}
 	runesStr := string(runes)
 	if !caseSensitive {
 		runesStr = strings.ToLower(runesStr)
 	}
 	if runesStr == string(pattern) {
-		return 0, len(pattern)
+		return Result{0, int32(len(pattern)), 0}
 	}
-	return -1, -1
+	return Result{-1, -1, 0}
 }

src/algo/algo_test.go

@@ -5,65 +5,84 @@ import (
 	"testing"
 )
 
-func assertMatch(t *testing.T, fun func(bool, bool, []rune, []rune) (int, int), caseSensitive bool, forward bool, input string, pattern string, sidx int, eidx int) {
+func assertMatch(t *testing.T, fun func(bool, bool, []rune, []rune) Result, caseSensitive, forward bool, input, pattern string, sidx int32, eidx int32, bonus int32) {
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	s, e := fun(caseSensitive, forward, []rune(input), []rune(pattern))
+	res := fun(caseSensitive, forward, []rune(input), []rune(pattern))
-	if s != sidx {
+	if res.Start != sidx {
-		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", s, sidx, input, pattern)
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", res.Start, sidx, input, pattern)
 	}
-	if e != eidx {
+	if res.End != eidx {
-		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", e, eidx, input, pattern)
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", res.End, eidx, input, pattern)
+	}
+	if res.Bonus != bonus {
+		t.Errorf("Invalid bonus: %d (expected: %d, %s / %s)", res.Bonus, bonus, input, pattern)
 	}
 }
 
 func TestFuzzyMatch(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "fooBarbaz", "oBZ", 2, 9)
+	assertMatch(t, FuzzyMatch, false, true, "fooBarbaz", "oBZ", 2, 9, 2)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBZ", -1, -1)
+	assertMatch(t, FuzzyMatch, false, true, "foo bar baz", "fbb", 0, 9, 8)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBz", 2, 9)
+	assertMatch(t, FuzzyMatch, false, true, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "fooBarbazz", -1, -1)
+	assertMatch(t, FuzzyMatch, false, true, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
+	assertMatch(t, FuzzyMatch, false, true, "/.oh-my-zsh/cache", "zshc", 8, 13, 8)
+	assertMatch(t, FuzzyMatch, false, true, "ab0123 456", "12356", 3, 10, 3)
+	assertMatch(t, FuzzyMatch, false, true, "abc123 456", "12356", 3, 10, 5)
+
+	assertMatch(t, FuzzyMatch, false, true, "foo/bar/baz", "fbb", 0, 9, 8)
+	assertMatch(t, FuzzyMatch, false, true, "fooBarBaz", "fbb", 0, 7, 6)
+	assertMatch(t, FuzzyMatch, false, true, "foo barbaz", "fbb", 0, 8, 6)
+	assertMatch(t, FuzzyMatch, false, true, "fooBar Baz", "foob", 0, 4, 8)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBZ", -1, -1, 0)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBz", 2, 9, 2)
+	assertMatch(t, FuzzyMatch, true, true, "Foo Bar Baz", "fbb", -1, -1, 0)
+	assertMatch(t, FuzzyMatch, true, true, "Foo/Bar/Baz", "FBB", 0, 9, 8)
+	assertMatch(t, FuzzyMatch, true, true, "FooBarBaz", "FBB", 0, 7, 6)
+	assertMatch(t, FuzzyMatch, true, true, "foo BarBaz", "fBB", 0, 8, 7)
+	assertMatch(t, FuzzyMatch, true, true, "FooBar Baz", "FooB", 0, 4, 8)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "fooBarbazz", -1, -1, 0)
 }
 
 func TestFuzzyMatchBackward(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "foobar fb", "fb", 0, 4)
+	assertMatch(t, FuzzyMatch, false, true, "foobar fb", "fb", 0, 4, 4)
-	assertMatch(t, FuzzyMatch, false, false, "foobar fb", "fb", 7, 9)
+	assertMatch(t, FuzzyMatch, false, false, "foobar fb", "fb", 7, 9, 5)
 }
 
 func TestExactMatchNaive(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5)
+		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5, 0)
-		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1)
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1, 0)
-		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1)
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1, 0)
 	}
 }
 
 func TestExactMatchNaiveBackward(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "foobar foob", "oo", 1, 3)
+	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3, 0)
-	assertMatch(t, FuzzyMatch, false, false, "foobar foob", "oo", 8, 10)
+	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10, 0)
 }
 
 func TestPrefixMatch(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, 0)
-		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1)
+		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
-		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "baz", -1, -1)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "baz", -1, -1, 0)
 	}
 }
 
 func TestSuffixMatch(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9, 0)
-		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1)
+		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1, 0)
 	}
 }
 
 func TestEmptyPattern(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, FuzzyMatch, true, dir, "foobar", "", 0, 0)
+		assertMatch(t, FuzzyMatch, true, dir, "foobar", "", 0, 0, 0)
-		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0, 0)
-		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0)
+		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0, 0)
-		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6)
+		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6, 0)
 	}
 }

src/constants.go

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

src/item.go

@@ -23,6 +23,7 @@ type Item struct {
 	offsets     []Offset
 	colors      []ansiOffset
 	rank        [5]int32
+	bonus       int32
 }
 
 // Sort criteria to use. Never changes once fzf is started.
@@ -73,15 +74,17 @@ func (item *Item) Rank(cache bool) [5]int32 {
 			matchlen += end - begin
 		}
 	}
-	if matchlen == 0 {
-		matchlen = math.MaxInt32
-	}
 	rank := buildEmptyRank(item.Index())
 	for idx, criterion := range sortCriteria {
 		var val int32
 		switch criterion {
 		case byMatchLen:
-			val = int32(matchlen)
+			if matchlen == 0 {
+				val = math.MaxInt32
+			} else {
+				// It is extremely unlikely that bonus exceeds 128
+				val = 128*int32(matchlen) - item.bonus
+			}
 		case byLength:
 			// It is guaranteed that .transformed in not null in normal execution
 			if item.transformed != nil {

src/matcher.go

@@ -200,7 +200,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 	}
 
 	partialResults := make([][]*Item, numSlices)
-	for range slices {
+	for _, _ = range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}

src/options.go

@@ -42,6 +42,8 @@ const usage = `usage: fzf [options]
     --tabstop=SPACES      Number of spaces for a tab character (default: 8)
     --cycle               Enable cyclic scroll
     --no-hscroll          Disable horizontal scroll
+    --hscroll-off=COL     Number of screen columns to keep to the right of the
+                          highlighted substring (default: 10)
     --inline-info         Display finder info inline with the query
     --prompt=STR          Input prompt (default: '> ')
     --bind=KEYBINDS       Custom key bindings. Refer to the man page.
@@ -108,6 +110,7 @@ type Options struct {
 	Reverse     bool
 	Cycle       bool
 	Hscroll     bool
+	HscrollOff  int
 	InlineInfo  bool
 	Prompt      string
 	Query       string
@@ -155,6 +158,7 @@ func defaultOptions() *Options {
 		Reverse:     false,
 		Cycle:       false,
 		Hscroll:     true,
+		HscrollOff:  10,
 		InlineInfo:  false,
 		Prompt:      "> ",
 		Query:       "",
@@ -163,7 +167,7 @@ func defaultOptions() *Options {
 		Filter:      nil,
 		ToggleSort:  false,
 		Expect:      make(map[int]string),
-		Keymap:      defaultKeymap(),
+		Keymap:      make(map[int]actionType),
 		Execmap:     make(map[int]string),
 		PrintQuery:  false,
 		ReadZero:    false,
@@ -484,7 +488,7 @@ const (
 	escapedComma = 1
 )
 
-func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort bool, str string) (map[int]actionType, map[int]string, bool) {
+func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string) {
 	if executeRegexp == nil {
 		// Backreferences are not supported.
 		// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
@@ -592,7 +596,6 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 			keymap[key] = actNextHistory
 		case "toggle-sort":
 			keymap[key] = actToggleSort
-			toggleSort = true
 		default:
 			if isExecuteAction(actLower) {
 				var offset int
@@ -613,7 +616,6 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 			}
 		}
 	}
-	return keymap, execmap, toggleSort
 }
 
 func isExecuteAction(str string) bool {
@@ -635,13 +637,12 @@ func isExecuteAction(str string) bool {
 	return false
 }
 
-func checkToggleSort(keymap map[int]actionType, str string) map[int]actionType {
+func parseToggleSort(keymap map[int]actionType, str string) {
 	keys := parseKeyChords(str, "key name required")
 	if len(keys) != 1 {
 		errorExit("multiple keys specified")
 	}
 	keymap[firstKey(keys)] = actToggleSort
-	return keymap
 }
 
 func strLines(str string) []string {
@@ -691,7 +692,6 @@ func parseMargin(margin string) [4]string {
 }
 
 func parseOptions(opts *Options, allArgs []string) {
-	keymap := make(map[int]actionType)
 	var historyMax int
 	if opts.History == nil {
 		historyMax = defaultHistoryMax
@@ -741,8 +741,7 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--tiebreak":
 			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
-			keymap, opts.Execmap, opts.ToggleSort =
+			parseKeymap(opts.Keymap, opts.Execmap, nextString(allArgs, &i, "bind expression required"))
-				parseKeymap(keymap, opts.Execmap, opts.ToggleSort, nextString(allArgs, &i, "bind expression required"))
 		case "--color":
 			spec := optionalNextString(allArgs, &i)
 			if len(spec) == 0 {
@@ -751,8 +750,7 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.Theme = parseTheme(opts.Theme, spec)
 			}
 		case "--toggle-sort":
-			keymap = checkToggleSort(keymap, nextString(allArgs, &i, "key name required"))
+			parseToggleSort(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":
@@ -801,6 +799,8 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Hscroll = true
 		case "--no-hscroll":
 			opts.Hscroll = false
+		case "--hscroll-off":
+			opts.HscrollOff = nextInt(allArgs, &i, "hscroll offset required")
 		case "--inline-info":
 			opts.InlineInfo = true
 		case "--no-inline-info":
@@ -869,8 +869,7 @@ 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 {
-				keymap = checkToggleSort(keymap, value)
+				parseToggleSort(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 {
@@ -878,8 +877,7 @@ func parseOptions(opts *Options, allArgs []string) {
 			} else if match, value := optString(arg, "--color="); match {
 				opts.Theme = parseTheme(opts.Theme, value)
 			} else if match, value := optString(arg, "--bind="); match {
-				keymap, opts.Execmap, opts.ToggleSort =
+				parseKeymap(opts.Keymap, opts.Execmap, value)
-					parseKeymap(keymap, opts.Execmap, opts.ToggleSort, value)
 			} else if match, value := optString(arg, "--history="); match {
 				setHistory(value)
 			} else if match, value := optString(arg, "--history-size="); match {
@@ -892,6 +890,8 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.Margin = parseMargin(value)
 			} else if match, value := optString(arg, "--tabstop="); match {
 				opts.Tabstop = atoi(value)
+			} else if match, value := optString(arg, "--hscroll-off="); match {
+				opts.HscrollOff = atoi(value)
 			} else {
 				errorExit("unknown option: " + arg)
 			}
@@ -902,24 +902,35 @@ func parseOptions(opts *Options, allArgs []string) {
 		errorExit("header lines must be a non-negative integer")
 	}
 
+	if opts.HscrollOff < 0 {
+		errorExit("hscroll offset must be a non-negative integer")
+	}
+
 	if opts.Tabstop < 1 {
 		errorExit("tab stop must be a positive integer")
 	}
+}
 
-	// Change default actions for CTRL-N / CTRL-P when --history is used
+func postProcessOptions(opts *Options) {
+	// Default actions for CTRL-N / CTRL-P when --history is set
 	if opts.History != nil {
-		if _, prs := keymap[curses.CtrlP]; !prs {
+		if _, prs := opts.Keymap[curses.CtrlP]; !prs {
-			keymap[curses.CtrlP] = actPreviousHistory
+			opts.Keymap[curses.CtrlP] = actPreviousHistory
 		}
-		if _, prs := keymap[curses.CtrlN]; !prs {
+		if _, prs := opts.Keymap[curses.CtrlN]; !prs {
-			keymap[curses.CtrlN] = actNextHistory
+			opts.Keymap[curses.CtrlN] = actNextHistory
 		}
 	}
 
-	// Override default key bindings
+	// Extend the default key map
-	for key, act := range keymap {
+	keymap := defaultKeymap()
-		opts.Keymap[key] = act
+	for key, act := range opts.Keymap {
+		if act == actToggleSort {
+			opts.ToggleSort = true
+		}
+		keymap[key] = act
 	}
+	opts.Keymap = keymap
 
 	// If we're not using extended search mode, --nth option becomes irrelevant
 	// if it contains the whole range
@@ -939,9 +950,13 @@ func ParseOptions() *Options {
 
 	// Options from Env var
 	words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
-	parseOptions(opts, words)
+	if len(words) > 0 {
+		parseOptions(opts, words)
+	}
 
 	// Options from command-line arguments
 	parseOptions(opts, os.Args[1:])
+
+	postProcessOptions(opts)
 	return opts
 }

src/options_test.go

@@ -96,6 +96,7 @@ func TestIrrelevantNth(t *testing.T) {
 		opts := defaultOptions()
 		words := []string{"--nth", "..", "-x"}
 		parseOptions(opts, words)
+		postProcessOptions(opts)
 		if len(opts.Nth) != 0 {
 			t.Errorf("nth should be empty: %s", opts.Nth)
 		}
@@ -104,6 +105,7 @@ func TestIrrelevantNth(t *testing.T) {
 		{
 			opts := defaultOptions()
 			parseOptions(opts, words)
+			postProcessOptions(opts)
 			if len(opts.Nth) != 0 {
 				t.Errorf("nth should be empty: %s", opts.Nth)
 			}
@@ -112,6 +114,7 @@ func TestIrrelevantNth(t *testing.T) {
 			opts := defaultOptions()
 			words = append(words, "-x")
 			parseOptions(opts, words)
+			postProcessOptions(opts)
 			if len(opts.Nth) != 2 {
 				t.Errorf("nth should not be empty: %s", opts.Nth)
 			}
@@ -231,15 +234,11 @@ func TestBind(t *testing.T) {
 	keymap := defaultKeymap()
 	execmap := make(map[int]string)
 	check(actBeginningOfLine, keymap[curses.CtrlA])
-	keymap, execmap, toggleSort :=
+	parseKeymap(keymap, execmap,
-		parseKeymap(keymap, execmap, false,
+		"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
-			"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
+			"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
-				"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
-				"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
+			",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
-				",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
-	if !toggleSort {
-		t.Errorf("toggleSort not set")
-	}
 	check(actKillLine, keymap[curses.CtrlA])
 	check(actToggleSort, keymap[curses.CtrlB])
 	check(actPageUp, keymap[curses.AltZ+'c'])
@@ -259,15 +258,11 @@ func TestBind(t *testing.T) {
 	checkString("\nfoobar,Y:execute(baz)", execmap[curses.AltZ+'X'])
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		keymap, execmap, toggleSort =
+		parseKeymap(keymap, execmap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
-			parseKeymap(keymap, execmap, false, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
 		checkString("foobar", execmap[curses.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
 	}
 
-	keymap, execmap, toggleSort = parseKeymap(keymap, execmap, false, "f1:abort")
+	parseKeymap(keymap, execmap, "f1:abort")
-	if toggleSort {
-		t.Errorf("toggleSort set")
-	}
 	check(actAbort, keymap[curses.F1])
 }
 
@@ -328,3 +323,53 @@ func TestParseNilTheme(t *testing.T) {
 		t.Errorf("color should now be enabled and customized")
 	}
 }
+
+func TestDefaultCtrlNP(t *testing.T) {
+	check := func(words []string, key int, expected actionType) {
+		opts := defaultOptions()
+		parseOptions(opts, words)
+		postProcessOptions(opts)
+		if opts.Keymap[key] != expected {
+			t.Error()
+		}
+	}
+	check([]string{}, curses.CtrlN, actDown)
+	check([]string{}, curses.CtrlP, actUp)
+
+	check([]string{"--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{"--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+
+	hist := "--history=/tmp/foo"
+	check([]string{hist}, curses.CtrlN, actNextHistory)
+	check([]string{hist}, curses.CtrlP, actPreviousHistory)
+
+	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlP, actPreviousHistory)
+
+	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlN, actNextHistory)
+	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+}
+
+func TestToggle(t *testing.T) {
+	optsFor := func(words ...string) *Options {
+		opts := defaultOptions()
+		parseOptions(opts, words)
+		postProcessOptions(opts)
+		return opts
+	}
+
+	opts := optsFor()
+	if opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort")
+	if !opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort", "--bind=a:up")
+	if opts.ToggleSort {
+		t.Error()
+	}
+}

src/pattern.go

@@ -49,7 +49,7 @@ type Pattern struct {
 	cacheable     bool
 	delimiter     Delimiter
 	nth           []Range
-	procFun       map[termType]func(bool, bool, []rune, []rune) (int, int)
+	procFun       map[termType]func(bool, bool, []rune, []rune) algo.Result
 }
 
 var (
@@ -125,7 +125,7 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		procFun:       make(map[termType]func(bool, bool, []rune, []rune) (int, int))}
+		procFun:       make(map[termType]func(bool, bool, []rune, []rune) algo.Result)}
 
 	ptr.procFun[termFuzzy] = algo.FuzzyMatch
 	ptr.procFun[termEqual] = algo.EqualMatch
@@ -275,15 +275,16 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 	matches := []*Item{}
 	if !p.extended {
 		for _, item := range *chunk {
-			if sidx, eidx, tlen := p.basicMatch(item); sidx >= 0 {
+			offset, bonus := p.basicMatch(item)
+			if sidx := offset[0]; sidx >= 0 {
 				matches = append(matches,
-					dupItem(item, []Offset{Offset{int32(sidx), int32(eidx), int32(tlen)}}))
+					dupItem(item, []Offset{offset}, bonus))
 			}
 		}
 	} else {
 		for _, item := range *chunk {
-			if offsets := p.extendedMatch(item); len(offsets) == len(p.termSets) {
+			if offsets, bonus := p.extendedMatch(item); len(offsets) == len(p.termSets) {
-				matches = append(matches, dupItem(item, offsets))
+				matches = append(matches, dupItem(item, offsets, bonus))
 			}
 		}
 	}
@@ -293,25 +294,27 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 // MatchItem returns true if the Item is a match
 func (p *Pattern) MatchItem(item *Item) bool {
 	if !p.extended {
-		sidx, _, _ := p.basicMatch(item)
+		offset, _ := p.basicMatch(item)
+		sidx := offset[0]
 		return sidx >= 0
 	}
-	offsets := p.extendedMatch(item)
+	offsets, _ := p.extendedMatch(item)
 	return len(offsets) == len(p.termSets)
 }
 
-func dupItem(item *Item, offsets []Offset) *Item {
+func dupItem(item *Item, offsets []Offset, bonus int32) *Item {
 	sort.Sort(ByOrder(offsets))
 	return &Item{
 		text:        item.text,
 		origText:    item.origText,
 		transformed: item.transformed,
 		offsets:     offsets,
+		bonus:       bonus,
 		colors:      item.colors,
 		rank:        buildEmptyRank(item.Index())}
 }
 
-func (p *Pattern) basicMatch(item *Item) (int, int, int) {
+func (p *Pattern) basicMatch(item *Item) (Offset, int32) {
 	input := p.prepareInput(item)
 	if p.fuzzy {
 		return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.forward, p.text)
@@ -319,29 +322,33 @@ func (p *Pattern) basicMatch(item *Item) (int, int, int) {
 	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text)
 }
 
-func (p *Pattern) extendedMatch(item *Item) []Offset {
+func (p *Pattern) extendedMatch(item *Item) ([]Offset, int32) {
 	input := p.prepareInput(item)
 	offsets := []Offset{}
+	var totalBonus int32
 	for _, termSet := range p.termSets {
 		var offset *Offset
+		var bonus int32
 		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-			if sidx, eidx, tlen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text); sidx >= 0 {
+			off, pen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text)
+			if sidx := off[0]; sidx >= 0 {
 				if term.inv {
 					continue
 				}
-				offset = &Offset{int32(sidx), int32(eidx), int32(tlen)}
+				offset, bonus = &off, pen
 				break
 			} else if term.inv {
-				offset = &Offset{0, 0, 0}
+				offset, bonus = &Offset{0, 0, 0}, 0
 				continue
 			}
 		}
 		if offset != nil {
 			offsets = append(offsets, *offset)
+			totalBonus += bonus
 		}
 	}
-	return offsets
+	return offsets, totalBonus
 }
 
 func (p *Pattern) prepareInput(item *Item) []Token {
@@ -360,13 +367,16 @@ func (p *Pattern) prepareInput(item *Item) []Token {
 	return ret
 }
 
-func (p *Pattern) iter(pfun func(bool, bool, []rune, []rune) (int, int),
+func (p *Pattern) iter(pfun func(bool, bool, []rune, []rune) algo.Result,
-	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (int, int, int) {
+	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (Offset, int32) {
 	for _, part := range tokens {
-		prefixLength := part.prefixLength
+		prefixLength := int32(part.prefixLength)
-		if sidx, eidx := pfun(caseSensitive, forward, part.text, pattern); sidx >= 0 {
+		if res := pfun(caseSensitive, forward, part.text, pattern); res.Start >= 0 {
-			return sidx + prefixLength, eidx + prefixLength, part.trimLength
+			var sidx int32 = res.Start + prefixLength
+			var eidx int32 = res.End + prefixLength
+			return Offset{sidx, eidx, int32(part.trimLength)}, res.Bonus
 		}
 	}
-	return -1, -1, -1 // math.MaxUint16
+	// TODO: math.MaxUint16
+	return Offset{-1, -1, -1}, 0.0
 }

src/pattern_test.go

@@ -70,10 +70,10 @@ func TestExact(t *testing.T) {
 	clearPatternCache()
 	pattern := BuildPattern(true, true, CaseSmart, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
-	sidx, eidx := algo.ExactMatchNaive(
+	res := algo.ExactMatchNaive(
 		pattern.caseSensitive, pattern.forward, []rune("aabbcc abc"), pattern.termSets[0][0].text)
-	if sidx != 7 || eidx != 10 {
+	if res.Start != 7 || res.End != 10 {
-		t.Errorf("%s / %d / %d", pattern.termSets, sidx, eidx)
+		t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 	}
 }
 
@@ -82,11 +82,11 @@ func TestEqual(t *testing.T) {
 	clearPatternCache()
 	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
-	match := func(str string, sidxExpected int, eidxExpected int) {
+	match := func(str string, sidxExpected int32, eidxExpected int32) {
-		sidx, eidx := algo.EqualMatch(
+		res := algo.EqualMatch(
 			pattern.caseSensitive, pattern.forward, []rune(str), pattern.termSets[0][0].text)
-		if sidx != sidxExpected || eidx != eidxExpected {
+		if res.Start != sidxExpected || res.End != eidxExpected {
-			t.Errorf("%s / %d / %d", pattern.termSets, sidx, eidx)
+			t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 		}
 	}
 	match("ABC", -1, -1)

src/reader.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"io"
 	"os"
-	"os/exec"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -59,7 +58,7 @@ func (r *Reader) readFromStdin() {
 }
 
 func (r *Reader) readFromCommand(cmd string) {
-	listCommand := exec.Command("sh", "-c", cmd)
+	listCommand := util.ExecCommand(cmd)
 	out, err := listCommand.StdoutPipe()
 	if err != nil {
 		return

src/terminal.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"os"
-	"os/exec"
 	"os/signal"
 	"regexp"
 	"sort"
@@ -27,6 +26,7 @@ type Terminal struct {
 	prompt     string
 	reverse    bool
 	hscroll    bool
+	hscrollOff int
 	cx         int
 	cy         int
 	offset     int
@@ -211,6 +211,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		prompt:     opts.Prompt,
 		reverse:    opts.Reverse,
 		hscroll:    opts.Hscroll,
+		hscrollOff: opts.HscrollOff,
 		cx:         len(input),
 		cy:         0,
 		offset:     0,
@@ -557,11 +558,9 @@ func trimLeft(runes []rune, width int) ([]rune, int32) {
 }
 
 func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, current bool) {
-	var maxe int32
+	var maxe int
 	for _, offset := range item.offsets {
-		if offset[1] > maxe {
+		maxe = util.Max(maxe, int(offset[1]))
-			maxe = offset[1]
-		}
 	}
 
 	// Overflow
@@ -569,6 +568,7 @@ func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, c
 	copy(text, item.text)
 	offsets := item.colorOffsets(col2, bold, current)
 	maxWidth := C.MaxX() - 3 - t.marginInt[1] - t.marginInt[3]
+	maxe = util.Constrain(maxe+util.Min(maxWidth/2-2, t.hscrollOff), 0, len(text))
 	fullWidth := displayWidth(text)
 	if fullWidth > maxWidth {
 		if t.hscroll {
@@ -711,7 +711,9 @@ func (t *Terminal) rubout(pattern string) {
 }
 
 func keyMatch(key int, event C.Event) bool {
-	return event.Type == key || event.Type == C.Rune && int(event.Char) == key-C.AltZ
+	return event.Type == key ||
+		event.Type == C.Rune && int(event.Char) == key-C.AltZ ||
+		event.Type == C.Mouse && key == C.DoubleClick && event.MouseEvent.Double
 }
 
 func quoteEntry(entry string) string {
@@ -720,7 +722,7 @@ func quoteEntry(entry string) string {
 
 func executeCommand(template string, replacement string) {
 	command := strings.Replace(template, "{}", replacement, -1)
-	cmd := exec.Command("sh", "-c", command)
+	cmd := util.ExecCommand(command)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -734,7 +736,7 @@ func (t *Terminal) Loop() {
 	<-t.startChan
 	{ // Late initialization
 		intChan := make(chan os.Signal, 1)
-		signal.Notify(intChan, os.Interrupt, os.Kill)
+		signal.Notify(intChan, os.Interrupt, os.Kill, syscall.SIGTERM)
 		go func() {
 			<-intChan
 			t.reqBox.Set(reqQuit, nil)
@@ -1123,15 +1125,7 @@ func (t *Terminal) constrain() {
 	diffpos := t.cy - t.offset
 
 	t.cy = util.Constrain(t.cy, 0, count-1)
-
+	t.offset = util.Constrain(t.offset, t.cy-height+1, t.cy)
-	if t.cy > t.offset+(height-1) {
-		// Ceil
-		t.offset = t.cy - (height - 1)
-	} else if t.offset > t.cy {
-		// Floor
-		t.offset = t.cy
-	}
-
 	// Adjustment
 	if count-t.offset < height {
 		t.offset = util.Max(0, count-height)

src/util/util.go

@@ -5,6 +5,7 @@ import "C"
 
 import (
 	"os"
+	"os/exec"
 	"time"
 	"unicode/utf8"
 )
@@ -20,6 +21,14 @@ func Max(first int, items ...int) int {
 	return max
 }
 
+// Min returns the smallest integer
+func Min(first int, second int) int {
+	if first <= second {
+		return first
+	}
+	return second
+}
+
 // Min32 returns the smallest 32-bit integer
 func Min32(first int32, second int32) int32 {
 	if first <= second {
@@ -126,3 +135,12 @@ func TrimLen(runes []rune) int {
 	}
 	return i - j + 1
 }
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "sh"
+	}
+	return exec.Command(shell, "-c", command)
+}

test/test_go.rb

@@ -207,13 +207,13 @@ class TestGoFZF < TestBase
     tmux.send_keys '99', 'C-a', '1', 'C-f', '3', 'C-b', 'C-h', 'C-u', 'C-e', 'C-y', 'C-k', 'Tab', 'BTab'
     tmux.until { |lines| lines[-2] == '  856/100000' }
     lines = tmux.capture
-    assert_equal '> 1391',       lines[-4]
+    assert_equal '> 3910',       lines[-4]
     assert_equal '  391',        lines[-3]
     assert_equal '  856/100000', lines[-2]
     assert_equal '> 391',        lines[-1]
 
     tmux.send_keys :Enter
-    assert_equal '1391', readonce.chomp
+    assert_equal '3910', readonce.chomp
   end
 
   def test_fzf_default_command
@@ -357,7 +357,7 @@ class TestGoFZF < TestBase
       tmux.send_keys :BTab, :BTab, :BTab
       tmux.until { |lines| lines[-2].include?('(3)') }
       tmux.send_keys :Enter
-      assert_equal ['5', '5', '15', '25'], readonce.split($/)
+      assert_equal ['5', '5', '50', '51'], readonce.split($/)
     end
   end
 
@@ -378,7 +378,7 @@ class TestGoFZF < TestBase
     tmux.send_keys :Enter
     tmux.until { |lines| lines[-1] == '>' }
     tmux.send_keys 'C-K', :Enter
-    assert_equal ['1919'], readonce.split($/)
+    assert_equal ['9090'], readonce.split($/)
   end
 
   def test_tac
@@ -394,6 +394,7 @@ class TestGoFZF < TestBase
     tmux.send_keys "seq 1 1000 | #{fzf :tac, :multi}", :Enter
     tmux.until { |lines| lines[-2].include? '1000/1000' }
     tmux.send_keys '99'
+    tmux.until { |lines| lines[-2].include? '28/1000' }
     tmux.send_keys :BTab, :BTab, :BTab
     tmux.until { |lines| lines[-2].include?('(3)') }
     tmux.send_keys :Enter
@@ -413,11 +414,12 @@ class TestGoFZF < TestBase
 
   def test_expect
     test = lambda do |key, feed, expected = key|
-      tmux.send_keys "seq 1 100 | #{fzf :expect, key}", :Enter
+      tmux.send_keys "seq 1 100 | #{fzf :expect, key}; sync", :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
+      tmux.prepare
       assert_equal [expected, '55'], readonce.split($/)
     end
     test.call 'ctrl-t', 'C-T'
@@ -709,10 +711,10 @@ class TestGoFZF < TestBase
 
     # len(1 ~ 2)
     output = [
-      "apple  ui     bottle 2",
       "app     ic    bottle 4",
-      "apple juice   bottle 1",
       "app     ice   bottle 3",
+      "apple  ui     bottle 2",
+      "apple juice   bottle 1",
     ]
     assert_equal output, `#{FZF} -fai -n1..2 < #{tempname}`.split($/)
 
@@ -727,9 +729,9 @@ class TestGoFZF < TestBase
 
     # len(2)
     output = [
-      "apple  ui     bottle 2",
       "app     ic    bottle 4",
       "app     ice   bottle 3",
+      "apple  ui     bottle 2",
       "apple juice   bottle 1",
     ]
     assert_equal output, `#{FZF} -fi -n2 < #{tempname}`.split($/)
@@ -877,15 +879,19 @@ class TestGoFZF < TestBase
 
   def test_execute_multi
     output = '/tmp/fzf-test-execute-multi'
-    opts = %[--multi --bind \\"alt-a:execute-multi(echo '[{}], @{}@' >> #{output})\\"]
+    opts = %[--multi --bind \\"alt-a:execute-multi(echo '[{}], @{}@' >> #{output}; sync)\\"]
     tmux.send_keys "seq 100 | #{fzf opts}", :Enter
     tmux.until { |lines| lines[-2].include? '100/100' }
     tmux.send_keys :Escape, :a
+    tmux.until { |lines| lines[-2].include? '/100' }
     tmux.send_keys :BTab, :BTab, :BTab
     tmux.send_keys :Escape, :a
+    tmux.until { |lines| lines[-2].include? '/100' }
     tmux.send_keys :Tab, :Tab
     tmux.send_keys :Escape, :a
+    tmux.until { |lines| lines[-2].include? '/100' }
     tmux.send_keys :Enter
+    tmux.prepare
     readonce
     assert_equal ['["1"], @"1"@', '["1" "2" "3"], @"1" "2" "3"@', '["1" "2" "4"], @"1" "2" "4"@'],
       File.readlines(output).map(&:chomp)
@@ -893,6 +899,24 @@ class TestGoFZF < TestBase
     File.unlink output rescue nil
   end
 
+  def test_execute_shell
+    # Custom script to use as $SHELL
+    output = tempname + '.out'
+    File.unlink output rescue nil
+    writelines tempname, ['#!/usr/bin/env bash', "echo $1 / $2 > #{output}", "sync"]
+    system "chmod +x #{tempname}"
+
+    tmux.send_keys "echo foo | SHELL=#{tempname} fzf --bind 'enter:execute:{}bar'", :Enter
+    tmux.until { |lines| lines[-2].include? '1/1' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-2].include? '1/1' }
+    tmux.send_keys 'C-c'
+    tmux.prepare
+    assert_equal ['-c / "foo"bar'], File.readlines(output).map(&:chomp)
+  ensure
+    File.unlink output rescue nil
+  end
+
   def test_cycle
     tmux.send_keys "seq 8 | #{fzf :cycle}", :Enter
     tmux.until { |lines| lines[-2].include? '8/8' }
@@ -919,12 +943,12 @@ class TestGoFZF < TestBase
         lines[-2].include?('/90') &&
         lines[-3]  == '  1' &&
         lines[-4]  == '  2' &&
-        lines[-13] == '> 15'
+        lines[-13] == '> 50'
       end
       tmux.send_keys :Down
     end
     tmux.send_keys :Enter
-    assert_equal '15', readonce.chomp
+    assert_equal '50', readonce.chomp
   end
 
   def test_header_lines_reverse
@@ -934,12 +958,12 @@ class TestGoFZF < TestBase
         lines[1].include?('/90') &&
         lines[2]  == '  1' &&
         lines[3]  == '  2' &&
-        lines[12] == '> 15'
+        lines[12] == '> 50'
       end
       tmux.send_keys :Up
     end
     tmux.send_keys :Enter
-    assert_equal '15', readonce.chomp
+    assert_equal '50', readonce.chomp
   end
 
   def test_header_lines_overflow
@@ -1121,10 +1145,22 @@ class TestGoFZF < TestBase
       `seq 10 | #{FZF} -f '1 | !1'`.lines.map(&:chomp)
   end
 
+  def test_hscroll_off
+    writelines tempname, ['=' * 10000 + '0123456789']
+    [0, 3, 6].each do |off|
+      tmux.prepare
+      tmux.send_keys "#{FZF} --hscroll-off=#{off} -q 0 < #{tempname}", :Enter
+      tmux.until { |lines| lines[-3].end_with?((0..off).to_a.join + '..') }
+      tmux.send_keys '9'
+      tmux.until { |lines| lines[-3].end_with? '789' }
+      tmux.send_keys :Enter
+    end
+  end
+
 private
   def writelines path, lines
     File.unlink path while File.exists? path
-    File.open(path, 'w') { |f| f << lines.join($/) }
+    File.open(path, 'w') { |f| f << lines.join($/) + $/ }
   end
 end
 
@@ -1269,7 +1305,7 @@ module CompletionTest
     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.send_keys 'C-K', :Enter
     tmux.until do |lines|
       tmux.send_keys 'C-L'
       lines[-1].end_with?('/tmp/fzf\ test/foobar')
@@ -1284,6 +1320,7 @@ module CompletionTest
       lines[-2].include?('100/') &&
       lines[-3].include?('/tmp/fzf-test/.hidden-')
     end
+    tmux.send_keys :Enter
   ensure
     ['/tmp/fzf-test', '/tmp/fzf test', '~/.fzf-home', 'no~such~user'].each do |f|
       FileUtils.rm_rf File.expand_path(f)
@@ -1342,6 +1379,39 @@ module CompletionTest
   ensure
     Process.kill 'KILL', pid.to_i rescue nil if pid
   end
+
+  def test_custom_completion
+    tmux.send_keys '_fzf_compgen_path() { echo "\$1"; seq 10; }', :Enter
+    tmux.prepare
+    tmux.send_keys 'ls /tmp/**', :Tab, pane: 0
+    tmux.until(1) { |lines| lines.item_count == 11 }
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.until(1) { |lines| lines[-2].include? '(3)' }
+    tmux.send_keys :Enter
+    tmux.until do |lines|
+      tmux.send_keys 'C-L'
+      lines[-1] == "ls /tmp 1 2"
+    end
+  end
+
+  def test_unset_completion
+    tmux.send_keys 'export FOO=BAR', :Enter
+    tmux.prepare
+
+    # Using tmux
+    tmux.send_keys 'unset FOO**', :Tab, pane: 0
+    tmux.until(1) { |lines| lines[-2].include? ' 1/' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == 'unset FOO' }
+    tmux.send_keys 'C-c'
+
+    # FZF_TMUX=0
+    new_shell
+    tmux.send_keys 'unset FOO**', :Tab
+    tmux.until { |lines| lines[-2].include? ' 1/' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == 'unset FOO' }
+  end
 end
 
 class TestBash < TestBase