0.11.4

Close #516

.gitignore

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

CHANGELOG.md

@@ -1,6 +1,56 @@
 CHANGELOG
 =========
 
+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
+------
+
+- `--tiebreak` now accepts comma-separated list of sort criteria
+    - Each criterion should appear only once in the list
+    - `index` is only allowed at the end of the list
+    - `index` is implicitly appended to the list when not specified
+    - Default is `length` (or equivalently `length,index`)
+- `begin` criterion will ignore leading whitespaces when calculating the index
+- Added `toggle-in` and `toggle-out` actions
+    - Switch direction depending on `--reverse`-ness
+    - `export FZF_DEFAULT_OPTS="--bind tab:toggle-out,shift-tab:toggle-in"`
+- Reduced the initial delay when `--tac` is not given
+    - fzf defers the initial rendering of the screen up to 100ms if the input
+      stream is ongoing to prevent unnecessary redraw during the initial
+      phase. However, 100ms delay is quite noticeable and might give the
+      impression that fzf is not snappy enough. This commit reduces the
+      maximum delay down to 20ms when `--tac` is not specified, in which case
+      the input list quickly fills the entire screen.
+
+0.11.1
+------
+
+- Added `--tabstop=SPACES` option
+
+0.11.0
+------
+
+- Added OR operator for extended-search mode
+- Added `--execute-multi` action
+- Fixed incorrect cursor position when unicode wide characters are used in
+  `--prompt`
+- Fixes and improvements in shell extensions
+
 0.10.9
 ------
 

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -50,10 +50,10 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
 
 ```sh
-brew reinstall --HEAD fzf
+brew install fzf
 
 # Install shell extensions
-/usr/local/Cellar/fzf/HEAD/install
+/usr/local/opt/fzf/install
 ```
 
 #### Install as Vim plugin
@@ -78,7 +78,7 @@ while. Please follow the instruction below depending on the installation
 method.
 
 - git: `cd ~/.fzf && git pull && ./install`
-- brew: `brew reinstall --HEAD fzf`
+- brew: `brew update; brew reinstall fzf`
 - vim-plug: `:PlugUpdate fzf`
 
 Usage
@@ -108,32 +108,41 @@ vim $(fzf)
 - Mouse: scroll, click, double-click; shift-click and shift-scroll on
   multi-select mode
 
-#### Extended-search mode
+#### Search syntax
 
-Since 0.10.9, fzf starts in "extended-search mode" by default.
+Unless otherwise specified, fzf starts in "extended-search mode" where you can
+type in multiple search terms delimited by spaces. e.g. `^music .mp3$ sbtrkt
+!rmx`
 
-In this mode, you can specify multiple patterns delimited by spaces,
+| Token    | Match type           | Description                      |
-such as: `^music .mp3$ sbtrkt !rmx`
+| -------- | -------------------- | -------------------------------- |
-
+| `sbtrkt` | fuzzy-match          | Items that match `sbtrkt`        |
-| Token    | Description                      | Match type           |
+| `^music` | prefix-exact-match   | Items that start with `music`    |
-| -------- | -------------------------------- | -------------------- |
+| `.mp3$`  | suffix-exact-match   | Items that end with `.mp3`       |
-| `^music` | Items that start with `music`    | prefix-exact-match   |
+| `'wild`  | exact-match (quoted) | Items that include `wild`        |
-| `.mp3$`  | Items that end with `.mp3`       | suffix-exact-match   |
+| `!rmx`   | inverse-fuzzy-match  | Items that do not match `rmx`    |
-| `sbtrkt` | Items that match `sbtrkt`        | fuzzy-match          |
+| `!'fire` | inverse-exact-match  | Items that do not include `fire` |
-| `!rmx`   | Items that do not match `rmx`    | inverse-fuzzy-match  |
-| `'wild`  | Items that include `wild`        | exact-match (quoted) |
-| `!'fire` | Items that do not include `fire` | inverse-exact-match  |
 
 If you don't prefer fuzzy matching and do not wish to "quote" every word,
 start fzf with `-e` or `--exact` option. Note that when  `--exact` is set,
 `'`-prefix "unquotes" the term.
 
+A single bar character term acts as an OR operator. For example, the following
+query matches entries that start with `core` and end with either `go`, `rb`,
+or `py`.
+
+```
+^core go$ | rb$ | py$
+```
+
 #### Environment variables
 
 - `FZF_DEFAULT_COMMAND`
     - Default command to use when input is tty
+    - e.g. `export FZF_DEFAULT_COMMAND='ag -g ""'`
 - `FZF_DEFAULT_OPTS`
-    - Default options. e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
+    - Default options
+    - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
 
 Examples
 --------
@@ -250,6 +259,25 @@ 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
+
+On bash, fuzzy completion is enabled only for a predefined set of commands
+(`complete | grep _fzf` to see the list). But you can enable it for other
+commands as well like follows.
+
+```sh
+# There are also _fzf_path_completion and _fzf_dir_completion
+complete -F _fzf_file_completion -o default -o bashdefault doge
 ```
 
 Usage as Vim plugin
@@ -335,10 +363,10 @@ filtering:
 
 ```sh
 # Feed the output of ag into fzf
-ag -l -g "" | fzf
+ag -g "" | fzf
 
 # Setting ag as the default source for fzf
-export FZF_DEFAULT_COMMAND='ag -l -g ""'
+export FZF_DEFAULT_COMMAND='ag -g ""'
 
 # Now fzf (w/o pipe) will use ag instead of find
 fzf

bin/fzf-tmux

@@ -82,11 +82,19 @@ while [ $# -gt 0 ]; do
   shift
 done
 
-if [ -z "$TMUX_PANE" ] || tmux list-panes -F '#F' | grep -q Z; then
+if [ -z "$TMUX" ]; then
   fzf "${args[@]}"
   exit $?
 fi
 
+# Handle zoomed tmux pane by moving it to a temp window
+if tmux list-panes -F '#F' | grep -q Z; then
+  zoomed=1
+  original_window=$(tmux display-message -p "#{window_id}")
+  tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - \\\\; do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
+  tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
+fi
+
 set -e
 
 # Clean up named pipes on exit
@@ -97,6 +105,14 @@ fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
 fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
 cleanup() {
   rm -f $argsf $fifo1 $fifo2 $fifo3
+
+  # Remove temp window if we were zoomed
+  if [ -n "$zoomed" ]; then
+    tmux swap-pane -t $original_window \; \
+      select-window -t $original_window \; \
+      kill-window -t $tmp_window \; \
+      resize-pane -Z
+  fi
 }
 trap cleanup EXIT SIGINT SIGTERM
 
@@ -111,8 +127,8 @@ envs="env TERM=$TERM "
 [ -n "$FZF_DEFAULT_OPTS"    ] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
 [ -n "$FZF_DEFAULT_COMMAND" ] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
 
-mkfifo $fifo2
+mkfifo -m o+w $fifo2
-mkfifo $fifo3
+mkfifo -m o+w $fifo3
 
 # Build arguments to fzf
 opts=""
@@ -125,11 +141,13 @@ done
 if [ -n "$term" -o -t 0 ]; then
   cat <<< "$fzf $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
   tmux set-window-option -q synchronize-panes off \;\
+    set-window-option -q remain-on-exit off \;\
     split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap
 else
   mkfifo $fifo1
   cat <<< "$fzf $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
   tmux set-window-option -q synchronize-panes off \;\
+    set-window-option -q remain-on-exit off \;\
     split-window $opt "$envs bash $argsf" $swap
   cat <&0 > $fifo1 &
 fi

fzf

@@ -370,7 +370,7 @@ class FZF
     +i                    Case-sensitive match
     -n, --nth=N[,..]      Comma-separated list of field index expressions
                           for limiting search scope. Each can be a non-zero
-                          integer or a range expression ([BEGIN]..[END])
+                          integer or a range expression ([BEGIN]..[END]).
         --with-nth=N[,..] Transform the item using index expressions for search
     -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
 
@@ -396,7 +396,7 @@ class FZF
 
   Environment variables
     FZF_DEFAULT_COMMAND   Default command to use when input is tty
-    FZF_DEFAULT_OPTS      Defaults options. (e.g. "-x -m --sort 10000")] + $/ + $/
+    FZF_DEFAULT_OPTS      Default options (e.g. "-x -m --sort 10000")] + $/ + $/
    exit x
   end
 

install

@@ -2,25 +2,28 @@
 
 set -u
 
-[[ "$@" =~ --pre ]] && version=0.10.9 pre=1 ||
+[[ "$@" =~ --pre ]] && version=0.11.4 pre=1 ||
-                       version=0.10.9 pre=0
+                       version=0.11.4 pre=0
 
 auto_completion=
 key_bindings=
 update_config=1
+binary_arch=
 
 help() {
   cat << EOF
 usage: $0 [OPTIONS]
 
     --help               Show this message
-    --bin                Download fzf binary only
+    --bin                Download fzf binary only; Do not generate ~/.fzf.{bash,zsh}
     --all                Download fzf binary and update configuration files
                          to enable key bindings and fuzzy completion
     --[no-]key-bindings  Enable/disable key bindings (CTRL-T, CTRL-R, ALT-C)
     --[no-]completion    Enable/disable fuzzy completion (bash & zsh)
     --[no-]update-rc     Whether or not to update shell configuration files
 
+    --32                 Download 32-bit binary
+    --64                 Download 64-bit binary
 EOF
 }
 
@@ -41,6 +44,8 @@ for opt in $@; do
     --no-completion)   auto_completion=0 ;;
     --update-rc)       update_config=1   ;;
     --no-update-rc)    update_config=0   ;;
+    --32)              binary_arch=386   ;;
+    --64)              binary_arch=amd64 ;;
     --bin)             ;;
     *)
       echo "unknown option: $opt"
@@ -97,6 +102,16 @@ symlink() {
   fi
 }
 
+link_fzf_in_path() {
+  if which_fzf="$(which fzf 2> /dev/null)"; 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
@@ -107,12 +122,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
@@ -143,21 +153,14 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ x86_64) download fzf-$version-darwin_amd64 ;;
+  Darwin\ x86_64) download fzf-$version-darwin_${binary_arch:-amd64} ;;
-  Darwin\ i*86)   download fzf-$version-darwin_386   ;;
+  Darwin\ i*86)   download fzf-$version-darwin_${binary_arch:-386}   ;;
-  Linux\ x86_64)  download fzf-$version-linux_amd64  ;;
+  Linux\ x86_64)  download fzf-$version-linux_${binary_arch:-amd64}  ;;
-  Linux\ i*86)    download fzf-$version-linux_386    ;;
+  Linux\ i*86)    download fzf-$version-linux_${binary_arch:-386}    ;;
   *)              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
@@ -223,6 +226,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 which go > /dev/null 2>&1; 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
@@ -342,7 +368,8 @@ append_line() {
 
 echo
 for shell in bash zsh; do
-  append_line $update_config "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" ~/.${shell}rc "~/.fzf.${shell}"
+  [ $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
@@ -353,7 +380,7 @@ fi
 cat << EOF
 Finished. Restart your shell or reload config file.
    source ~/.bashrc  # bash
-   source ~/.zshrc   # zsh
+   source ${ZDOTDIR:-~}/.zshrc   # zsh
 EOF
 [ $has_fish -eq 1 ] && echo "   fzf_key_bindings  # fish"; cat << EOF
 

man/man1/fzf.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Nov 2015" "fzf 0.10.9" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Mar 2016" "fzf 0.11.4" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -68,10 +68,10 @@ Reverse the order of the input
 e.g. \fBhistory | fzf --tac --no-sort\fR
 .RE
 .TP
-.BI "--tiebreak=" "CRI"
+.BI "--tiebreak=" "CRI[,..]"
-Sort criterion to use when the scores are tied
+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,6 +81,15 @@ Sort criterion to use when the scores are tied
 .br
 .BR index "   Prefers item that appeared earlier in the input stream"
 .br
+
+.br
+- Each criterion should appear only once in the list
+.br
+- \fBindex\fR is only allowed at the end of the list
+.br
+- \fBindex\fR is implicitly appended to the list when not specified
+.br
+- Default is \fBlength\fR (or equivalently \fBlength\fR,index)
 .SS Interface
 .TP
 .B "-m, --multi"
@@ -135,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"
@@ -146,23 +155,31 @@ 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
 .RE
 .TP
+.BI "--tabstop=" SPACES
+Number of spaces for a tab character (default: 8)
+.TP
 .B "--cycle"
 Enable cyclic scroll
 .TP
 .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
@@ -207,7 +224,7 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
 .RE
 
 .RS
-  \fBACTION:               DEFAULT BINDINGS:
+  \fBACTION:               DEFAULT BINDINGS (NOTES):
     \fBabort\fR                 \fIctrl-c  ctrl-g  ctrl-q  esc\fR
     \fBaccept\fR                \fIenter   double-click\fR
     \fBbackward-char\fR         \fIctrl-b  left\fR
@@ -223,6 +240,7 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBdown\fR                  \fIctrl-j  ctrl-n  down\fR
     \fBend-of-line\fR           \fIctrl-e  end\fR
     \fBexecute(...)\fR          (see below for the details)
+    \fBexecute-multi(...)\fR    (see below for the details)
     \fBforward-char\fR          \fIctrl-f  right\fR
     \fBforward-word\fR          \fIalt-f   shift-right\fR
     \fBignore\fR
@@ -236,6 +254,8 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fBtoggle\fR
     \fBtoggle-all\fR
     \fBtoggle-down\fR           \fIctrl-i  (tab)\fR
+    \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle-up\fR : \fBtoggle-down\fR)
+    \fBtoggle-out\fR            (\fB--reverse\fR ? \fBtoggle-down\fR : \fBtoggle-up\fR)
     \fBtoggle-sort\fR           (equivalent to \fB--toggle-sort\fR)
     \fBtoggle-up\fR             \fIbtab    (shift-tab)\fR
     \fBunix-line-discard\fR     \fIctrl-u\fR
@@ -276,6 +296,12 @@ This is the special form that frees you from parse errors as it does not expect
 the closing character. The catch is that it should be the last one in the
 comma-separated list.
 .RE
+
+\fBexecute-multi(...)\fR is an alternative action that executes the command
+with the selected entries when multi-select is enabled (\fB--multi\fR). With
+this action, \fB{}\fR is replaced with the double-quoted strings of the
+selected entries separated by spaces.
+
 .RE
 .TP
 .BI "--history=" "HISTORY_FILE"
@@ -343,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
 
@@ -394,6 +424,13 @@ If you don't prefer fuzzy matching and do not wish to "quote" (prefixing with
 \fB'\fR) every word, start fzf with \fB-e\fR or \fB--exact\fR option. Note that
 when \fB--exact\fR is set, \fB'\fR-prefix "unquotes" the term.
 
+.SS OR operator
+A single bar character term acts as an OR operator. For example, the following
+query matches entries that start with \fBcore\fR and end with either \fBgo\fR,
+\fBrb\fR, or \fBpy\fR.
+
+e.g. \fB^core go$ | rb$ | py$\fR
+
 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)
 
@@ -403,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

@@ -1,4 +1,4 @@
-" Copyright (c) 2015 Junegunn Choi
+" Copyright (c) 2016 Junegunn Choi
 "
 " MIT License
 "
@@ -52,17 +52,13 @@ function! s:fzf_exec()
   return s:exec
 endfunction
 
-function! s:tmux_not_zoomed()
-  return system('tmux list-panes -F "#F"') !~# 'Z'
-endfunction
-
 function! s:tmux_enabled()
   if has('gui_running')
     return 0
   endif
 
   if exists('s:tmux')
-    return s:tmux && s:tmux_not_zoomed()
+    return s:tmux
   endif
 
   let s:tmux = 0
@@ -70,7 +66,7 @@ function! s:tmux_enabled()
     let output = system('tmux -V')
     let s:tmux = !v:shell_error && output >= 'tmux 1.7'
   endif
-  return s:tmux && s:tmux_not_zoomed()
+  return s:tmux
 endfunction
 
 function! s:shellesc(arg)
@@ -143,17 +139,13 @@ try
   let tmux = !has('nvim') && s:tmux_enabled() && s:splittable(dict)
   let command = prefix.(tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
-  try
+  if has('nvim')
-    if tmux
+    return s:execute_term(dict, command, temps)
-      return s:execute_tmux(dict, command, temps)
+  endif
-    elseif has('nvim')
+
-      return s:execute_term(dict, command, temps)
+  let ret = tmux ? s:execute_tmux(dict, command, temps) : s:execute(dict, command, temps)
-    else
+  call s:popd(dict, ret)
-      return s:execute(dict, command, temps)
+  return ret
-    endif
-  finally
-    call s:popd(dict)
-  endtry
 finally
   let &shell = oshell
 endtry
@@ -197,16 +189,28 @@ function! s:pushd(dict)
       return 1
     endif
     let a:dict.prev_dir = cwd
-    execute 'chdir '.s:escape(a:dict.dir)
+    execute 'chdir' s:escape(a:dict.dir)
     let a:dict.dir = getcwd()
     return 1
   endif
   return 0
 endfunction
 
-function! s:popd(dict)
+function! s:popd(dict, lines)
-  if has_key(a:dict, 'prev_dir')
+  " Since anything can be done in the sink function, there is no telling that
-    execute 'chdir '.s:escape(remove(a:dict, 'prev_dir'))
+  " the change of the working directory was made by &autochdir setting.
+  "
+  " We use the following heuristic to determine whether to restore CWD:
+  " - Always restore the current directory when &autochdir is disabled.
+  "   FIXME This makes it impossible to change directory from inside the sink
+  "   function when &autochdir is not used.
+  " - In case of an error or an interrupt, a:lines will be empty.
+  "   And it will be an array of a single empty string when fzf was finished
+  "   without a match. In these cases, we presume that the change of the
+  "   directory is not expected and should be undone.
+  if has_key(a:dict, 'prev_dir') &&
+        \ (!&autochdir || (empty(a:lines) || len(a:lines) == 1 && empty(a:lines[0])))
+    execute 'chdir' s:escape(remove(a:dict, 'prev_dir'))
   endif
 endfunction
 
@@ -235,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'), '%#')
@@ -251,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
@@ -316,9 +320,8 @@ function! s:split(dict)
   endtry
 endfunction
 
-function! s:execute_term(dict, command, temps)
+function! s:execute_term(dict, command, temps) abort
   call s:split(a:dict)
-  call s:pushd(a:dict)
 
   let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps, 'name': 'FZF' }
   let s:command = a:command
@@ -341,8 +344,9 @@ function! s:execute_term(dict, command, temps)
     endif
 
     call s:pushd(self.dict)
+    let ret = []
     try
-      call s:callback(self.dict, self.temps)
+      let ret = s:callback(self.dict, self.temps)
 
       if inplace && bufnr('') == self.buf
         execute "normal! \<c-^>"
@@ -352,21 +356,23 @@ function! s:execute_term(dict, command, temps)
         endif
       endif
     finally
-      call s:popd(self.dict)
+      call s:popd(self.dict, ret)
     endtry
   endfunction
 
+  call s:pushd(a:dict)
   call termopen(a:command, fzf)
+  call s:popd(a:dict, [])
+  setlocal nospell
   setf fzf
   startinsert
   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
@@ -385,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
 
@@ -413,10 +419,16 @@ function! s:cmd_callback(lines) abort
     augroup END
   endif
   try
+    let empty = empty(expand('%')) && line('$') == 1 && empty(getline(1)) && !&modified
     let autochdir = &autochdir
     set noautochdir
     for item in a:lines
-      execute cmd s:escape(item)
+      if empty
+        execute 'e' s:escape(item)
+        let empty = 0
+      else
+        execute cmd s:escape(item)
+      endif
       if exists('#BufEnter') && isdirectory(item)
         doautocmd BufEnter
       endif

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,31 +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/#\/}
-        [ "$dir" = './' ] && dir=''
+        [ -z "$dir" ] && dir='.'
+        [ "$dir" != "/" ] && dir="${dir/%\//}"
         tput sc
-        matches=$(find -L "$dir"* $1 2> /dev/null | $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% }
@@ -135,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")
@@ -170,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 -print -o -type f -print -o -type l -print" \
-    "-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 -print -o -type l -print" \
-    "-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 -print" \
-    "" "/" "$@"
 }
 
 _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
@@ -238,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="
-  awk cat diff diff3
-  emacs ex file ftp g++ gcc gvim head hg java
-  javac ld less more mvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc"
 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
   basename bunzip2 bzip2 chmod chown curl cp dirname du
   find git grep gunzip gzip hg jar
   ln ls mv open rm rsync scp
@@ -252,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
@@ -277,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
@@ -306,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,18 +10,38 @@
 # - $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
   [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
-  if ! setopt | grep nonomatch > /dev/null; then
+  if ! setopt | \grep nonomatch > /dev/null; then
     nnm=1
     setopt nonomatch
   fi
@@ -30,9 +50,10 @@ __fzf_generic_path_completion() {
     if [ -z "$dir" -o -d ${~dir} ]; then
       leftover=${base/#"$dir"}
       leftover=${leftover/#\/}
-      [ "$dir" = './' ] && dir=''
+      [ -z "$dir" ] && dir='.'
+      [ "$dir" != "/" ] && 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
+      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% }
@@ -49,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 -print -o -type f -print -o -type l -print" \
     "-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 -print" \
     "" "/" ""
 }
 
 _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
@@ -116,11 +138,8 @@ _fzf_complete_unalias() {
 }
 
 fzf-completion() {
-  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds sws
+  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds
-  if setopt | grep shwordsplit > /dev/null; then
+  setopt localoptions noshwordsplit
-    sws=1
-    unsetopt shwordsplit
-  fi
 
   # http://zsh.sourceforge.net/FAQ/zshfaq03.html
   # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
@@ -147,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]}}
@@ -163,12 +182,10 @@ fzf-completion() {
   else
     eval "zle ${fzf_default_completion:-expand-or-complete}"
   fi
-  [ -n "$sws" ] && setopt shwordsplit
 }
 
 [ -z "$fzf_default_completion" ] &&
-  fzf_default_completion=$(bindkey '^I' | grep -v undefined-key | awk '{print $2}')
+  fzf_default_completion=$(bindkey '^I' | \grep -v undefined-key | awk '{print $2}')
 
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
-

shell/key-bindings.bash

@@ -1,11 +1,11 @@
 # Key bindings
 # ------------
 __fzf_select__() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command \\find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
-  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__() {
@@ -25,13 +25,23 @@ __fzf_select_tmux__() {
   else
     height="-l $height"
   fi
-  tmux split-window $height "cd $(printf %q "$PWD"); FZF_CTRL_T_COMMAND=$(printf %q "$FZF_CTRL_T_COMMAND") bash -c 'source ~/.fzf.bash; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
+
+  tmux split-window $height "cd $(printf %q "$PWD"); FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS") PATH=$(printf %q "$PATH") FZF_CTRL_T_COMMAND=$(printf %q "$FZF_CTRL_T_COMMAND") bash -c 'source \"${BASH_SOURCE[0]}\"; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
+}
+
+__fzf_select_tmux_auto__() {
+  if [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ]; then
+    __fzf_select_tmux__
+  else
+    tmux send-keys -t "$TMUX_PANE" "$(__fzf_select__)"
+  fi
 }
 
 __fzf_cd__() {
-  local dir
+  local cmd dir
-  dir=$(command \find -L ${1:-.} \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+  cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m) && printf 'cd %q' "$dir"
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+  dir=$(eval "$cmd" | $(__fzfcmd) +m) && printf 'cd %q' "$dir"
 }
 
 __fzf_history__() (
@@ -49,7 +59,11 @@ __fzf_history__() (
 )
 
 __use_tmux=0
-[ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
+__use_tmux_auto=0
+if [ -n "$TMUX_PANE" ]; then
+  [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ] && __use_tmux=1
+  [ $BASH_VERSINFO -gt 3 ] && __use_tmux_auto=1
+fi
 
 if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   # Required to refresh the prompt after fzf
@@ -57,7 +71,9 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   bind '"\e^": history-expand-line'
 
   # CTRL-T - Paste the selected file path into the command line
-  if [ $__use_tmux -eq 1 ]; then
+  if [ $__use_tmux_auto -eq 1 ]; then
+    bind -x '"\C-t": "__fzf_select_tmux_auto__"'
+  elif [ $__use_tmux -eq 1 ]; then
     bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select_tmux__)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
   else
     bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select__)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
@@ -75,7 +91,9 @@ else
 
   # CTRL-T - Paste the selected file path into the command line
   # - FIXME: Selected items are attached to the end regardless of cursor position
-  if [ $__use_tmux -eq 1 ]; then
+  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"'
   else
     bind '"\C-t": "\e$a \eddi$(__fzf_select__)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
@@ -91,6 +109,6 @@ else
   bind -m vi-command '"\ec": "i\ec"'
 fi
 
-unset __use_tmux
+unset -v __use_tmux __use_tmux_auto
 
 fi

shell/key-bindings.fish

@@ -20,6 +20,7 @@ function fzf_key_bindings
       -o -type d -print \
       -o -type l -print 2> /dev/null | sed 1d | cut -b3-"
     eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)" -m > $TMPDIR/fzf.result"
+    and sleep 0
     and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result
@@ -33,9 +34,11 @@ function fzf_key_bindings
   end
 
   function __fzf_alt_c
+    set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
+    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+      -o -type d -print 2> /dev/null | sed 1d | cut -b3-"
     # Fish hangs if the command before pipe redirects (2> /dev/null)
-    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) \
+    eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m > $TMPDIR/fzf.result"
-      -prune -o -type d -print 2> /dev/null | sed 1d | cut -b3- | eval (__fzfcmd) +m > $TMPDIR/fzf.result
     [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
     and cd (cat $TMPDIR/fzf.result)
     commandline -f repaint

shell/key-bindings.zsh

@@ -4,7 +4,7 @@ if [[ $- == *i* ]]; then
 
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command \\find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
@@ -27,8 +27,9 @@ bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  cd "${$(command \find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m):-.}"
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+  cd "${$(eval "$cmd" | $(__fzfcmd) +m):-.}"
   zle reset-prompt
 }
 zle     -N    fzf-cd-widget
@@ -36,8 +37,9 @@ bindkey '\ec' fzf-cd-widget
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  local selected restore_no_bang_hist
+  local selected num
-  if selected=( $(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r -q "$LBUFFER") ); then
+  selected=( $(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r -q "${LBUFFER//$/\\$}") )
+  if [ -n "$selected" ]; then
     num=$selected[1]
     if [ -n "$num" ]; then
       zle vi-fetch-history -n $num

src/Dockerfile.android

@@ -0,0 +1,40 @@
+FROM ubuntu:14.04
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN apt-get update && apt-get -y upgrade && \
+    apt-get install -y --force-yes git curl build-essential
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4 && \
+    sed -i 's@#define PTHREAD_KEYS_MAX 128@@' /go1.4/src/runtime/cgo/gcc_android_arm.c
+
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+RUN cd / && \
+    curl -O http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin && \
+    chmod 755 /android-ndk* && /android-ndk-r10e-linux-x86_64.bin && \
+    mv android-ndk-r10e /android-ndk
+
+RUN cd /android-ndk && bash ./build/tools/make-standalone-toolchain.sh --platform=android-21 --install-dir=/ndk --arch=arm
+
+ENV NDK_CC /ndk/bin/arm-linux-androideabi-gcc
+
+RUN cd $GOROOT/src && \
+    CC_FOR_TARGET=$NDK_CC GOOS=android GOARCH=arm GOARM=7 ./make.bash
+
+RUN cd / && curl \
+    http://ftp.gnu.org/gnu/ncurses/ncurses-5.9.tar.gz | \
+    tar -xz && cd /ncurses-5.9 && \
+    ./configure CC=$NDK_CC CFLAGS="-fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch" LDFLAGS="-march=armv7-a -Wl,--no-warn-mismatch" --host=arm-linux --enable-overwrite --enable-const --without-cxx-binding  --without-shared --without-debug --enable-widec --enable-ext-colors --enable-ext-mouse --enable-pc-files --with-pkg-config-libdir=$PKG_CONFIG_LIBDIR --without-manpages --without-ada --disable-shared --without-tests --prefix=/ndk/sysroot/usr --with-default-terminfo-dirs=/usr/share/terminfo --with-terminfo-dirs=/usr/share/terminfo ac_cv_header_locale_h=n ac_cv_func_getpwent=no ac_cv_func_getpwnam=no ac_cv_func_getpwuid=no && \
+    sed -i 's@#define HAVE_LOCALE_H 1@/* #undef HAVE_LOCALE_H */@' include/ncurses_cfg.h && \
+    make && \
+    sed -i '0,/echo.*/{s/echo.*/exit 0/}' misc/run_tic.sh && \
+    make install && \
+    mv /ndk/sysroot/usr/lib/libncursesw.a /ndk/sysroot/usr/lib/libncurses.a
+
+# Default CMD
+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

@@ -11,16 +11,18 @@ RUN cd / && curl \
     https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
-ENV GOPATH /go
+# Install Go 1.5
-ENV GOROOT /go1.4
+RUN cd / && curl \
-ENV PATH /go1.4/bin:$PATH
+    https://storage.googleapis.com/golang/go1.5.3.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.5
+
+ENV GOROOT_BOOTSTRAP /go1.4
+ENV GOROOT /go1.5
+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/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/Makefile

@@ -1,39 +1,55 @@
-ifndef GOPATH
+ifndef GOOS
-$(error GOPATH is undefined)
-endif
-
 UNAME_S := $(shell uname -s)
 ifeq ($(UNAME_S),Darwin)
 	GOOS := darwin
 else ifeq ($(UNAME_S),Linux)
 	GOOS := linux
 endif
+endif
 
 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
-BINARY32  := fzf-$(GOOS)_386
+GOPATH      := $(shell dirname $(ROOTDIR))/gopath
-BINARY64  := fzf-$(GOOS)_amd64
+SRCDIR      := $(GOPATH)/src/github.com/junegunn/fzf/src
-VERSION    = $(shell fzf/$(BINARY64) --version)
+DOCKEROPTS  := -i -t -v $(ROOTDIR):/fzf/src
-RELEASE32  = fzf-$(VERSION)-$(GOOS)_386
+BINARY32    := fzf-$(GOOS)_386
-RELEASE64  = fzf-$(VERSION)-$(GOOS)_amd64
+BINARY64    := fzf-$(GOOS)_amd64
+BINARYARM7  := fzf-$(GOOS)_arm7
+VERSION     := $(shell awk -F= '/version =/ {print $$2}' constants.go | tr -d "\" ")
+RELEASE32   := fzf-$(VERSION)-$(GOOS)_386
+RELEASE64   := fzf-$(VERSION)-$(GOOS)_amd64
+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)
 
-test:
+$(SRCDIR):
-	go get
+	mkdir -p $(shell dirname $(SRCDIR))
-	go test -v ./...
+	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: deps
+	SHELL=/bin/sh go test -v ./...
 
 install: $(BINDIR)/fzf
 
@@ -43,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)
 
-fzf/$(BINARY64): $(SOURCES)
+fzf/$(BINARY64): deps
 	cd fzf && go build -a -tags "$(TAGS)" -o $(BINARY64)
 
 $(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
@@ -65,21 +81,33 @@ docker-ubuntu:
 docker-centos:
 	docker build -t junegunn/centos-sandbox - < Dockerfile.centos
 
+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'
 
-.PHONY: all build release test install uninstall clean docker \
+ubuntu-android: docker-android
-	linux arch ubuntu centos docker-arch docker-ubuntu docker-centos
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
+		sh -c 'cd /fzf/src; /bin/bash'
+
+android: docker-android
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
+		/bin/bash -ci 'cd /fzf/src; GOOS=android make android-build'
+
+.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/chunklist_test.go

@@ -6,8 +6,11 @@ import (
 )
 
 func TestChunkList(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byMatchLen, byLength}
+
 	cl := NewChunkList(func(s []byte, i int) *Item {
-		return &Item{text: []rune(string(s)), rank: Rank{0, 0, uint32(i * 2)}}
+		return &Item{text: []rune(string(s)), rank: buildEmptyRank(int32(i * 2))}
 	})
 
 	// Snapshot
@@ -36,8 +39,11 @@ func TestChunkList(t *testing.T) {
 	if len(*chunk1) != 2 {
 		t.Error("Snapshot should contain only two items")
 	}
-	if string((*chunk1)[0].text) != "hello" || (*chunk1)[0].rank.index != 0 ||
+	last := func(arr [5]int32) int32 {
-		string((*chunk1)[1].text) != "world" || (*chunk1)[1].rank.index != 2 {
+		return arr[len(arr)-1]
+	}
+	if string((*chunk1)[0].text) != "hello" || last((*chunk1)[0].rank) != 0 ||
+		string((*chunk1)[1].text) != "world" || last((*chunk1)[1].rank) != 2 {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {

src/constants.go

@@ -8,7 +8,7 @@ import (
 
 const (
 	// Current version
-	version = "0.10.9"
+	version = "0.11.4"
 
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
@@ -18,7 +18,8 @@ const (
 	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
 
 	// Terminal
-	initialDelay    = 100 * time.Millisecond
+	initialDelay    = 20 * time.Millisecond
+	initialDelayTac = 100 * time.Millisecond
 	spinnerDuration = 200 * time.Millisecond
 
 	// Matcher

src/core.go

@@ -3,7 +3,7 @@ Package fzf implements fzf, a command-line fuzzy finder.
 
 The MIT License (MIT)
 
-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -52,7 +52,7 @@ func Run(opts *Options) {
 	initProcs()
 
 	sort := opts.Sort > 0
-	rankTiebreak = opts.Tiebreak
+	sortCriteria = opts.Criteria
 
 	if opts.Version {
 		fmt.Println(version)
@@ -103,9 +103,8 @@ func Run(opts *Options) {
 			runes, colors := ansiProcessor(data)
 			return &Item{
 				text:   runes,
-				index:  uint32(index),
 				colors: colors,
-				rank:   Rank{0, 0, uint32(index)}}
+				rank:   buildEmptyRank(int32(index))}
 		})
 	} else {
 		chunkList = NewChunkList(func(data []byte, index int) *Item {
@@ -120,9 +119,8 @@ func Run(opts *Options) {
 			item := Item{
 				text:     joinTokens(trans),
 				origText: &runes,
-				index:    uint32(index),
 				colors:   nil,
-				rank:     Rank{0, 0, uint32(index)}}
+				rank:     buildEmptyRank(int32(index))}
 
 			trimmed, colors := ansiProcessorRunes(item.text)
 			item.text = trimmed
@@ -141,9 +139,19 @@ func Run(opts *Options) {
 	}
 
 	// Matcher
+	forward := true
+	for _, cri := range opts.Criteria[1:] {
+		if cri == byEnd {
+			forward = false
+			break
+		}
+		if cri == byBegin {
+			break
+		}
+	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Fuzzy, opts.Extended, opts.Case, opts.Tiebreak != byEnd,
+			opts.Fuzzy, opts.Extended, opts.Case, forward,
 			opts.Nth, opts.Delimiter, runes)
 	}
 	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)

src/curses/curses.go

@@ -5,6 +5,12 @@ package curses
 #include <locale.h>
 #cgo !static LDFLAGS: -lncurses
 #cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
+#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
+
+SCREEN *c_newterm () {
+	return newterm(NULL, stderr, stdin);
+}
+
 */
 import "C"
 
@@ -260,7 +266,7 @@ func Init(theme *ColorTheme, black bool, mouse bool) {
 	}
 
 	C.setlocale(C.LC_ALL, C.CString(""))
-	_screen = C.newterm(nil, C.stderr, C.stdin)
+	_screen = C.c_newterm()
 	if _screen == nil {
 		fmt.Println("Invalid $TERM: " + os.Getenv("TERM"))
 		os.Exit(2)

src/item.go

@@ -20,31 +20,41 @@ type Item struct {
 	text        []rune
 	origText    *[]rune
 	transformed []Token
-	index       uint32
 	offsets     []Offset
 	colors      []ansiOffset
-	rank        Rank
+	rank        [5]int32
 }
 
-// Rank is used to sort the search result
+// Sort criteria to use. Never changes once fzf is started.
-type Rank struct {
+var sortCriteria []criterion
-	matchlen uint16
+
-	tiebreak uint16
+func isRankValid(rank [5]int32) bool {
-	index    uint32
+	// Exclude ordinal index
+	for _, r := range rank[:4] {
+		if r > 0 {
+			return true
+		}
+	}
+	return false
 }
 
-// Tiebreak criterion to use. Never changes once fzf is started.
+func buildEmptyRank(index int32) [5]int32 {
-var rankTiebreak tiebreak
+	return [5]int32{0, 0, 0, 0, index}
+}
+
+func (item *Item) Index() int32 {
+	return item.rank[4]
+}
 
 // Rank calculates rank of the Item
-func (item *Item) Rank(cache bool) Rank {
+func (item *Item) Rank(cache bool) [5]int32 {
-	if cache && (item.rank.matchlen > 0 || item.rank.tiebreak > 0) {
+	if cache && isRankValid(item.rank) {
 		return item.rank
 	}
 	matchlen := 0
 	prevEnd := 0
 	lenSum := 0
-	minBegin := math.MaxUint16
+	minBegin := math.MaxInt32
 	for _, offset := range item.offsets {
 		begin := int(offset[0])
 		end := int(offset[1])
@@ -63,30 +73,43 @@ func (item *Item) Rank(cache bool) Rank {
 			matchlen += end - begin
 		}
 	}
-	var tiebreak uint16
+	if matchlen == 0 {
-	switch rankTiebreak {
+		matchlen = math.MaxInt32
-	case byLength:
+	}
-		// It is guaranteed that .transformed in not null in normal execution
+	rank := buildEmptyRank(item.Index())
-		if item.transformed != nil {
+	for idx, criterion := range sortCriteria {
-			// If offsets is empty, lenSum will be 0, but we don't care
+		var val int32
-			tiebreak = uint16(lenSum)
+		switch criterion {
-		} else {
+		case byMatchLen:
-			tiebreak = uint16(len(item.text))
+			val = int32(matchlen)
-		}
+		case byLength:
-	case byBegin:
+			// It is guaranteed that .transformed in not null in normal execution
-		// We can't just look at item.offsets[0][0] because it can be an inverse term
+			if item.transformed != nil {
-		tiebreak = uint16(minBegin)
+				// If offsets is empty, lenSum will be 0, but we don't care
-	case byEnd:
+				val = int32(lenSum)
-		if prevEnd > 0 {
+			} else {
-			tiebreak = uint16(1 + len(item.text) - prevEnd)
+				val = int32(len(item.text))
-		} else {
+			}
-			// Empty offsets due to inverse terms.
+		case byBegin:
-			tiebreak = 1
+			// We can't just look at item.offsets[0][0] because it can be an inverse term
-		}
+			whitePrefixLen := 0
-	case byIndex:
+			for idx, r := range item.text {
-		tiebreak = 1
+				whitePrefixLen = idx
+				if idx == minBegin || r != ' ' && r != '\t' {
+					break
+				}
+			}
+			val = int32(minBegin - whitePrefixLen)
+		case byEnd:
+			if prevEnd > 0 {
+				val = int32(1 + len(item.text) - prevEnd)
+			} else {
+				// Empty offsets due to inverse terms.
+				val = 1
+			}
+		}
+		rank[idx] = val
 	}
-	rank := Rank{uint16(matchlen), tiebreak, item.index}
 	if cache {
 		item.rank = rank
 	}
@@ -251,18 +274,15 @@ func (a ByRelevanceTac) Less(i, j int) bool {
 	return compareRanks(irank, jrank, true)
 }
 
-func compareRanks(irank Rank, jrank Rank, tac bool) bool {
+func compareRanks(irank [5]int32, jrank [5]int32, tac bool) bool {
-	if irank.matchlen < jrank.matchlen {
+	for idx := 0; idx < 4; idx++ {
-		return true
+		left := irank[idx]
-	} else if irank.matchlen > jrank.matchlen {
+		right := jrank[idx]
-		return false
+		if left < right {
+			return true
+		} else if left > right {
+			return false
+		}
 	}
-
+	return (irank[4] <= jrank[4]) != tac
-	if irank.tiebreak < jrank.tiebreak {
-		return true
-	} else if irank.tiebreak > jrank.tiebreak {
-		return false
-	}
-
-	return (irank.index <= jrank.index) != tac
 }

src/item_test.go

@@ -1,6 +1,7 @@
 package fzf
 
 import (
+	"math"
 	"sort"
 	"testing"
 
@@ -22,31 +23,34 @@ func TestOffsetSort(t *testing.T) {
 }
 
 func TestRankComparison(t *testing.T) {
-	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, false) ||
+	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, false) ||
-		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
+		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, false) ||
+		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, false) ||
-		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
+		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
 		t.Error("Invalid order")
 	}
 
-	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, true) ||
+	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, true) ||
-		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
+		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, true) ||
+		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, true) ||
-		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
+		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
 		t.Error("Invalid order (tac)")
 	}
 }
 
 // Match length, string length, index
 func TestItemRank(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byMatchLen, byLength}
+
 	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
-	item1 := Item{text: strs[0], index: 1, offsets: []Offset{}}
+	item1 := Item{text: strs[0], offsets: []Offset{}, rank: [5]int32{0, 0, 0, 0, 1}}
 	rank1 := item1.Rank(true)
-	if rank1.matchlen != 0 || rank1.tiebreak != 3 || rank1.index != 1 {
+	if rank1[0] != math.MaxInt32 || rank1[1] != 3 || rank1[4] != 1 {
 		t.Error(item1.Rank(true))
 	}
 	// Only differ in index
-	item2 := Item{text: strs[0], index: 0, offsets: []Offset{}}
+	item2 := Item{text: strs[0], offsets: []Offset{}}
 
 	items := []*Item{&item1, &item2}
 	sort.Sort(ByRelevance(items))
@@ -62,15 +66,15 @@ func TestItemRank(t *testing.T) {
 	}
 
 	// Sort by relevance
-	item3 := Item{text: strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item3 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item4 := Item{text: strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item4 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
-	item5 := Item{text: strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item5 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item6 := Item{text: strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item6 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
 	items = []*Item{&item1, &item2, &item3, &item4, &item5, &item6}
 	sort.Sort(ByRelevance(items))
-	if items[0] != &item2 || items[1] != &item1 ||
+	if items[0] != &item6 || items[1] != &item4 ||
-		items[2] != &item6 || items[3] != &item4 ||
+		items[2] != &item5 || items[3] != &item3 ||
-		items[4] != &item5 || items[5] != &item3 {
+		items[4] != &item2 || items[5] != &item1 {
 		t.Error(items)
 	}
 }

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/merger.go

@@ -88,7 +88,7 @@ func (mg *Merger) cacheable() bool {
 
 func (mg *Merger) mergedGet(idx int) *Item {
 	for i := len(mg.merged); i <= idx; i++ {
-		minRank := Rank{0, 0, 0}
+		minRank := buildEmptyRank(0)
 		minIdx := -1
 		for listIdx, list := range mg.lists {
 			cursor := mg.cursors[listIdx]

src/merger_test.go

@@ -23,7 +23,7 @@ func randItem() *Item {
 	}
 	return &Item{
 		text:    []rune(str),
-		index:   rand.Uint32(),
+		rank:    buildEmptyRank(rand.Int31()),
 		offsets: offsets}
 }
 

src/options.go

@@ -22,12 +22,13 @@ const usage = `usage: fzf [options]
     +i                    Case-sensitive match
     -n, --nth=N[,..]      Comma-separated list of field index expressions
                           for limiting search scope. Each can be a non-zero
-                          integer or a range expression ([BEGIN]..[END])
+                          integer or a range expression ([BEGIN]..[END]).
     --with-nth=N[,..]     Transform item using index expressions within finder
     -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
     +s, --no-sort         Do not sort the result
     --tac                 Reverse the order of the input
-    --tiebreak=CRITERION  Sort criterion when the scores are tied;
+    --tiebreak=CRI[,..]   Comma-separated list of sort criteria to apply
+                          when the scores are tied;
                           [length|begin|end|index] (default: length)
 
   Interface
@@ -38,8 +39,11 @@ const usage = `usage: fzf [options]
     --black               Use black background
     --reverse             Reverse orientation
     --margin=MARGIN       Screen margin (TRBL / TB,RL / T,RL,B / T,R,B,L)
+    --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.
@@ -59,7 +63,7 @@ const usage = `usage: fzf [options]
 
   Environment variables
     FZF_DEFAULT_COMMAND   Default command to use when input is tty
-    FZF_DEFAULT_OPTS      Defaults options. (e.g. '--reverse --inline-info')
+    FZF_DEFAULT_OPTS      Default options (e.g. '--reverse --inline-info')
 
 `
 
@@ -74,13 +78,13 @@ const (
 )
 
 // Sort criteria
-type tiebreak int
+type criterion int
 
 const (
-	byLength tiebreak = iota
+	byMatchLen criterion = iota
+	byLength
 	byBegin
 	byEnd
-	byIndex
 )
 
 func defaultMargin() [4]string {
@@ -97,7 +101,7 @@ type Options struct {
 	Delimiter   Delimiter
 	Sort        int
 	Tac         bool
-	Tiebreak    tiebreak
+	Criteria    []criterion
 	Multi       bool
 	Ansi        bool
 	Mouse       bool
@@ -106,6 +110,7 @@ type Options struct {
 	Reverse     bool
 	Cycle       bool
 	Hscroll     bool
+	HscrollOff  int
 	InlineInfo  bool
 	Prompt      string
 	Query       string
@@ -123,6 +128,7 @@ type Options struct {
 	Header      []string
 	HeaderLines int
 	Margin      [4]string
+	Tabstop     int
 	Version     bool
 }
 
@@ -143,7 +149,7 @@ func defaultOptions() *Options {
 		Delimiter:   Delimiter{},
 		Sort:        1000,
 		Tac:         false,
-		Tiebreak:    byLength,
+		Criteria:    []criterion{byMatchLen, byLength},
 		Multi:       false,
 		Ansi:        false,
 		Mouse:       true,
@@ -152,6 +158,7 @@ func defaultOptions() *Options {
 		Reverse:     false,
 		Cycle:       false,
 		Hscroll:     true,
+		HscrollOff:  10,
 		InlineInfo:  false,
 		Prompt:      "> ",
 		Query:       "",
@@ -160,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,
@@ -169,6 +176,7 @@ func defaultOptions() *Options {
 		Header:      make([]string, 0),
 		HeaderLines: 0,
 		Margin:      defaultMargin(),
+		Tabstop:     8,
 		Version:     false}
 }
 
@@ -358,20 +366,39 @@ func parseKeyChords(str string, message string) map[int]string {
 	return chords
 }
 
-func parseTiebreak(str string) tiebreak {
+func parseTiebreak(str string) []criterion {
-	switch strings.ToLower(str) {
+	criteria := []criterion{byMatchLen}
-	case "length":
+	hasIndex := false
-		return byLength
+	hasLength := false
-	case "index":
+	hasBegin := false
-		return byIndex
+	hasEnd := false
-	case "begin":
+	check := func(notExpected *bool, name string) {
-		return byBegin
+		if *notExpected {
-	case "end":
+			errorExit("duplicate sort criteria: " + name)
-		return byEnd
+		}
-	default:
+		if hasIndex {
-		errorExit("invalid sort criterion: " + str)
+			errorExit("index should be the last criterion")
+		}
+		*notExpected = true
 	}
-	return byLength
+	for _, str := range strings.Split(strings.ToLower(str), ",") {
+		switch str {
+		case "index":
+			check(&hasIndex, "index")
+		case "length":
+			check(&hasLength, "length")
+			criteria = append(criteria, byLength)
+		case "begin":
+			check(&hasBegin, "begin")
+			criteria = append(criteria, byBegin)
+		case "end":
+			check(&hasEnd, "end")
+			criteria = append(criteria, byEnd)
+		default:
+			errorExit("invalid sort criterion: " + str)
+		}
+	}
+	return criteria
 }
 
 func dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
@@ -461,15 +488,18 @@ 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('|')
 		executeRegexp = regexp.MustCompile(
-			"(?s):execute:.*|:execute(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
+			"(?s):execute(-multi)?:.*|:execute(-multi)?(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
 	}
 	masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string {
-		return ":execute(" + strings.Repeat(" ", len(src)-10) + ")"
+		if strings.HasPrefix(src, ":execute-multi") {
+			return ":execute-multi(" + strings.Repeat(" ", len(src)-len(":execute-multi()")) + ")"
+		}
+		return ":execute(" + strings.Repeat(" ", len(src)-len(":execute()")) + ")"
 	})
 	masked = strings.Replace(masked, "::", string([]rune{escapedColon, ':'}), -1)
 	masked = strings.Replace(masked, ",:", string([]rune{escapedComma, ':'}), -1)
@@ -540,6 +570,10 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 			keymap[key] = actToggleDown
 		case "toggle-up":
 			keymap[key] = actToggleUp
+		case "toggle-in":
+			keymap[key] = actToggleIn
+		case "toggle-out":
+			keymap[key] = actToggleOut
 		case "toggle-all":
 			keymap[key] = actToggleAll
 		case "select-all":
@@ -562,28 +596,39 @@ 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) {
-				keymap[key] = actExecute
+				var offset int
-				if act[7] == ':' {
+				if strings.HasPrefix(actLower, "execute-multi") {
-					execmap[key] = act[8:]
+					keymap[key] = actExecuteMulti
+					offset = len("execute-multi")
 				} else {
-					execmap[key] = act[8 : len(act)-1]
+					keymap[key] = actExecute
+					offset = len("execute")
+				}
+				if act[offset] == ':' {
+					execmap[key] = act[offset+1:]
+				} else {
+					execmap[key] = act[offset+1 : len(act)-1]
 				}
 			} else {
 				errorExit("unknown action: " + act)
 			}
 		}
 	}
-	return keymap, execmap, toggleSort
 }
 
 func isExecuteAction(str string) bool {
-	if !strings.HasPrefix(str, "execute") || len(str) < 9 {
+	if !strings.HasPrefix(str, "execute") || len(str) < len("execute()") {
 		return false
 	}
-	b := str[7]
+	b := str[len("execute")]
+	if strings.HasPrefix(str, "execute-multi") {
+		if len(str) < len("execute-multi()") {
+			return false
+		}
+		b = str[len("execute-multi")]
+	}
 	e := str[len(str)-1]
 	if b == ':' || b == '(' && e == ')' || b == '[' && e == ']' ||
 		b == e && strings.ContainsAny(string(b), "~!@#$%^&*;/|") {
@@ -592,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 {
@@ -648,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
@@ -696,10 +739,9 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--expect":
 			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
 		case "--tiebreak":
-			opts.Tiebreak = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
+			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 {
@@ -708,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":
@@ -758,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":
@@ -806,6 +849,8 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--margin":
 			opts.Margin = parseMargin(
 				nextString(allArgs, &i, "margin required (TRBL / TB,RL / T,RL,B / T,R,B,L)"))
+		case "--tabstop":
+			opts.Tabstop = nextInt(allArgs, &i, "tab stop required")
 		case "--version":
 			opts.Version = true
 		default:
@@ -824,17 +869,15 @@ 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 {
-				opts.Tiebreak = parseTiebreak(value)
+				opts.Criteria = parseTiebreak(value)
 			} 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 {
@@ -845,6 +888,10 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.HeaderLines = atoi(value)
 			} else if match, value := optString(arg, "--margin="); match {
 				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)
 			}
@@ -855,20 +902,35 @@ func parseOptions(opts *Options, allArgs []string) {
 		errorExit("header lines must be a non-negative integer")
 	}
 
-	// Change default actions for CTRL-N / CTRL-P when --history is used
+	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")
+	}
+}
+
+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
@@ -888,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

@@ -36,6 +36,8 @@ type term struct {
 	origText      []rune
 }
 
+type termSet []term
+
 // Pattern represents search pattern
 type Pattern struct {
 	fuzzy         bool
@@ -43,8 +45,8 @@ type Pattern struct {
 	caseSensitive bool
 	forward       bool
 	text          []rune
-	terms         []term
+	termSets      []termSet
-	hasInvTerm    bool
+	cacheable     bool
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]func(bool, bool, []rune, []rune) (int, int)
@@ -88,14 +90,20 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		return cached
 	}
 
-	caseSensitive, hasInvTerm := true, false
+	caseSensitive, cacheable := true, true
-	terms := []term{}
+	termSets := []termSet{}
 
 	if extended {
-		terms = parseTerms(fuzzy, caseMode, asString)
+		termSets = parseTerms(fuzzy, caseMode, asString)
-		for _, term := range terms {
+	Loop:
-			if term.inv {
+		for _, termSet := range termSets {
-				hasInvTerm = true
+			for idx, term := range termSet {
+				// If the query contains inverse search terms or OR operators,
+				// we cannot cache the search scope
+				if idx > 0 || term.inv {
+					cacheable = false
+					break Loop
+				}
 			}
 		}
 	} else {
@@ -113,8 +121,8 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		caseSensitive: caseSensitive,
 		forward:       forward,
 		text:          []rune(asString),
-		terms:         terms,
+		termSets:      termSets,
-		hasInvTerm:    hasInvTerm,
+		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
 		procFun:       make(map[termType]func(bool, bool, []rune, []rune) (int, int))}
@@ -129,9 +137,11 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 	return ptr
 }
 
-func parseTerms(fuzzy bool, caseMode Case, str string) []term {
+func parseTerms(fuzzy bool, caseMode Case, str string) []termSet {
 	tokens := _splitRegex.Split(str, -1)
-	terms := []term{}
+	sets := []termSet{}
+	set := termSet{}
+	switchSet := false
 	for _, token := range tokens {
 		typ, inv, text := termFuzzy, false, token
 		lowerText := strings.ToLower(text)
@@ -145,6 +155,11 @@ func parseTerms(fuzzy bool, caseMode Case, str string) []term {
 			typ = termExact
 		}
 
+		if text == "|" {
+			switchSet = false
+			continue
+		}
+
 		if strings.HasPrefix(text, "!") {
 			inv = true
 			text = text[1:]
@@ -173,15 +188,23 @@ func parseTerms(fuzzy bool, caseMode Case, str string) []term {
 		}
 
 		if len(text) > 0 {
-			terms = append(terms, term{
+			if switchSet {
+				sets = append(sets, set)
+				set = termSet{}
+			}
+			set = append(set, term{
 				typ:           typ,
 				inv:           inv,
 				text:          []rune(text),
 				caseSensitive: caseSensitive,
 				origText:      origText})
+			switchSet = true
 		}
 	}
-	return terms
+	if len(set) > 0 {
+		sets = append(sets, set)
+	}
+	return sets
 }
 
 // IsEmpty returns true if the pattern is effectively empty
@@ -189,7 +212,7 @@ func (p *Pattern) IsEmpty() bool {
 	if !p.extended {
 		return len(p.text) == 0
 	}
-	return len(p.terms) == 0
+	return len(p.termSets) == 0
 }
 
 // AsString returns the search query in string type
@@ -203,11 +226,10 @@ func (p *Pattern) CacheKey() string {
 		return p.AsString()
 	}
 	cacheableTerms := []string{}
-	for _, term := range p.terms {
+	for _, termSet := range p.termSets {
-		if term.inv {
+		if len(termSet) == 1 && !termSet[0].inv {
-			continue
+			cacheableTerms = append(cacheableTerms, string(termSet[0].origText))
 		}
-		cacheableTerms = append(cacheableTerms, string(term.origText))
 	}
 	return strings.Join(cacheableTerms, " ")
 }
@@ -218,7 +240,7 @@ func (p *Pattern) Match(chunk *Chunk) []*Item {
 
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
-	if !p.hasInvTerm { // Because we're excluding Inv-term from cache key
+	if p.cacheable {
 		if cached, found := _cache.Find(chunk, cacheKey); found {
 			return cached
 		}
@@ -243,7 +265,7 @@ Loop:
 
 	matches := p.matchChunk(space)
 
-	if !p.hasInvTerm {
+	if p.cacheable {
 		_cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
@@ -260,7 +282,7 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 		}
 	} else {
 		for _, item := range *chunk {
-			if offsets := p.extendedMatch(item); len(offsets) == len(p.terms) {
+			if offsets := p.extendedMatch(item); len(offsets) == len(p.termSets) {
 				matches = append(matches, dupItem(item, offsets))
 			}
 		}
@@ -275,7 +297,7 @@ func (p *Pattern) MatchItem(item *Item) bool {
 		return sidx >= 0
 	}
 	offsets := p.extendedMatch(item)
-	return len(offsets) == len(p.terms)
+	return len(offsets) == len(p.termSets)
 }
 
 func dupItem(item *Item, offsets []Offset) *Item {
@@ -284,10 +306,9 @@ func dupItem(item *Item, offsets []Offset) *Item {
 		text:        item.text,
 		origText:    item.origText,
 		transformed: item.transformed,
-		index:       item.index,
 		offsets:     offsets,
 		colors:      item.colors,
-		rank:        Rank{0, 0, item.index}}
+		rank:        buildEmptyRank(item.Index())}
 }
 
 func (p *Pattern) basicMatch(item *Item) (int, int, int) {
@@ -301,15 +322,23 @@ func (p *Pattern) basicMatch(item *Item) (int, int, int) {
 func (p *Pattern) extendedMatch(item *Item) []Offset {
 	input := p.prepareInput(item)
 	offsets := []Offset{}
-	for _, term := range p.terms {
+	for _, termSet := range p.termSets {
-		pfun := p.procFun[term.typ]
+		var offset *Offset
-		if sidx, eidx, tlen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text); sidx >= 0 {
+		for _, term := range termSet {
-			if term.inv {
+			pfun := p.procFun[term.typ]
+			if sidx, eidx, tlen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text); sidx >= 0 {
+				if term.inv {
+					continue
+				}
+				offset = &Offset{int32(sidx), int32(eidx), int32(tlen)}
 				break
+			} else if term.inv {
+				offset = &Offset{0, 0, 0}
+				continue
 			}
-			offsets = append(offsets, Offset{int32(sidx), int32(eidx), int32(tlen)})
+		}
-		} else if term.inv {
+		if offset != nil {
-			offsets = append(offsets, Offset{0, 0, 0})
+			offsets = append(offsets, *offset)
 		}
 	}
 	return offsets

src/pattern_test.go

@@ -9,20 +9,25 @@ import (
 
 func TestParseTermsExtended(t *testing.T) {
 	terms := parseTerms(true, CaseSmart,
-		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ ^iii$")
+		"| aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | | zzz$ | !ZZZ |")
 	if len(terms) != 9 ||
-		terms[0].typ != termFuzzy || terms[0].inv ||
+		terms[0][0].typ != termFuzzy || terms[0][0].inv ||
-		terms[1].typ != termExact || terms[1].inv ||
+		terms[1][0].typ != termExact || terms[1][0].inv ||
-		terms[2].typ != termPrefix || terms[2].inv ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv ||
-		terms[3].typ != termSuffix || terms[3].inv ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv ||
-		terms[4].typ != termFuzzy || !terms[4].inv ||
+		terms[4][0].typ != termFuzzy || !terms[4][0].inv ||
-		terms[5].typ != termExact || !terms[5].inv ||
+		terms[5][0].typ != termExact || !terms[5][0].inv ||
-		terms[6].typ != termPrefix || !terms[6].inv ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv ||
-		terms[7].typ != termSuffix || !terms[7].inv ||
+		terms[7][0].typ != termSuffix || !terms[7][0].inv ||
-		terms[8].typ != termEqual || terms[8].inv {
+		terms[7][1].typ != termEqual || terms[7][1].inv ||
+		terms[8][0].typ != termPrefix || terms[8][0].inv ||
+		terms[8][1].typ != termExact || terms[8][1].inv ||
+		terms[8][2].typ != termSuffix || terms[8][2].inv ||
+		terms[8][3].typ != termFuzzy || !terms[8][3].inv {
 		t.Errorf("%s", terms)
 	}
-	for idx, term := range terms {
+	for idx, termSet := range terms[:8] {
+		term := termSet[0]
 		if len(term.text) != 3 {
 			t.Errorf("%s", term)
 		}
@@ -30,20 +35,25 @@ func TestParseTermsExtended(t *testing.T) {
 			t.Errorf("%s", term)
 		}
 	}
+	for _, term := range terms[8] {
+		if len(term.origText) != 4 {
+			t.Errorf("%s", term)
+		}
+	}
 }
 
 func TestParseTermsExtendedExact(t *testing.T) {
 	terms := parseTerms(false, CaseSmart,
 		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
 	if len(terms) != 8 ||
-		terms[0].typ != termExact || terms[0].inv || len(terms[0].text) != 3 ||
+		terms[0][0].typ != termExact || terms[0][0].inv || len(terms[0][0].text) != 3 ||
-		terms[1].typ != termFuzzy || terms[1].inv || len(terms[1].text) != 3 ||
+		terms[1][0].typ != termFuzzy || terms[1][0].inv || len(terms[1][0].text) != 3 ||
-		terms[2].typ != termPrefix || terms[2].inv || len(terms[2].text) != 3 ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv || len(terms[2][0].text) != 3 ||
-		terms[3].typ != termSuffix || terms[3].inv || len(terms[3].text) != 3 ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv || len(terms[3][0].text) != 3 ||
-		terms[4].typ != termExact || !terms[4].inv || len(terms[4].text) != 3 ||
+		terms[4][0].typ != termExact || !terms[4][0].inv || len(terms[4][0].text) != 3 ||
-		terms[5].typ != termFuzzy || !terms[5].inv || len(terms[5].text) != 3 ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv || len(terms[5][0].text) != 3 ||
-		terms[6].typ != termPrefix || !terms[6].inv || len(terms[6].text) != 3 ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv || len(terms[6][0].text) != 3 ||
-		terms[7].typ != termSuffix || !terms[7].inv || len(terms[7].text) != 3 {
+		terms[7][0].typ != termSuffix || !terms[7][0].inv || len(terms[7][0].text) != 3 {
 		t.Errorf("%s", terms)
 	}
 }
@@ -61,9 +71,9 @@ func TestExact(t *testing.T) {
 	pattern := BuildPattern(true, true, CaseSmart, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
 	sidx, eidx := algo.ExactMatchNaive(
-		pattern.caseSensitive, pattern.forward, []rune("aabbcc abc"), pattern.terms[0].text)
+		pattern.caseSensitive, pattern.forward, []rune("aabbcc abc"), pattern.termSets[0][0].text)
 	if sidx != 7 || eidx != 10 {
-		t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
+		t.Errorf("%s / %d / %d", pattern.termSets, sidx, eidx)
 	}
 }
 
@@ -74,9 +84,9 @@ func TestEqual(t *testing.T) {
 
 	match := func(str string, sidxExpected int, eidxExpected int) {
 		sidx, eidx := algo.EqualMatch(
-			pattern.caseSensitive, pattern.forward, []rune(str), pattern.terms[0].text)
+			pattern.caseSensitive, pattern.forward, []rune(str), pattern.termSets[0][0].text)
 		if sidx != sidxExpected || eidx != eidxExpected {
-			t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
+			t.Errorf("%s / %d / %d", pattern.termSets, sidx, eidx)
 		}
 	}
 	match("ABC", -1, -1)
@@ -130,3 +140,25 @@ func TestOrigTextAndTransformed(t *testing.T) {
 		}
 	}
 }
+
+func TestCacheKey(t *testing.T) {
+	test := func(extended bool, patStr string, expected string, cacheable bool) {
+		pat := BuildPattern(true, extended, CaseSmart, true, []Range{}, Delimiter{}, []rune(patStr))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
+		if pat.cacheable != cacheable {
+			t.Errorf("Expected: %s, actual: %s (%s)", cacheable, pat.cacheable, patStr)
+		}
+		clearPatternCache()
+	}
+	test(false, "foo !bar", "foo !bar", true)
+	test(false, "foo | bar !baz", "foo | bar !baz", true)
+	test(true, "foo  bar  baz", "foo bar baz", true)
+	test(true, "foo !bar", "foo", false)
+	test(true, "foo !bar   baz", "foo baz", false)
+	test(true, "foo | bar baz", "baz", false)
+	test(true, "foo | bar | baz", "", false)
+	test(true, "foo | bar !baz", "", false)
+	test(true, "| | | foo", "foo", true)
+}

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"
@@ -22,10 +21,12 @@ import (
 
 // Terminal represents terminal input/output
 type Terminal struct {
+	initDelay  time.Duration
 	inlineInfo bool
 	prompt     string
 	reverse    bool
 	hscroll    bool
+	hscrollOff int
 	cx         int
 	cy         int
 	offset     int
@@ -50,7 +51,7 @@ type Terminal struct {
 	progress   int
 	reading    bool
 	merger     *Merger
-	selected   map[uint32]selectedItem
+	selected   map[int32]selectedItem
 	reqBox     *util.EventBox
 	eventBox   *util.EventBox
 	mutex      sync.Mutex
@@ -80,6 +81,7 @@ func (a byTimeOrder) Less(i, j int) bool {
 
 var _spinner = []string{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
 var _runeWidths = make(map[rune]int)
+var _tabStop int
 
 const (
 	reqPrompt util.EventType = iota
@@ -124,6 +126,8 @@ const (
 	actToggleAll
 	actToggleDown
 	actToggleUp
+	actToggleIn
+	actToggleOut
 	actDown
 	actUp
 	actPageUp
@@ -132,6 +136,7 @@ const (
 	actPreviousHistory
 	actNextHistory
 	actExecute
+	actExecuteMulti
 )
 
 func defaultKeymap() map[int]actionType {
@@ -193,11 +198,20 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 	} else {
 		header = reverseStringArray(opts.Header)
 	}
+	_tabStop = opts.Tabstop
+	var delay time.Duration
+	if opts.Tac {
+		delay = initialDelayTac
+	} else {
+		delay = initialDelay
+	}
 	return &Terminal{
+		initDelay:  delay,
 		inlineInfo: opts.InlineInfo,
 		prompt:     opts.Prompt,
 		reverse:    opts.Reverse,
 		hscroll:    opts.Hscroll,
+		hscrollOff: opts.HscrollOff,
 		cx:         len(input),
 		cy:         0,
 		offset:     0,
@@ -220,7 +234,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		ansi:       opts.Ansi,
 		reading:    true,
 		merger:     EmptyMerger,
-		selected:   make(map[uint32]selectedItem),
+		selected:   make(map[int32]selectedItem),
 		reqBox:     util.NewEventBox(),
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
@@ -305,21 +319,25 @@ func (t *Terminal) output() bool {
 			found = true
 		}
 	} else {
-		sels := make([]selectedItem, 0, len(t.selected))
+		for _, sel := range t.sortSelected() {
-		for _, sel := range t.selected {
-			sels = append(sels, sel)
-		}
-		sort.Sort(byTimeOrder(sels))
-		for _, sel := range sels {
 			fmt.Println(*sel.text)
 		}
 	}
 	return found
 }
 
+func (t *Terminal) sortSelected() []selectedItem {
+	sels := make([]selectedItem, 0, len(t.selected))
+	for _, sel := range t.selected {
+		sels = append(sels, sel)
+	}
+	sort.Sort(byTimeOrder(sels))
+	return sels
+}
+
 func runeWidth(r rune, prefixWidth int) int {
 	if r == '\t' {
-		return 8 - prefixWidth%8
+		return _tabStop - prefixWidth%_tabStop
 	} else if w, found := _runeWidths[r]; found {
 		return w
 	} else {
@@ -391,7 +409,7 @@ func (t *Terminal) move(y int, x int, clear bool) {
 }
 
 func (t *Terminal) placeCursor() {
-	t.move(0, len(t.prompt)+displayWidth(t.input[:t.cx]), false)
+	t.move(0, displayWidth([]rune(t.prompt))+displayWidth(t.input[:t.cx]), false)
 }
 
 func (t *Terminal) printPrompt() {
@@ -402,7 +420,7 @@ func (t *Terminal) printPrompt() {
 
 func (t *Terminal) printInfo() {
 	if t.inlineInfo {
-		t.move(0, len(t.prompt)+displayWidth(t.input)+1, true)
+		t.move(0, displayWidth([]rune(t.prompt))+displayWidth(t.input)+1, true)
 		if t.reading {
 			C.CPrint(C.ColSpinner, true, " < ")
 		} else {
@@ -457,9 +475,8 @@ func (t *Terminal) printHeader() {
 		state = newState
 		item := &Item{
 			text:   []rune(trimmed),
-			index:  0,
 			colors: colors,
-			rank:   Rank{0, 0, 0}}
+			rank:   buildEmptyRank(0)}
 
 		t.move(line, 2, true)
 		t.printHighlighted(item, false, C.ColHeader, 0, false)
@@ -484,7 +501,7 @@ func (t *Terminal) printList() {
 }
 
 func (t *Terminal) printItem(item *Item, current bool) {
-	_, selected := t.selected[item.index]
+	_, selected := t.selected[item.Index()]
 	if current {
 		C.CPrint(C.ColCursor, true, ">")
 		if selected {
@@ -541,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
@@ -553,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 {
@@ -698,9 +714,13 @@ func keyMatch(key int, event C.Event) bool {
 	return event.Type == key || event.Type == C.Rune && int(event.Char) == key-C.AltZ
 }
 
-func executeCommand(template string, current string) {
+func quoteEntry(entry string) string {
-	command := strings.Replace(template, "{}", fmt.Sprintf("%q", current), -1)
+	return fmt.Sprintf("%q", entry)
-	cmd := exec.Command("sh", "-c", command)
+}
+
+func executeCommand(template string, replacement string) {
+	command := strings.Replace(template, "{}", replacement, -1)
+	cmd := util.ExecCommand(command)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -714,7 +734,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)
@@ -739,7 +759,7 @@ func (t *Terminal) Loop() {
 		t.printHeader()
 		t.mutex.Unlock()
 		go func() {
-			timer := time.NewTimer(initialDelay)
+			timer := time.NewTimer(t.initDelay)
 			<-timer.C
 			t.reqBox.Set(reqRefresh, nil)
 		}()
@@ -825,8 +845,8 @@ func (t *Terminal) Loop() {
 			}
 		}
 		selectItem := func(item *Item) bool {
-			if _, found := t.selected[item.index]; !found {
+			if _, found := t.selected[item.Index()]; !found {
-				t.selected[item.index] = selectedItem{time.Now(), item.StringPtr(t.ansi)}
+				t.selected[item.Index()] = selectedItem{time.Now(), item.StringPtr(t.ansi)}
 				return true
 			}
 			return false
@@ -834,7 +854,7 @@ func (t *Terminal) Loop() {
 		toggleY := func(y int) {
 			item := t.merger.Get(y)
 			if !selectItem(item) {
-				delete(t.selected, item.index)
+				delete(t.selected, item.Index())
 			}
 		}
 		toggle := func() {
@@ -858,7 +878,17 @@ func (t *Terminal) Loop() {
 			case actExecute:
 				if t.cy >= 0 && t.cy < t.merger.Length() {
 					item := t.merger.Get(t.cy)
-					executeCommand(t.execmap[mapkey], item.AsString(t.ansi))
+					executeCommand(t.execmap[mapkey], quoteEntry(item.AsString(t.ansi)))
+				}
+			case actExecuteMulti:
+				if len(t.selected) > 0 {
+					sels := make([]string, len(t.selected))
+					for i, sel := range t.sortSelected() {
+						sels[i] = quoteEntry(*sel.text)
+					}
+					executeCommand(t.execmap[mapkey], strings.Join(sels, " "))
+				} else {
+					return doAction(actExecute, mapkey)
 				}
 			case actInvalid:
 				t.mutex.Unlock()
@@ -913,7 +943,7 @@ func (t *Terminal) Loop() {
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
 						item := t.merger.Get(i)
-						delete(t.selected, item.index)
+						delete(t.selected, item.Index())
 					}
 					req(reqList, reqInfo)
 				}
@@ -929,6 +959,16 @@ func (t *Terminal) Loop() {
 					}
 					req(reqList, reqInfo)
 				}
+			case actToggleIn:
+				if t.reverse {
+					return doAction(actToggleUp, mapkey)
+				}
+				return doAction(actToggleDown, mapkey)
+			case actToggleOut:
+				if t.reverse {
+					return doAction(actToggleDown, mapkey)
+				}
+				return doAction(actToggleUp, mapkey)
 			case actToggleDown:
 				if t.multi && t.merger.Length() > 0 {
 					toggle()
@@ -1023,7 +1063,7 @@ func (t *Terminal) Loop() {
 					my >= t.marginInt[0] && my < C.MaxY()-t.marginInt[2] {
 					mx -= t.marginInt[3]
 					my -= t.marginInt[0]
-					mx = util.Constrain(mx-len(t.prompt), 0, len(t.input))
+					mx = util.Constrain(mx-displayWidth([]rune(t.prompt)), 0, len(t.input))
 					if !t.reverse {
 						my = t.maxHeight() - my - 1
 					}
@@ -1083,15 +1123,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/fzf.vader

@@ -1,6 +1,7 @@
 Execute (Setup):
   let g:dir = fnamemodify(g:vader_file, ':p:h')
   Log 'Test directory: ' . g:dir
+  Save &acd
 
 Execute (fzf#run with dir option):
   let cwd = getcwd()
@@ -35,6 +36,34 @@ Execute (fzf#run with string source):
   let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))
   AssertEqual ['hi'], result
 
+Execute (fzf#run with dir option and noautochdir):
+  set noacd
+  let cwd = getcwd()
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/tmp', 'options': '-1'})
+  " No change in working directory
+  AssertEqual cwd, getcwd()
+
+Execute (Incomplete fzf#run with dir option and autochdir):
+  set acd
+  let cwd = getcwd()
+  call fzf#run({'source': [], 'sink': 'e', 'dir': '/tmp', 'options': '-0'})
+  " No change in working directory even if &acd is set
+  AssertEqual cwd, getcwd()
+
+Execute (fzf#run with dir option and autochdir):
+  set acd
+  let cwd = getcwd()
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/tmp', 'options': '-1'})
+  " Working directory changed due to &acd
+  AssertEqual '/', getcwd()
+
+Execute (fzf#run with dir option and autochdir when final cwd is same as dir):
+  set acd
+  cd /tmp
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/', 'options': '-1'})
+  " Working directory changed due to &acd
+  AssertEqual '/', getcwd()
+
 Execute (Cleanup):
   unlet g:dir
   Restore

test/test_go.rb

@@ -6,6 +6,7 @@ require 'fileutils'
 
 DEFAULT_TIMEOUT = 20
 
+FILE = File.expand_path(__FILE__)
 base = File.expand_path('../../', __FILE__)
 Dir.chdir base
 FZF = "FZF_DEFAULT_OPTS= FZF_DEFAULT_COMMAND= #{base}/bin/fzf"
@@ -142,8 +143,10 @@ class TestBase < Minitest::Test
   attr_reader :tmux
 
   def tempname
+    @temp_suffix ||= 0
     [TEMPNAME,
-     caller_locations.map(&:label).find { |l| l =~ /^test_/ }].join '-'
+     caller_locations.map(&:label).find { |l| l =~ /^test_/ },
+     @temp_suffix].join '-'
   end
 
   def setup
@@ -157,6 +160,7 @@ class TestBase < Minitest::Test
     File.read(tempname)
   ensure
     File.unlink tempname while File.exists?(tempname)
+    @temp_suffix += 1
     tmux.prepare
   end
 
@@ -458,8 +462,8 @@ class TestGoFZF < TestBase
 
   def test_unicode_case
     writelines tempname, %w[строКА1 СТРОКА2 строка3 Строка4]
-    assert_equal %w[СТРОКА2 Строка4], `cat #{tempname} | #{FZF} -fС`.split($/)
+    assert_equal %w[СТРОКА2 Строка4], `#{FZF} -fС < #{tempname}`.split($/)
-    assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `cat #{tempname} | #{FZF} -fс`.split($/)
+    assert_equal %w[строКА1 СТРОКА2 строка3 Строка4], `#{FZF} -fс < #{tempname}`.split($/)
   end
 
   def test_tiebreak
@@ -471,7 +475,7 @@ class TestGoFZF < TestBase
     ]
     writelines tempname, input
 
-    assert_equal input, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=index`.split($/)
+    assert_equal input, `#{FZF} -ffoobar --tiebreak=index < #{tempname}`.split($/)
 
     by_length = %w[
       ----foobar--
@@ -479,8 +483,8 @@ class TestGoFZF < TestBase
       -------foobar-
       --foobar--------
     ]
-    assert_equal by_length, `cat #{tempname} | #{FZF} -ffoobar`.split($/)
+    assert_equal by_length, `#{FZF} -ffoobar < #{tempname}`.split($/)
-    assert_equal by_length, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=length`.split($/)
+    assert_equal by_length, `#{FZF} -ffoobar --tiebreak=length < #{tempname}`.split($/)
 
     by_begin = %w[
       --foobar--------
@@ -488,17 +492,175 @@ class TestGoFZF < TestBase
       -----foobar---
       -------foobar-
     ]
-    assert_equal by_begin, `cat #{tempname} | #{FZF} -ffoobar --tiebreak=begin`.split($/)
+    assert_equal by_begin, `#{FZF} -ffoobar --tiebreak=begin < #{tempname}`.split($/)
-    assert_equal by_begin, `cat #{tempname} | #{FZF} -f"!z foobar" -x --tiebreak begin`.split($/)
+    assert_equal by_begin, `#{FZF} -f"!z foobar" -x --tiebreak begin < #{tempname}`.split($/)
 
     assert_equal %w[
       -------foobar-
       ----foobar--
       -----foobar---
       --foobar--------
-    ], `cat #{tempname} | #{FZF} -ffoobar --tiebreak end`.split($/)
+    ], `#{FZF} -ffoobar --tiebreak end < #{tempname}`.split($/)
 
-    assert_equal input, `cat #{tempname} | #{FZF} -f"!z" -x --tiebreak end`.split($/)
+    assert_equal input, `#{FZF} -f"!z" -x --tiebreak end < #{tempname}`.split($/)
+  end
+
+  # Since 0.11.2
+  def test_tiebreak_list
+    input = %w[
+      f-o-o-b-a-r
+      foobar----
+      --foobar
+      ----foobar
+      foobar--
+      --foobar--
+      foobar
+    ]
+    writelines tempname, input
+
+    assert_equal %w[
+      foobar----
+      --foobar
+      ----foobar
+      foobar--
+      --foobar--
+      foobar
+      f-o-o-b-a-r
+    ], `#{FZF} -ffb --tiebreak=index < #{tempname}`.split($/)
+
+    by_length = %w[
+      foobar
+      --foobar
+      foobar--
+      foobar----
+      ----foobar
+      --foobar--
+      f-o-o-b-a-r
+    ]
+    assert_equal by_length, `#{FZF} -ffb < #{tempname}`.split($/)
+    assert_equal by_length, `#{FZF} -ffb --tiebreak=length < #{tempname}`.split($/)
+
+    assert_equal %w[
+      foobar
+      foobar--
+      --foobar
+      foobar----
+      --foobar--
+      ----foobar
+      f-o-o-b-a-r
+    ], `#{FZF} -ffb --tiebreak=length,begin < #{tempname}`.split($/)
+
+    assert_equal %w[
+      foobar
+      --foobar
+      foobar--
+      ----foobar
+      --foobar--
+      foobar----
+      f-o-o-b-a-r
+    ], `#{FZF} -ffb --tiebreak=length,end < #{tempname}`.split($/)
+
+    assert_equal %w[
+      foobar----
+      foobar--
+      foobar
+      --foobar
+      --foobar--
+      ----foobar
+      f-o-o-b-a-r
+    ], `#{FZF} -ffb --tiebreak=begin < #{tempname}`.split($/)
+
+    by_begin_end = %w[
+      foobar
+      foobar--
+      foobar----
+      --foobar
+      --foobar--
+      ----foobar
+      f-o-o-b-a-r
+    ]
+    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=begin,length < #{tempname}`.split($/)
+    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=begin,end < #{tempname}`.split($/)
+
+    assert_equal %w[
+      --foobar
+      ----foobar
+      foobar
+      foobar--
+      --foobar--
+      foobar----
+      f-o-o-b-a-r
+    ], `#{FZF} -ffb --tiebreak=end < #{tempname}`.split($/)
+
+    by_begin_end = %w[
+      foobar
+      --foobar
+      ----foobar
+      foobar--
+      --foobar--
+      foobar----
+      f-o-o-b-a-r
+    ]
+    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=end,begin < #{tempname}`.split($/)
+    assert_equal by_begin_end, `#{FZF} -ffb --tiebreak=end,length < #{tempname}`.split($/)
+  end
+
+  def test_tiebreak_white_prefix
+    writelines tempname, [
+      'f o o b a r',
+      '    foo bar',
+      '    foobar',
+      '----foo bar',
+      '----foobar',
+      '  foo bar',
+      '  foobar--',
+      '  foobar',
+      '--foo bar',
+      '--foobar',
+      'foobar',
+    ]
+
+    assert_equal [
+      '    foobar',
+      '  foobar',
+      'foobar',
+      '  foobar--',
+      '--foobar',
+      '----foobar',
+      '    foo bar',
+      '  foo bar',
+      '--foo bar',
+      '----foo bar',
+      'f o o b a r',
+    ], `#{FZF} -ffb < #{tempname}`.split($/)
+
+    assert_equal [
+      '    foobar',
+      '  foobar--',
+      '  foobar',
+      'foobar',
+      '--foobar',
+      '----foobar',
+      '    foo bar',
+      '  foo bar',
+      '--foo bar',
+      '----foo bar',
+      'f o o b a r',
+    ], `#{FZF} -ffb --tiebreak=begin < #{tempname}`.split($/)
+
+    assert_equal [
+      '    foobar',
+      '  foobar',
+      'foobar',
+      '  foobar--',
+      '--foobar',
+      '----foobar',
+      '    foo bar',
+      '  foo bar',
+      '--foo bar',
+      '----foo bar',
+      'f o o b a r',
+    ], `#{FZF} -ffb --tiebreak=begin,length < #{tempname}`.split($/)
   end
 
   def test_tiebreak_length_with_nth
@@ -516,7 +678,7 @@ class TestGoFZF < TestBase
       123:hello
       1234567:h
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -fh`.split($/)
+    assert_equal output, `#{FZF} -fh < #{tempname}`.split($/)
 
     output = %w[
       1234567:h
@@ -524,7 +686,7 @@ class TestGoFZF < TestBase
       1:hell
       123:hello
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -fh -n2 -d:`.split($/)
+    assert_equal output, `#{FZF} -fh -n2 -d: < #{tempname}`.split($/)
   end
 
   def test_tiebreak_length_with_nth_trim_length
@@ -543,7 +705,7 @@ class TestGoFZF < TestBase
       "apple juice   bottle 1",
       "apple  ui     bottle 2",
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -fa -n1`.split($/)
+    assert_equal output, `#{FZF} -fa -n1 < #{tempname}`.split($/)
 
     # len(1 ~ 2)
     output = [
@@ -552,7 +714,7 @@ class TestGoFZF < TestBase
       "apple juice   bottle 1",
       "app     ice   bottle 3",
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -fai -n1..2`.split($/)
+    assert_equal output, `#{FZF} -fai -n1..2 < #{tempname}`.split($/)
 
     # len(1) + len(2)
     output = [
@@ -561,7 +723,7 @@ class TestGoFZF < TestBase
       "apple  ui     bottle 2",
       "apple juice   bottle 1",
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -x -f"a i" -n1,2`.split($/)
+    assert_equal output, `#{FZF} -x -f"a i" -n1,2 < #{tempname}`.split($/)
 
     # len(2)
     output = [
@@ -570,8 +732,8 @@ class TestGoFZF < TestBase
       "app     ice   bottle 3",
       "apple juice   bottle 1",
     ]
-    assert_equal output, `cat #{tempname} | #{FZF} -fi -n2`.split($/)
+    assert_equal output, `#{FZF} -fi -n2 < #{tempname}`.split($/)
-    assert_equal output, `cat #{tempname} | #{FZF} -fi -n2,1..2`.split($/)
+    assert_equal output, `#{FZF} -fi -n2,1..2 < #{tempname}`.split($/)
   end
 
   def test_tiebreak_end_backward_scan
@@ -581,8 +743,8 @@ class TestGoFZF < TestBase
     ]
     writelines tempname, input
 
-    assert_equal input.reverse, `cat #{tempname} | #{FZF} -f fb`.split($/)
+    assert_equal input.reverse, `#{FZF} -f fb < #{tempname}`.split($/)
-    assert_equal input, `cat #{tempname} | #{FZF} -f fb --tiebreak=end`.split($/)
+    assert_equal input, `#{FZF} -f fb --tiebreak=end < #{tempname}`.split($/)
   end
 
   def test_invalid_cache
@@ -612,7 +774,7 @@ class TestGoFZF < TestBase
     File.open(tempname, 'w') do |f|
       f << data
     end
-    assert_equal data, `cat #{tempname} | #{FZF} -f .`.chomp
+    assert_equal data, `#{FZF} -f . < #{tempname}`.chomp
   end
 
   def test_read0
@@ -713,6 +875,42 @@ class TestGoFZF < TestBase
     File.unlink output rescue nil
   end
 
+  def test_execute_multi
+    output = '/tmp/fzf-test-execute-multi'
+    opts = %[--multi --bind \\"alt-a:execute-multi(echo '[{}], @{}@' >> #{output})\\"]
+    tmux.send_keys "seq 100 | #{fzf opts}", :Enter
+    tmux.until { |lines| lines[-2].include? '100/100' }
+    tmux.send_keys :Escape, :a
+    tmux.send_keys :BTab, :BTab, :BTab
+    tmux.send_keys :Escape, :a
+    tmux.send_keys :Tab, :Tab
+    tmux.send_keys :Escape, :a
+    tmux.send_keys :Enter
+    readonce
+    assert_equal ['["1"], @"1"@', '["1" "2" "3"], @"1" "2" "3"@', '["1" "2" "4"], @"1" "2" "4"@'],
+      File.readlines(output).map(&:chomp)
+  ensure
+    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' }
@@ -785,8 +983,8 @@ class TestGoFZF < TestBase
   end
 
   def test_header
-    tmux.send_keys "seq 100 | #{fzf "--header \\\"\\$(head -5 #{__FILE__})\\\""}", :Enter
+    tmux.send_keys "seq 100 | #{fzf "--header \\\"\\$(head -5 #{FILE})\\\""}", :Enter
-    header = File.readlines(__FILE__).take(5).map(&:strip)
+    header = File.readlines(FILE).take(5).map(&:strip)
     tmux.until do |lines|
       lines[-2].include?('100/100') &&
       lines[-7..-3].map(&:strip) == header
@@ -794,8 +992,8 @@ class TestGoFZF < TestBase
   end
 
   def test_header_reverse
-    tmux.send_keys "seq 100 | #{fzf "--header=\\\"\\$(head -5 #{__FILE__})\\\" --reverse"}", :Enter
+    tmux.send_keys "seq 100 | #{fzf "--header=\\\"\\$(head -5 #{FILE})\\\" --reverse"}", :Enter
-    header = File.readlines(__FILE__).take(5).map(&:strip)
+    header = File.readlines(FILE).take(5).map(&:strip)
     tmux.until do |lines|
       lines[1].include?('100/100') &&
       lines[2..6].map(&:strip) == header
@@ -803,8 +1001,8 @@ class TestGoFZF < TestBase
   end
 
   def test_header_and_header_lines
-    tmux.send_keys "seq 100 | #{fzf "--header-lines 10 --header \\\"\\$(head -5 #{__FILE__})\\\""}", :Enter
+    tmux.send_keys "seq 100 | #{fzf "--header-lines 10 --header \\\"\\$(head -5 #{FILE})\\\""}", :Enter
-    header = File.readlines(__FILE__).take(5).map(&:strip)
+    header = File.readlines(FILE).take(5).map(&:strip)
     tmux.until do |lines|
       lines[-2].include?('90/90') &&
       lines[-7...-2].map(&:strip) == header &&
@@ -813,8 +1011,8 @@ class TestGoFZF < TestBase
   end
 
   def test_header_and_header_lines_reverse
-    tmux.send_keys "seq 100 | #{fzf "--reverse --header-lines 10 --header \\\"\\$(head -5 #{__FILE__})\\\""}", :Enter
+    tmux.send_keys "seq 100 | #{fzf "--reverse --header-lines 10 --header \\\"\\$(head -5 #{FILE})\\\""}", :Enter
-    header = File.readlines(__FILE__).take(5).map(&:strip)
+    header = File.readlines(FILE).take(5).map(&:strip)
     tmux.until do |lines|
       lines[1].include?('90/90') &&
       lines[2...7].map(&:strip) == header &&
@@ -847,20 +1045,40 @@ class TestGoFZF < TestBase
     tmux.send_keys :Enter
   end
 
+  def test_tabstop
+    writelines tempname, ["f\too\tba\tr\tbaz\tbarfooq\tux"]
+    {
+      1 => '> f oo ba r baz barfooq ux',
+      2 => '> f oo  ba  r baz barfooq ux',
+      3 => '> f  oo ba r  baz   barfooq  ux',
+      4 => '> f   oo  ba  r   baz barfooq ux',
+      5 => '> f    oo   ba   r    baz  barfooq   ux',
+      6 => '> f     oo    ba    r     baz   barfooq     ux',
+      7 => '> f      oo     ba     r      baz    barfooq       ux',
+      8 => '> f       oo      ba      r       baz     barfooq ux',
+      9 => '> f        oo       ba       r        baz      barfooq  ux',
+    }.each do |ts, exp|
+      tmux.prepare
+      tmux.send_keys %[cat #{tempname} | fzf --tabstop=#{ts}], :Enter
+      tmux.until { |lines| exp.start_with? lines[-3].to_s.strip.sub(/\.\.$/, '') }
+      tmux.send_keys :Enter
+    end
+  end
+
   def test_with_nth
     writelines tempname, ['hello world ', 'byebye']
-    assert_equal 'hello world ', `cat #{tempname} | #{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1`.chomp
+    assert_equal 'hello world ', `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 < #{tempname}`.chomp
   end
 
   def test_with_nth_ansi
     writelines tempname, ["\x1b[33mhello \x1b[34;1mworld\x1b[m ", 'byebye']
-    assert_equal 'hello world ', `cat #{tempname} | #{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 --ansi`.chomp
+    assert_equal 'hello world ', `#{FZF} -f"^he hehe" -x -n 2.. --with-nth 2,1,1 --ansi < #{tempname}`.chomp
   end
 
   def test_with_nth_no_ansi
     src = "\x1b[33mhello \x1b[34;1mworld\x1b[m "
     writelines tempname, [src, 'byebye']
-    assert_equal src, `cat #{tempname} | #{FZF} -fhehe -x -n 2.. --with-nth 2,1,1 --no-ansi`.chomp
+    assert_equal src, `#{FZF} -fhehe -x -n 2.. --with-nth 2,1,1 --no-ansi < #{tempname}`.chomp
   end
 
   def test_exit_0_exit_code
@@ -915,10 +1133,28 @@ class TestGoFZF < TestBase
     assert_equal 4, `seq 123 | #{FZF} -f 13 +e`.lines.length
   end
 
+  def test_or_operator
+    assert_equal %w[1 5 10], `seq 10 | #{FZF} -f "1 | 5"`.lines.map(&:chomp)
+    assert_equal %w[1 10 2 3 4 5 6 7 8 9],
+      `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
 
@@ -981,6 +1217,22 @@ module TestShell
     tmux.until { |lines| lines[-1].end_with?(expected) }
   end
 
+  def test_alt_c_command
+    set_var 'FZF_ALT_C_COMMAND', 'echo /tmp'
+
+    tmux.prepare
+    tmux.send_keys 'cd /', :Enter
+
+    tmux.prepare
+    tmux.send_keys :Escape, :c, pane: 0
+    lines = tmux.until(1) { |lines| lines.item_count == 1 }
+    tmux.send_keys :Enter, pane: 1
+
+    tmux.prepare
+    tmux.send_keys :pwd, :Enter
+    tmux.until { |lines| lines[-1].end_with? '/tmp' }
+  end
+
   def test_ctrl_r
     tmux.prepare
     tmux.send_keys 'echo 1st', :Enter; tmux.prepare
@@ -1010,6 +1262,8 @@ module CompletionTest
     tmux.prepare
     tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab, pane: 0
     tmux.until(1) { |lines| lines.item_count > 0 }
+    tmux.send_keys ' !d'
+    tmux.until(1) { |lines| lines[-2].include?(' 2/') }
     tmux.send_keys :BTab, :BTab
     tmux.until(1) { |lines| lines[-2].include?('(2)') }
     tmux.send_keys :Enter
@@ -1045,17 +1299,33 @@ 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')
     end
+
+    # Should include hidden files
+    (1..100).each { |i| FileUtils.touch "/tmp/fzf-test/.hidden-#{i}" }
+    tmux.send_keys 'C-u'
+    tmux.send_keys 'cat /tmp/fzf-test/hidden**', :Tab, pane: 0
+    tmux.until(1) do |lines|
+      tmux.send_keys 'C-L'
+      lines[-2].include?('100/') &&
+      lines[-3].include?('/tmp/fzf-test/.hidden-')
+    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_file_completion_root
+    tmux.send_keys 'ls /**', :Tab, pane: 0
+    tmux.until(1) { |lines| lines.item_count > 0 }
+    tmux.send_keys :Enter
+  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
@@ -1102,6 +1372,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