0.11.0

Close #412

CHANGELOG.md

@@ -1,6 +1,38 @@
 CHANGELOG
 =========
 
+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
+------
+
+- Extended-search mode is now enabled by default
+    - `--extended-exact` is deprecated and instead we have `--exact` for
+      orthogonally controlling "exactness" of search
+- Fixed not to display non-printable characters
+- Added `double-click` for `--bind` option
+- More robust handling of SIGWINCH
+
+0.10.8
+------
+
+- Fixed panic when trying to set colors after colors are disabled (#370)
+
+0.10.7
+------
+
+- Fixed unserialized interrupt handling during execute action which often
+  caused invalid memory access and crash
+- Changed `--tiebreak=length` (default) to use trimmed length when `--nth` is
+  used
+
 0.10.6
 ------
 

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
@@ -68,7 +68,7 @@ Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf
 (recommended):
 
 ```vim
-Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 ```
 
 #### Upgrading fzf
@@ -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
 
-With `-x` or `--extended` option, fzf will start in "extended-search mode".
+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 `--extended-exact` option. Note that in
+start fzf with `-e` or `--exact` option. Note that when  `--exact` is set,
-`--extended-exact` mode, `'`-prefix "unquotes" the term.
+`'`-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="--extended --cycle"`
+    - Default options
+    - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
 
 Examples
 --------
@@ -335,10 +344,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
@@ -355,7 +364,8 @@ speed of the traversal.
 ```sh
 export FZF_DEFAULT_COMMAND='
   (git ls-tree -r --name-only HEAD ||
-   find * -name ".*" -prune -o -type f -print -o -type l -print) 2> /dev/null'
+   find . -path "*/\.*" -prune -o -type f -print -o -type l -print |
+      sed s/^..//) 2> /dev/null'
 ```
 
 #### Fish shell

bin/fzf-tmux

@@ -91,10 +91,10 @@ set -e
 
 # Clean up named pipes on exit
 id=$RANDOM
-argsf=/tmp/fzf-args-$id
+argsf="${TMPDIR:-/tmp}/fzf-args-$id"
-fifo1=/tmp/fzf-fifo1-$id
+fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
-fifo2=/tmp/fzf-fifo2-$id
+fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
-fifo3=/tmp/fzf-fifo3-$id
+fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
 cleanup() {
   rm -f $argsf $fifo1 $fifo2 $fifo3
 }

install

@@ -1,12 +1,60 @@
 #!/usr/bin/env bash
 
-[[ "$@" =~ --pre ]] && version=0.10.6 pre=1 ||
+set -u
-                       version=0.10.6 pre=0
+
+[[ "$@" =~ --pre ]] && version=0.11.0 pre=1 ||
+                       version=0.11.0 pre=0
+
+auto_completion=
+key_bindings=
+update_config=1
+
+help() {
+  cat << EOF
+usage: $0 [OPTIONS]
+
+    --help               Show this message
+    --bin                Download fzf binary only
+    --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
+
+EOF
+}
+
+for opt in $@; do
+  case $opt in
+    --help)
+      help
+      exit 0
+      ;;
+    --all)
+      auto_completion=1
+      key_bindings=1
+      update_config=1
+      ;;
+    --key-bindings)    key_bindings=1    ;;
+    --no-key-bindings) key_bindings=0    ;;
+    --completion)      auto_completion=1 ;;
+    --no-completion)   auto_completion=0 ;;
+    --update-rc)       update_config=1   ;;
+    --no-update-rc)    update_config=0   ;;
+    --bin)             ;;
+    *)
+      echo "unknown option: $opt"
+      help
+      exit 1
+      ;;
+  esac
+done
 
 cd $(dirname $BASH_SOURCE)
-fzf_base=$(pwd)
+fzf_base="$(pwd)"
 
 # If stdin is a tty, we are "interactive".
+interactive=
 [ -t 0 ] && interactive=yes
 
 ask() {
@@ -16,7 +64,7 @@ ask() {
 
   read -p "$1 ([y]/n) " $read_n -r
   echo
-  [[ ! $REPLY =~ ^[Nn]$ ]]
+  [[ $REPLY =~ ^[Nn]$ ]]
 }
 
 check_binary() {
@@ -55,9 +103,16 @@ download() {
     if [ -x "$fzf_base"/bin/fzf ]; then
       echo "  - Already exists"
       check_binary && return
-    elif [ -x "$fzf_base"/bin/$1 ]; then
+    fi
+    if [ -x "$fzf_base"/bin/$1 ]; then
       symlink $1 && check_binary && return
     fi
+    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
   fi
   mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
   if [ $? -ne 0 ]; then
@@ -173,38 +228,42 @@ fi
 [[ "$*" =~ "--bin" ]] && exit 0
 
 # Auto-completion
-ask "Do you want to add auto-completion support?"
+if [ -z "$auto_completion" ]; then
-auto_completion=$?
+  ask "Do you want to enable fuzzy auto-completion?"
+  auto_completion=$?
+fi
 
 # Key-bindings
-ask "Do you want to add key bindings?"
+if [ -z "$key_bindings" ]; then
-key_bindings=$?
+  ask "Do you want to enable key bindings?"
+  key_bindings=$?
+fi
 
 echo
 for shell in bash zsh; do
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
-  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
+  fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
-  if [ $auto_completion -ne 0 ]; then
+  if [ $auto_completion -eq 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
 
   fzf_key_bindings="source \"$fzf_base/shell/key-bindings.${shell}\""
-  if [ $key_bindings -ne 0 ]; then
+  if [ $key_bindings -eq 0 ]; then
     fzf_key_bindings="# $fzf_key_bindings"
   fi
 
   cat > $src << EOF
 # Setup fzf
 # ---------
-if [[ ! "\$PATH" =~ "$fzf_base/bin" ]]; then
+if [[ ! "\$PATH" == *$fzf_base/bin* ]]; then
   export PATH="\$PATH:$fzf_base/bin"
 fi
 
 # Man path
 # --------
-if [[ ! "\$MANPATH" =~ "$fzf_base/man" && -d "$fzf_base/man" ]]; then
+if [[ ! "\$MANPATH" == *$fzf_base/man* && -d "$fzf_base/man" ]]; then
   export MANPATH="\$MANPATH:$fzf_base/man"
 fi
 
@@ -237,29 +296,45 @@ EOF
     rm -f ~/.config/fish/functions/fzf.fish && echo "OK" || echo "Failed"
   fi
 
-  if [ $key_bindings -eq 0 ]; then
+  fish_binding=~/.config/fish/functions/fzf_key_bindings.fish
-    echo -n "Symlink ~/.config/fish/functions/fzf_key_bindings.fish ... "
+  if [ $key_bindings -ne 0 ]; then
-    ln -sf $fzf_base/shell/key-bindings.fish \
+    echo -n "Symlink $fish_binding ... "
-           ~/.config/fish/functions/fzf_key_bindings.fish && echo "OK" || echo "Failed"
+    ln -sf "$fzf_base/shell/key-bindings.fish" \
+           "$fish_binding" && echo "OK" || echo "Failed"
+  else
+    echo -n "Removing $fish_binding ... "
+    rm -f "$fish_binding"
+    echo "OK"
   fi
 fi
 
 append_line() {
   set -e
-  echo "Update $2:"
+
-  echo "  - $1"
+  local skip line file pat lno
-  [ -f "$2" ] || touch "$2"
+  skip="$1"
-  if [ $# -lt 3 ]; then
+  line="$2"
-    line=$(\grep -nF "$1" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  file="$3"
+  pat="${4:-}"
+
+  echo "Update $file:"
+  echo "  - $line"
+  [ -f "$file" ] || touch "$file"
+  if [ $# -lt 4 ]; then
+    lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
   else
-    line=$(\grep -nF "$3" "$2" | sed 's/:.*//' | tr '\n' ' ')
+    lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
   fi
-  if [ -n "$line" ]; then
+  if [ -n "$lno" ]; then
-    echo "    - Already exists: line #$line"
+    echo "    - Already exists: line #$lno"
   else
-    echo >> "$2"
+    if [ $skip -eq 1 ]; then
-    echo "$1" >> "$2"
+      echo >> "$file"
+      echo "$line" >> "$file"
       echo "    + Added"
+    else
+      echo "    ~ Skipped"
+    fi
   fi
   echo
   set +e
@@ -267,18 +342,19 @@ append_line() {
 
 echo
 for shell in bash zsh; do
-  append_line "[ -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 0 -a $has_fish -eq 1 ]; then
+if [ $key_bindings -eq 1 -a $has_fish -eq 1 ]; then
   bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
-  append_line "fzf_key_bindings" "$bind_file"
+  append_line $update_config "fzf_key_bindings" "$bind_file"
 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

@@ -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 "Sep 2015" "fzf 0.10.6" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Nov 2015" "fzf 0.11.0" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -36,10 +36,11 @@ fzf is a general-purpose command-line fuzzy finder.
 .SS Search mode
 .TP
 .B "-x, --extended"
-Extended-search mode
+Extended-search mode. Since 0.10.9, this is enabled by default. You can disable
+it with \fB+x\fR or \fB--no-extended\fR.
 .TP
-.B "-e, --extended-exact"
+.B "-e, --exact"
-Extended-search mode (exact match)
+Enable exact-match
 .TP
 .B "-i"
 Case-insensitive match (default: smart-case match)
@@ -179,11 +180,11 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
 .RE
 
 .RS
-.B AVAILABLE KEYS:
+.B AVAILABLE KEYS:    (SYNONYMS)
     \fIctrl-[a-z]\fR
     \fIalt-[a-z]\fR
     \fIf[1-4]\fR
-    \fIenter\fR       (\fIreturn\fR)
+    \fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
     \fIspace\fR
     \fIbspace\fR      (\fIbs\fR)
     \fIalt-bspace\fR  (\fIalt-bs\fR)
@@ -201,13 +202,14 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fIpgdn\fR        (\fIpage-down\fR)
     \fIshift-left\fR
     \fIshift-right\fR
+    \fIdouble-click\fR
     or any single character
 .RE
 
 .RS
   \fBACTION:               DEFAULT BINDINGS:
     \fBabort\fR                 \fIctrl-c  ctrl-g  ctrl-q  esc\fR
-    \fBaccept\fR                \fIctrl-m  (enter)\fR
+    \fBaccept\fR                \fIenter   double-click\fR
     \fBbackward-char\fR         \fIctrl-b  left\fR
     \fBbackward-delete-char\fR  \fIctrl-h  bspace\fR
     \fBbackward-kill-word\fR    \fIalt-bs\fR
@@ -221,6 +223,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
@@ -274,6 +277,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"
@@ -369,9 +378,9 @@ of field index expressions.
 
 .SH EXTENDED SEARCH MODE
 
-With \fB-x\fR or \fB--extended\fR option, fzf will start in "extended-search
+Unless specified otherwise, fzf will start in "extended-search mode". In this
-mode". In this mode, you can specify multiple patterns delimited by spaces,
+mode, you can specify multiple patterns delimited by spaces, such as: \fB'wild
-such as: \fB'wild ^music .mp3$ sbtrkt !rmx\fR
+^music .mp3$ sbtrkt !rmx\fR
 
 .SS Exact-match (quoted)
 A term that is prefixed by a single-quote character (\fB'\fR) is interpreted as
@@ -387,11 +396,17 @@ with the given string. An anchored-match term is also an exact-match term.
 If a term is prefixed by \fB!\fR, fzf will exclude the items that satisfy the
 term from the result.
 
-.SS Extended-exact mode
+.SS Exact-match by default
 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--extended-exact\fR option
+\fB'\fR) every word, start fzf with \fB-e\fR or \fB--exact\fR option. Note that
-(instead of \fB-x\fR or \fB--extended\fR). Note that in \fB--extended-exact\fR
+when \fB--exact\fR is set, \fB'\fR-prefix "unquotes" the term.
-mode, \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)

plugin/fzf.vim

@@ -213,7 +213,7 @@ endfunction
 function! s:xterm_launcher()
   let fmt = 'xterm -T "[fzf]" -bg "\%s" -fg "\%s" -geometry %dx%d+%d+%d -e bash -ic %%s'
   if has('gui_macvim')
-    let fmt .= '; osascript -e "tell application \"MacVim\" to activate"'
+    let fmt .= '&& osascript -e "tell application \"MacVim\" to activate"'
   endif
   return printf(fmt,
     \ synIDattr(hlID("Normal"), "bg"), synIDattr(hlID("Normal"), "fg"),
@@ -222,6 +222,19 @@ endfunction
 unlet! s:launcher
 let s:launcher = function('s:xterm_launcher')
 
+function! s:exit_handler(code, command, ...)
+  if a:code == 130
+    return 0
+  elseif a:code > 1
+    call s:error('Error running ' . a:command)
+    if !empty(a:000)
+      sleep
+    endif
+    return 0
+  endif
+  return 1
+endfunction
+
 function! s:execute(dict, command, temps)
   call s:pushd(a:dict)
   silent! !clear 2> /dev/null
@@ -235,15 +248,7 @@ function! s:execute(dict, command, temps)
   endif
   execute 'silent !'.command
   redraw!
-  if v:shell_error
+  return s:exit_handler(v:shell_error, command) ? s:callback(a:dict, a:temps) : []
-    " Do not print error message on exit status 1 (no match) or 130 (interrupt)
-    if v:shell_error == 2
-      call s:error('Error running ' . command)
-    endif
-    return []
-  else
-    return s:callback(a:dict, a:temps)
-  endif
 endfunction
 
 function! s:execute_tmux(dict, command, temps)
@@ -255,11 +260,7 @@ function! s:execute_tmux(dict, command, temps)
 
   call system(command)
   redraw!
-  if v:shell_error == 2
+  return s:exit_handler(v:shell_error, command) ? s:callback(a:dict, a:temps) : []
-    call s:error('Error running ' . command)
-    return []
-  endif
-  return s:callback(a:dict, a:temps)
 endfunction
 
 function! s:calc_size(max, val, dict)
@@ -335,9 +336,7 @@ function! s:execute_term(dict, command, temps)
       endif
     endif
 
-    if a:code == 2
+    if !s:exit_handler(a:code, s:command, 1)
-      call s:error('Error running ' . s:command)
-      sleep
       return
     endif
 
@@ -358,6 +357,7 @@ function! s:execute_term(dict, command, temps)
   endfunction
 
   call termopen(a:command, fzf)
+  setf fzf
   startinsert
   return []
 endfunction
@@ -406,14 +406,24 @@ function! s:cmd_callback(lines) abort
   endif
   let key = remove(a:lines, 0)
   let cmd = get(s:action, key, 'e')
+  if len(a:lines) > 1
+    augroup fzf_swap
+      autocmd SwapExists * let v:swapchoice='o'
+            \| call s:warn('fzf: E325: swap file exists: '.expand('<afile>'))
+    augroup END
+  endif
   try
     let autochdir = &autochdir
     set noautochdir
     for item in a:lines
       execute cmd s:escape(item)
+      if exists('#BufEnter') && isdirectory(item)
+        doautocmd BufEnter
+      endif
     endfor
   finally
     let &autochdir = autochdir
+    silent! autocmd! fzf_swap
   endtry
 endfunction
 

shell/completion.bash

@@ -11,8 +11,8 @@
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
 _fzf_orig_completion_filter() {
-  sed 's/.*-F *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\2=\1;/' |
+  sed 's/^\(.*-F\) *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\3="\1 %s \3 #\2";/' |
-  sed 's/[^a-z0-9_= ;]/_/g'
+  awk -F= '{gsub(/[^a-z0-9_= ;]/, "_", $1); print $1"="$2}'
 }
 
 _fzf_opts_completion() {
@@ -22,7 +22,7 @@ _fzf_opts_completion() {
   prev="${COMP_WORDS[COMP_CWORD-1]}"
   opts="
     -x --extended
-    -e --extended-exact
+    -e --exact
     -i +i
     -n --nth
     -d --delimiter
@@ -77,12 +77,12 @@ _fzf_opts_completion() {
 }
 
 _fzf_handle_dynamic_completion() {
-  local cmd orig ret orig_cmd
+  local cmd orig_var orig ret orig_cmd
   cmd="$1"
   shift
   orig_cmd="$1"
-
+  orig_var="_fzf_orig_completion_$cmd"
-  orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+  orig="${!orig_var##*#}"
   if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
     $orig "$@"
   elif [ -n "$_fzf_completion_loader" ]; then
@@ -94,7 +94,7 @@ _fzf_handle_dynamic_completion() {
   fi
 }
 
-_fzf_path_completion() {
+__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"
   cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
@@ -135,20 +135,29 @@ _fzf_path_completion() {
   fi
 }
 
-_fzf_list_completion() {
+_fzf_feed_fifo() (
-  local cur selected trigger cmd src fzf
+  rm -f "$fifo"
+  mkfifo "$fifo"
+  cat <&0 > "$fifo" &
+)
+
+_fzf_complete() {
+  local fifo cur selected trigger cmd fzf
+  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
   [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-  read -r src
+
   cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ ${cur} == *"$trigger" ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
+    _fzf_feed_fifo "$fifo"
     tput sc
-    selected=$(eval "$src | $fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
+    selected=$(eval "cat '$fifo' | $fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
-    selected=${selected% }
+    selected=${selected% } # Strip trailing space not to repeat "-o nospace"
     tput rc
+    rm -f "$fifo"
 
     if [ -n "$selected" ]; then
       COMPREPLY=("$selected")
@@ -160,25 +169,25 @@ _fzf_list_completion() {
   fi
 }
 
-_fzf_all_completion() {
+_fzf_path_completion() {
-  _fzf_path_completion \
+  __fzf_generic_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
     "-m" "" "$@"
 }
 
 _fzf_file_completion() {
-  _fzf_path_completion \
+  __fzf_generic_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
     "-m" "" "$@"
 }
 
 _fzf_dir_completion() {
-  _fzf_path_completion \
+  __fzf_generic_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print" \
     "" "/" "$@"
 }
 
-_fzf_kill_completion() {
+_fzf_complete_kill() {
   [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
 
   local selected fzf
@@ -193,28 +202,37 @@ _fzf_kill_completion() {
   fi
 }
 
-_fzf_telnet_completion() {
+_fzf_complete_telnet() {
-  _fzf_list_completion '+m' "$@" << "EOF"
+  _fzf_complete '+m' "$@" < <(
-  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
+    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
-EOF
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
-_fzf_ssh_completion() {
+_fzf_complete_ssh() {
-  _fzf_list_completion '+m' "$@" << "EOF"
+  _fzf_complete '+m' "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
-EOF
+        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
-_fzf_env_var_completion() {
+_fzf_complete_unset() {
-  _fzf_list_completion '-m' "$@" << "EOF"
+  _fzf_complete '-m' "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }
 
-_fzf_alias_completion() {
+_fzf_complete_export() {
-  _fzf_list_completion '-m' "$@" << "EOF"
+  _fzf_complete '-m' "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete '-m' "$@" < <(
     alias | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }
 
 # fzf options
@@ -224,7 +242,7 @@ d_cmds="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
+  javac ld less more mvim nvim patch perl python ruby
   sed sftp sort source tail tee uniq vi view vim wc"
 a_cmds="
   basename bunzip2 bzip2 chmod chown curl cp dirname du
@@ -234,42 +252,58 @@ a_cmds="
 x_cmds="kill ssh telnet unset unalias export"
 
 # Preserve existing completion
-if [ "$_fzf_completion_loaded" != '0.9.12' ]; then
+if [ "$_fzf_completion_loaded" != '0.10.8' ]; then
   # Really wish I could use associative array but OSX comes with bash 3.2 :(
   eval $(complete | \grep '\-F' | \grep -v _fzf_ |
     \grep -E " ($(echo $d_cmds $f_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
-  export _fzf_completion_loaded=0.9.12
+  export _fzf_completion_loaded=0.10.8
 fi
 
 if type _completion_loader > /dev/null 2>&1; then
   _fzf_completion_loader=1
 fi
 
+_fzf_defc() {
+  local cmd func opts orig_var orig
+  cmd="$1"
+  func="$2"
+  opts="$3"
+  orig_var="_fzf_orig_completion_$cmd"
+  orig="${!orig_var}"
+  if [ -n "$orig" ]; then
+    eval "$(printf "$orig" "$func")"
+  else
+    complete -F "$func" $opts "$cmd"
+  fi
+}
+
 # Directory
 for cmd in $d_cmds; do
-  complete -F _fzf_dir_completion -o nospace -o plusdirs $cmd
+  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
 done
 
 # File
 for cmd in $f_cmds; do
-  complete -F _fzf_file_completion -o default -o bashdefault $cmd
+  _fzf_defc "$cmd" _fzf_file_completion "-o default -o bashdefault"
 done
 
 # Anything
 for cmd in $a_cmds; do
-  complete -F _fzf_all_completion -o default -o bashdefault $cmd
+  _fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
 done
 
+unset _fzf_defc
+
 # Kill completion
-complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
+complete -F _fzf_complete_kill -o nospace -o default -o bashdefault kill
 
 # Host completion
-complete -F _fzf_ssh_completion -o default -o bashdefault ssh
+complete -F _fzf_complete_ssh -o default -o bashdefault ssh
-complete -F _fzf_telnet_completion -o default -o bashdefault telnet
+complete -F _fzf_complete_telnet -o default -o bashdefault telnet
 
 # Environment variables / Aliases
-complete -F _fzf_env_var_completion -o default -o bashdefault unset
+complete -F _fzf_complete_unset -o default -o bashdefault unset
-complete -F _fzf_env_var_completion -o default -o bashdefault export
+complete -F _fzf_complete_export -o default -o bashdefault export
-complete -F _fzf_alias_completion -o default -o bashdefault unalias
+complete -F _fzf_complete_unalias -o default -o bashdefault unalias
 
 unset cmd d_cmds f_cmds a_cmds x_cmds

shell/completion.zsh

@@ -10,8 +10,9 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
-_fzf_path_completion() {
+__fzf_generic_path_completion() {
   local base lbuf find_opts 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
@@ -47,55 +48,71 @@ _fzf_path_completion() {
   [ -n "$nnm" ] && unsetopt nonomatch
 }
 
-_fzf_all_completion() {
+_fzf_path_completion() {
-  _fzf_path_completion "$1" "$2" \
+  __fzf_generic_path_completion "$1" "$2" \
     "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
     "-m" "" " "
 }
 
 _fzf_dir_completion() {
-  _fzf_path_completion "$1" "$2" \
+  __fzf_generic_path_completion "$1" "$2" \
     "-name .git -prune -o -name .svn -prune -o -type d -print" \
     "" "/" ""
 }
 
-_fzf_list_completion() {
+_fzf_feed_fifo() (
-  local prefix lbuf fzf_opts src fzf matches
+  rm -f "$fifo"
-  prefix=$1
+  mkfifo "$fifo"
+  cat <&0 > "$fifo" &
+)
+
+_fzf_complete() {
+  local fifo fzf_opts lbuf fzf matches
+  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
+  fzf_opts=$1
   lbuf=$2
-  fzf_opts=$3
-  read -r src
   [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
-  matches=$(eval "$src" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$prefix")
+  _fzf_feed_fifo "$fifo"
+  matches=$(cat "$fifo" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "${(Q)prefix}" | tr '\n' ' ')
   if [ -n "$matches" ]; then
-    LBUFFER="$lbuf$matches "
+    LBUFFER="$lbuf$matches"
   fi
   zle redisplay
+  rm -f "$fifo"
 }
 
-_fzf_telnet_completion() {
+_fzf_complete_telnet() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  _fzf_complete '+m' "$@" < <(
-  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
+    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
-EOF
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
-_fzf_ssh_completion() {
+_fzf_complete_ssh() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  _fzf_complete '+m' "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
-EOF
+        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
-_fzf_env_var_completion() {
+_fzf_complete_export() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  _fzf_complete '-m' "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }
 
-_fzf_alias_completion() {
+_fzf_complete_unset() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+  _fzf_complete '-m' "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete '+m' "$@" < <(
     alias | sed 's/=.*//'
-EOF
+  )
 }
 
 fzf-completion() {
@@ -135,18 +152,12 @@ fzf-completion() {
     [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
     [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}
 
-    if [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
+    if eval "type _fzf_complete_${cmd} > /dev/null"; then
-      _fzf_dir_completion "$prefix" $lbuf
+      eval "prefix=\"$prefix\" _fzf_complete_${cmd} \"$lbuf\""
-    elif [ $cmd = telnet ]; then
+    elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
-      _fzf_telnet_completion "$prefix" $lbuf
+      _fzf_dir_completion "$prefix" "$lbuf"
-    elif [ $cmd = ssh ]; then
-      _fzf_ssh_completion "$prefix" $lbuf
-    elif [ $cmd = unset -o $cmd = export ]; then
-      _fzf_env_var_completion "$prefix" $lbuf
-    elif [ $cmd = unalias ]; then
-      _fzf_alias_completion "$prefix" $lbuf
     else
-      _fzf_all_completion "$prefix" $lbuf
+      _fzf_path_completion "$prefix" "$lbuf"
     fi
   # Fall back to default completion
   else

shell/key-bindings.bash

@@ -1,7 +1,7 @@
 # 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-"}"
@@ -29,9 +29,10 @@ __fzf_select_tmux__() {
 }
 
 __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__() (

shell/key-bindings.fish

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

@@ -1,10 +1,10 @@
 # Key bindings
 # ------------
-if [[ $- =~ i ]]; then
+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/constants.go

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

src/core.go

@@ -143,7 +143,7 @@ func Run(opts *Options) {
 	// Matcher
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Mode, opts.Case, opts.Tiebreak != byEnd,
+			opts.Fuzzy, opts.Extended, opts.Case, opts.Tiebreak != byEnd,
 			opts.Nth, opts.Delimiter, runes)
 	}
 	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)

src/curses/curses.go

@@ -4,14 +4,14 @@ package curses
 #include <ncurses.h>
 #include <locale.h>
 #cgo !static LDFLAGS: -lncurses
-#cgo static LDFLAGS: -l:libncurses.a -l:libtinfo.a -l:libgpm.a -ldl
+#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
 */
 import "C"
 
 import (
 	"fmt"
 	"os"
-	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 	"unicode/utf8"
@@ -51,6 +51,7 @@ const (
 
 	Invalid
 	Mouse
+	DoubleClick
 
 	BTab
 	BSpace
@@ -271,14 +272,6 @@ func Init(theme *ColorTheme, black bool, mouse bool) {
 	C.noecho()
 	C.raw() // stty dsusp undef
 
-	intChan := make(chan os.Signal, 1)
-	signal.Notify(intChan, os.Interrupt, os.Kill)
-	go func() {
-		<-intChan
-		Close()
-		os.Exit(2)
-	}()
-
 	if theme != nil {
 		C.start_color()
 		initPairs(theme, black)
@@ -522,7 +515,12 @@ func MoveAndClear(y int, x int) {
 }
 
 func Print(text string) {
-	C.addstr(C.CString(text))
+	C.addstr(C.CString(strings.Map(func(r rune) rune {
+		if r < 32 {
+			return -1
+		}
+		return r
+	}, text)))
 }
 
 func CPrint(pair int, bold bool, text string) {

src/item.go

@@ -6,8 +6,8 @@ import (
 	"github.com/junegunn/fzf/src/curses"
 )
 
-// Offset holds two 32-bit integers denoting the offsets of a matched substring
+// Offset holds three 32-bit integers denoting the offsets of a matched substring
-type Offset [2]int32
+type Offset [3]int32
 
 type colorOffset struct {
 	offset [2]int32
@@ -43,10 +43,13 @@ func (item *Item) Rank(cache bool) Rank {
 	}
 	matchlen := 0
 	prevEnd := 0
+	lenSum := 0
 	minBegin := math.MaxUint16
 	for _, offset := range item.offsets {
 		begin := int(offset[0])
 		end := int(offset[1])
+		trimLen := int(offset[2])
+		lenSum += trimLen
 		if prevEnd > begin {
 			begin = prevEnd
 		}
@@ -60,15 +63,15 @@ func (item *Item) Rank(cache bool) Rank {
 			matchlen += end - begin
 		}
 	}
+	if matchlen == 0 {
+		matchlen = math.MaxUint16
+	}
 	var tiebreak uint16
 	switch rankTiebreak {
 	case byLength:
 		// It is guaranteed that .transformed in not null in normal execution
 		if item.transformed != nil {
-			lenSum := 0
+			// If offsets is empty, lenSum will be 0, but we don't care
-			for _, token := range item.transformed {
-				lenSum += len(token.text)
-			}
 			tiebreak = uint16(lenSum)
 		} else {
 			tiebreak = uint16(len(item.text))
@@ -116,7 +119,8 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 	if len(item.colors) == 0 {
 		var offsets []colorOffset
 		for _, off := range item.offsets {
-			offsets = append(offsets, colorOffset{offset: off, color: color, bold: bold})
+
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, bold: bold})
 		}
 		return offsets
 	}
@@ -160,7 +164,7 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 		if curr != 0 && idx > start {
 			if curr == -1 {
 				offsets = append(offsets, colorOffset{
-					offset: Offset{int32(start), int32(idx)}, color: color, bold: bold})
+					offset: [2]int32{int32(start), int32(idx)}, color: color, bold: bold})
 			} else {
 				ansi := item.colors[curr-1]
 				fg := ansi.color.fg
@@ -180,7 +184,7 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 					}
 				}
 				offsets = append(offsets, colorOffset{
-					offset: Offset{int32(start), int32(idx)},
+					offset: [2]int32{int32(start), int32(idx)},
 					color:  curses.PairFor(fg, bg),
 					bold:   ansi.color.bold || bold})
 			}

src/item_test.go

@@ -1,6 +1,7 @@
 package fzf
 
 import (
+	"math"
 	"sort"
 	"testing"
 
@@ -42,7 +43,7 @@ func TestItemRank(t *testing.T) {
 	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
 	item1 := Item{text: strs[0], index: 1, offsets: []Offset{}}
 	rank1 := item1.Rank(true)
-	if rank1.matchlen != 0 || rank1.tiebreak != 3 || rank1.index != 1 {
+	if rank1.matchlen != math.MaxUint16 || rank1.tiebreak != 3 || rank1.index != 1 {
 		t.Error(item1.Rank(true))
 	}
 	// Only differ in index
@@ -68,9 +69,9 @@ func TestItemRank(t *testing.T) {
 	item6 := Item{text: strs[2], rank: Rank{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/options.go

@@ -16,7 +16,8 @@ const usage = `usage: fzf [options]
 
   Search
     -x, --extended        Extended-search mode
-    -e, --extended-exact  Extended-search mode (exact match)
+                          (enabled by default; +x or --no-extended to disable)
+    -e, --exact           Enable Exact-match
     -i                    Case-insensitive match (default: smart-case match)
     +i                    Case-sensitive match
     -n, --nth=N[,..]      Comma-separated list of field index expressions
@@ -58,20 +59,10 @@ 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. '-x -m')
+    FZF_DEFAULT_OPTS      Defaults options. (e.g. '--reverse --inline-info')
 
 `
 
-// Mode denotes the current search mode
-type Mode int
-
-// Search modes
-const (
-	ModeFuzzy Mode = iota
-	ModeExtended
-	ModeExtendedExact
-)
-
 // Case denotes case-sensitivity of search
 type Case int
 
@@ -98,7 +89,8 @@ func defaultMargin() [4]string {
 
 // Options stores the values of command-line options
 type Options struct {
-	Mode        Mode
+	Fuzzy       bool
+	Extended    bool
 	Case        Case
 	Nth         []Range
 	WithNth     []Range
@@ -143,7 +135,8 @@ func defaultTheme() *curses.ColorTheme {
 
 func defaultOptions() *Options {
 	return &Options{
-		Mode:        ModeFuzzy,
+		Fuzzy:       true,
+		Extended:    true,
 		Case:        CaseSmart,
 		Nth:         make([]Range, 0),
 		WithNth:     make([]Range, 0),
@@ -343,6 +336,8 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = curses.SLeft
 		case "shift-right":
 			chord = curses.SRight
+		case "double-click":
+			chord = curses.DoubleClick
 		default:
 			if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) {
 				chord = curses.CtrlA + int(lkey[5]) - 'a'
@@ -380,8 +375,11 @@ func parseTiebreak(str string) tiebreak {
 }
 
 func dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
+	if theme != nil {
 		dupe := *theme
 		return &dupe
+	}
+	return nil
 }
 
 func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme {
@@ -402,7 +400,7 @@ func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme
 			}
 			// Color is disabled
 			if theme == nil {
-				errorExit("colors disabled; cannot customize colors")
+				continue
 			}
 
 			pair := strings.Split(str, ":")
@@ -468,10 +466,13 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 		// 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)
@@ -567,11 +568,18 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 			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)
@@ -582,10 +590,16 @@ func parseKeymap(keymap map[int]actionType, execmap map[int]string, toggleSort b
 }
 
 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), "~!@#$%^&*;/|") {
@@ -679,11 +693,17 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "-h", "--help":
 			help(exitOk)
 		case "-x", "--extended":
-			opts.Mode = ModeExtended
+			opts.Extended = true
-		case "-e", "--extended-exact":
+		case "-e", "--exact":
-			opts.Mode = ModeExtendedExact
+			opts.Fuzzy = false
-		case "+x", "--no-extended", "+e", "--no-extended-exact":
+		case "--extended-exact":
-			opts.Mode = ModeFuzzy
+			// Note that we now don't have --no-extended-exact
+			opts.Fuzzy = false
+			opts.Extended = true
+		case "+x", "--no-extended":
+			opts.Extended = false
+		case "+e", "--no-exact":
+			opts.Fuzzy = true
 		case "-q", "--query":
 			opts.Query = nextString(allArgs, &i, "query string required")
 		case "-f", "--filter":
@@ -868,7 +888,7 @@ func parseOptions(opts *Options, allArgs []string) {
 
 	// If we're not using extended search mode, --nth option becomes irrelevant
 	// if it contains the whole range
-	if opts.Mode == ModeFuzzy || len(opts.Nth) == 1 {
+	if !opts.Extended || len(opts.Nth) == 1 {
 		for _, r := range opts.Nth {
 			if r.begin == rangeEllipsis && r.end == rangeEllipsis {
 				opts.Nth = make([]Range, 0)

src/options_test.go

@@ -100,7 +100,7 @@ func TestIrrelevantNth(t *testing.T) {
 			t.Errorf("nth should be empty: %s", opts.Nth)
 		}
 	}
-	for _, words := range [][]string{[]string{"--nth", "..,3"}, []string{"--nth", "3,1.."}, []string{"--nth", "..-1,1"}} {
+	for _, words := range [][]string{[]string{"--nth", "..,3", "+x"}, []string{"--nth", "3,1..", "+x"}, []string{"--nth", "..-1,1", "+x"}} {
 		{
 			opts := defaultOptions()
 			parseOptions(opts, words)
@@ -316,3 +316,15 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("using default colors")
 	}
 }
+
+func TestParseNilTheme(t *testing.T) {
+	var theme *curses.ColorTheme
+	newTheme := parseTheme(theme, "prompt:12")
+	if newTheme != nil {
+		t.Errorf("color is disabled. keep it that way.")
+	}
+	newTheme = parseTheme(theme, "prompt:12,dark,prompt:13")
+	if newTheme.Prompt != 13 {
+		t.Errorf("color should now be enabled and customized")
+	}
+}

src/pattern.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/util"
 )
 
 // fuzzy
@@ -35,14 +36,17 @@ type term struct {
 	origText      []rune
 }
 
+type termSet []term
+
 // Pattern represents search pattern
 type Pattern struct {
-	mode          Mode
+	fuzzy         bool
+	extended      bool
 	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)
@@ -62,7 +66,7 @@ func init() {
 
 func clearPatternCache() {
 	// We can uniquely identify the pattern for a given string since
-	// mode and caseMode do not change while the program is running
+	// search mode and caseMode do not change while the program is running
 	_patternCache = make(map[string]*Pattern)
 }
 
@@ -71,14 +75,13 @@ func clearChunkCache() {
 }
 
 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(mode Mode, caseMode Case, forward bool,
+func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 	nth []Range, delimiter Delimiter, runes []rune) *Pattern {
 
 	var asString string
-	switch mode {
+	if extended {
-	case ModeExtended, ModeExtendedExact:
 		asString = strings.Trim(string(runes), " ")
-	default:
+	} else {
 		asString = string(runes)
 	}
 
@@ -87,18 +90,23 @@ func BuildPattern(mode Mode, caseMode Case, forward bool,
 		return cached
 	}
 
-	caseSensitive, hasInvTerm := true, false
+	caseSensitive, cacheable := true, true
-	terms := []term{}
+	termSets := []termSet{}
 
-	switch mode {
+	if extended {
-	case ModeExtended, ModeExtendedExact:
+		termSets = parseTerms(fuzzy, caseMode, asString)
-		terms = parseTerms(mode, caseMode, asString)
+	Loop:
-		for _, term := range terms {
+		for _, termSet := range termSets {
-			if term.inv {
+			for idx, term := range termSet {
-				hasInvTerm = true
+				// 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
 				}
 			}
-	default:
+		}
+	} else {
 		lowerString := strings.ToLower(asString)
 		caseSensitive = caseMode == CaseRespect ||
 			caseMode == CaseSmart && lowerString != asString
@@ -108,12 +116,13 @@ func BuildPattern(mode Mode, caseMode Case, forward bool,
 	}
 
 	ptr := &Pattern{
-		mode:          mode,
+		fuzzy:         fuzzy,
+		extended:      extended,
 		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))}
@@ -128,9 +137,11 @@ func BuildPattern(mode Mode, caseMode Case, forward bool,
 	return ptr
 }
 
-func parseTerms(mode Mode, 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)
@@ -140,20 +151,26 @@ func parseTerms(mode Mode, caseMode Case, str string) []term {
 			text = lowerText
 		}
 		origText := []rune(text)
-		if mode == ModeExtendedExact {
+		if !fuzzy {
 			typ = termExact
 		}
 
+		if text == "|" {
+			switchSet = false
+			continue
+		}
+
 		if strings.HasPrefix(text, "!") {
 			inv = true
 			text = text[1:]
 		}
 
 		if strings.HasPrefix(text, "'") {
-			if mode == ModeExtended {
+			// Flip exactness
+			if fuzzy {
 				typ = termExact
 				text = text[1:]
-			} else if mode == ModeExtendedExact {
+			} else {
 				typ = termFuzzy
 				text = text[1:]
 			}
@@ -171,23 +188,31 @@ func parseTerms(mode Mode, 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
 func (p *Pattern) IsEmpty() bool {
-	if p.mode == ModeFuzzy {
+	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
@@ -197,15 +222,14 @@ func (p *Pattern) AsString() string {
 
 // CacheKey is used to build string to be used as the key of result cache
 func (p *Pattern) CacheKey() string {
-	if p.mode == ModeFuzzy {
+	if !p.extended {
 		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, " ")
 }
@@ -216,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
 		}
@@ -241,7 +265,7 @@ Loop:
 
 	matches := p.matchChunk(space)
 
-	if !p.hasInvTerm {
+	if p.cacheable {
 		_cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
@@ -249,16 +273,16 @@ Loop:
 
 func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 	matches := []*Item{}
-	if p.mode == ModeFuzzy {
+	if !p.extended {
 		for _, item := range *chunk {
-			if sidx, eidx := p.fuzzyMatch(item); sidx >= 0 {
+			if sidx, eidx, tlen := p.basicMatch(item); sidx >= 0 {
 				matches = append(matches,
-					dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
+					dupItem(item, []Offset{Offset{int32(sidx), int32(eidx), int32(tlen)}}))
 			}
 		}
 	} 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))
 			}
 		}
@@ -268,12 +292,12 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 
 // MatchItem returns true if the Item is a match
 func (p *Pattern) MatchItem(item *Item) bool {
-	if p.mode == ModeFuzzy {
+	if !p.extended {
-		sidx, _ := p.fuzzyMatch(item)
+		sidx, _, _ := p.basicMatch(item)
 		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 {
@@ -288,23 +312,34 @@ func dupItem(item *Item, offsets []Offset) *Item {
 		rank:        Rank{0, 0, item.index}}
 }
 
-func (p *Pattern) fuzzyMatch(item *Item) (int, int) {
+func (p *Pattern) basicMatch(item *Item) (int, int, int) {
 	input := p.prepareInput(item)
+	if p.fuzzy {
 		return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.forward, p.text)
+	}
+	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text)
 }
 
 func (p *Pattern) extendedMatch(item *Item) []Offset {
 	input := p.prepareInput(item)
 	offsets := []Offset{}
-	for _, term := range p.terms {
+	for _, termSet := range p.termSets {
+		var offset *Offset
+		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-		if sidx, eidx := p.iter(pfun, input, term.caseSensitive, p.forward, term.text); sidx >= 0 {
+			if sidx, eidx, tlen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text); sidx >= 0 {
 				if term.inv {
-				break
+					continue
 				}
-			offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
+				offset = &Offset{int32(sidx), int32(eidx), int32(tlen)}
+				break
 			} else if term.inv {
-			offsets = append(offsets, Offset{0, 0})
+				offset = &Offset{0, 0, 0}
+				continue
+			}
+		}
+		if offset != nil {
+			offsets = append(offsets, *offset)
 		}
 	}
 	return offsets
@@ -320,19 +355,19 @@ func (p *Pattern) prepareInput(item *Item) []Token {
 		tokens := Tokenize(item.text, p.delimiter)
 		ret = Transform(tokens, p.nth)
 	} else {
-		ret = []Token{Token{text: item.text, prefixLength: 0}}
+		ret = []Token{Token{text: item.text, prefixLength: 0, trimLength: util.TrimLen(item.text)}}
 	}
 	item.transformed = ret
 	return ret
 }
 
 func (p *Pattern) iter(pfun func(bool, bool, []rune, []rune) (int, int),
-	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (int, int) {
+	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (int, int, int) {
 	for _, part := range tokens {
 		prefixLength := part.prefixLength
 		if sidx, eidx := pfun(caseSensitive, forward, part.text, pattern); sidx >= 0 {
-			return sidx + prefixLength, eidx + prefixLength
+			return sidx + prefixLength, eidx + prefixLength, part.trimLength
 		}
 	}
-	return -1, -1
+	return -1, -1, -1 // math.MaxUint16
 }

src/pattern_test.go

@@ -8,21 +8,26 @@ import (
 )
 
 func TestParseTermsExtended(t *testing.T) {
-	terms := parseTerms(ModeExtended, CaseSmart,
+	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,26 +35,31 @@ 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(ModeExtendedExact, CaseSmart,
+	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)
 	}
 }
 
 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(ModeExtended, CaseSmart, "' $ ^ !' !^ !$")
+	terms := parseTerms(true, CaseSmart, "' $ ^ !' !^ !$")
 	if len(terms) != 0 {
 		t.Errorf("%s", terms)
 	}
@@ -58,25 +68,25 @@ func TestParseTermsEmpty(t *testing.T) {
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(ModeExtended, CaseSmart, true,
+	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)
 	}
 }
 
 func TestEqual(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(ModeExtended, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
 	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)
@@ -86,17 +96,17 @@ func TestEqual(t *testing.T) {
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(ModeFuzzy, CaseSmart, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat1 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(ModeFuzzy, CaseSmart, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat2 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(ModeFuzzy, CaseIgnore, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat3 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(ModeFuzzy, CaseIgnore, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat4 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(ModeFuzzy, CaseRespect, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat5 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(ModeFuzzy, CaseRespect, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat6 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("Abc"))
 
 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -109,19 +119,19 @@ func TestCaseSensitivity(t *testing.T) {
 }
 
 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := BuildPattern(ModeExtended, CaseSmart, true, []Range{}, Delimiter{}, []rune("jg"))
+	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("jg"))
 	tokens := Tokenize([]rune("junegunn"), Delimiter{})
 	trans := Transform(tokens, []Range{Range{1, 1}})
 
 	origRunes := []rune("junegunn.choi")
-	for _, mode := range []Mode{ModeFuzzy, ModeExtended} {
+	for _, extended := range []bool{false, true} {
 		chunk := Chunk{
 			&Item{
 				text:        []rune("junegunn"),
 				origText:    &origRunes,
 				transformed: trans},
 		}
-		pattern.mode = mode
+		pattern.extended = extended
 		matches := pattern.matchChunk(&chunk)
 		if string(matches[0].text) != "junegunn" || string(*matches[0].origText) != "junegunn.choi" ||
 			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
@@ -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/terminal.go

@@ -132,6 +132,7 @@ const (
 	actPreviousHistory
 	actNextHistory
 	actExecute
+	actExecuteMulti
 )
 
 func defaultKeymap() map[int]actionType {
@@ -180,6 +181,7 @@ func defaultKeymap() map[int]actionType {
 
 	keymap[C.Rune] = actRune
 	keymap[C.Mouse] = actMouse
+	keymap[C.DoubleClick] = actAccept
 	return keymap
 }
 
@@ -304,16 +306,20 @@ func (t *Terminal) output() bool {
 			found = true
 		}
 	} else {
+		for _, sel := range t.sortSelected() {
+			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))
-		for _, sel := range sels {
+	return sels
-			fmt.Println(*sel.text)
-		}
-	}
-	return found
 }
 
 func runeWidth(r rune, prefixWidth int) int {
@@ -390,7 +396,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() {
@@ -401,7 +407,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 {
@@ -697,8 +703,12 @@ 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)
+}
+
+func executeCommand(template string, replacement string) {
+	command := strings.Replace(template, "{}", replacement, -1)
 	cmd := exec.Command("sh", "-c", command)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -712,6 +722,22 @@ func executeCommand(template string, current string) {
 func (t *Terminal) Loop() {
 	<-t.startChan
 	{ // Late initialization
+		intChan := make(chan os.Signal, 1)
+		signal.Notify(intChan, os.Interrupt, os.Kill)
+		go func() {
+			<-intChan
+			t.reqBox.Set(reqQuit, nil)
+		}()
+
+		resizeChan := make(chan os.Signal, 1)
+		signal.Notify(resizeChan, syscall.SIGWINCH)
+		go func() {
+			for {
+				<-resizeChan
+				t.reqBox.Set(reqRedraw, nil)
+			}
+		}()
+
 		t.mutex.Lock()
 		t.initFunc()
 		t.calculateMargins()
@@ -727,15 +753,6 @@ func (t *Terminal) Loop() {
 			t.reqBox.Set(reqRefresh, nil)
 		}()
 
-		resizeChan := make(chan os.Signal, 1)
-		signal.Notify(resizeChan, syscall.SIGWINCH)
-		go func() {
-			for {
-				<-resizeChan
-				t.reqBox.Set(reqRedraw, nil)
-			}
-		}()
-
 		// Keep the spinner spinning
 		go func() {
 			for {
@@ -843,29 +860,33 @@ func (t *Terminal) Loop() {
 			}
 		}
 
-		action := t.keymap[event.Type]
+		var doAction func(actionType, int) bool
-		mapkey := event.Type
+		doAction = func(action actionType, mapkey int) bool {
-		if event.Type == C.Rune {
-			mapkey = int(event.Char) + int(C.AltZ)
-			if act, prs := t.keymap[mapkey]; prs {
-				action = act
-			}
-		}
 			switch action {
 			case actIgnore:
 			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()
-			continue
+				return false
 			case actToggleSort:
 				t.sort = !t.sort
 				t.eventBox.Set(EvtSearchNew, t.sort)
 				t.mutex.Unlock()
-			continue
+				return false
 			case actBeginningOfLine:
 				t.cx = 0
 			case actBackwardChar:
@@ -1021,7 +1042,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
 					}
@@ -1033,7 +1054,7 @@ func (t *Terminal) Loop() {
 						// Double-click
 						if my >= min {
 							if t.vset(t.offset+my-min) && t.cy < t.merger.Length() {
-							req(reqClose)
+								return doAction(t.keymap[C.DoubleClick], C.DoubleClick)
 							}
 						}
 					} else if me.Down {
@@ -1050,6 +1071,19 @@ func (t *Terminal) Loop() {
 					}
 				}
 			}
+			return true
+		}
+		action := t.keymap[event.Type]
+		mapkey := event.Type
+		if event.Type == C.Rune {
+			mapkey = int(event.Char) + int(C.AltZ)
+			if act, prs := t.keymap[mapkey]; prs {
+				action = act
+			}
+		}
+		if !doAction(action, mapkey) {
+			continue
+		}
 		changed := string(previousInput) != string(t.input)
 		t.mutex.Unlock() // Must be unlocked before touching reqBox
 

src/tokenizer.go

@@ -20,6 +20,7 @@ type Range struct {
 type Token struct {
 	text         []rune
 	prefixLength int
+	trimLength   int
 }
 
 // Delimiter for tokenizing the input
@@ -81,7 +82,7 @@ func withPrefixLengths(tokens [][]rune, begin int) []Token {
 	for idx, token := range tokens {
 		// Need to define a new local variable instead of the reused token to take
 		// the pointer to it
-		ret[idx] = Token{text: token, prefixLength: prefixLength}
+		ret[idx] = Token{token, prefixLength, util.TrimLen(token)}
 		prefixLength += len(token)
 	}
 	return ret
@@ -233,7 +234,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		} else {
 			prefixLength = 0
 		}
-		transTokens[idx] = Token{part, prefixLength}
+		transTokens[idx] = Token{part, prefixLength, util.TrimLen(part)}
 	}
 	return transTokens
 }

src/tokenizer_test.go

@@ -44,22 +44,22 @@ func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
 	tokens := Tokenize([]rune(input), Delimiter{})
-	if string(tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 {
+	if string(tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 || tokens[0].trimLength != 4 {
 		t.Errorf("%s", tokens)
 	}
 
 	// With delimiter
 	tokens = Tokenize([]rune(input), delimiterRegexp(":"))
-	if string(tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 {
+	if string(tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 || tokens[0].trimLength != 4 {
 		t.Errorf("%s", tokens)
 	}
 
 	// With delimiter regex
 	tokens = Tokenize([]rune(input), delimiterRegexp("\\s+"))
-	if string(tokens[0].text) != "  " || tokens[0].prefixLength != 0 ||
+	if string(tokens[0].text) != "  " || tokens[0].prefixLength != 0 || tokens[0].trimLength != 0 ||
-		string(tokens[1].text) != "abc:  " || tokens[1].prefixLength != 2 ||
+		string(tokens[1].text) != "abc:  " || tokens[1].prefixLength != 2 || tokens[1].trimLength != 4 ||
-		string(tokens[2].text) != "def:  " || tokens[2].prefixLength != 8 ||
+		string(tokens[2].text) != "def:  " || tokens[2].prefixLength != 8 || tokens[2].trimLength != 4 ||
-		string(tokens[3].text) != "ghi  " || tokens[3].prefixLength != 14 {
+		string(tokens[3].text) != "ghi  " || tokens[3].prefixLength != 14 || tokens[3].trimLength != 3 {
 		t.Errorf("%s", tokens)
 	}
 }

src/util/util.go

@@ -75,6 +75,7 @@ func IsTty() bool {
 	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
 }
 
+// TrimRight returns rune array with trailing white spaces cut off
 func TrimRight(runes []rune) []rune {
 	var i int
 	for i = len(runes) - 1; i >= 0; i-- {
@@ -86,6 +87,7 @@ func TrimRight(runes []rune) []rune {
 	return runes[0 : i+1]
 }
 
+// BytesToRunes converts byte array into rune array
 func BytesToRunes(bytea []byte) []rune {
 	runes := make([]rune, 0, len(bytea))
 	for i := 0; i < len(bytea); {
@@ -100,3 +102,27 @@ func BytesToRunes(bytea []byte) []rune {
 	}
 	return runes
 }
+
+// TrimLen returns the length of trimmed rune array
+func TrimLen(runes []rune) int {
+	var i int
+	for i = len(runes) - 1; i >= 0; i-- {
+		char := runes[i]
+		if char != ' ' && char != '\t' {
+			break
+		}
+	}
+	// Completely empty
+	if i < 0 {
+		return 0
+	}
+
+	var j int
+	for j = 0; j < len(runes); j++ {
+		char := runes[j]
+		if char != ' ' && char != '\t' {
+			break
+		}
+	}
+	return i - j + 1
+}

src/util/util_test.go

@@ -20,3 +20,23 @@ func TestContrain(t *testing.T) {
 		t.Error("Expected", 3)
 	}
 }
+
+func TestTrimLen(t *testing.T) {
+	check := func(str string, exp int) {
+		trimmed := TrimLen([]rune(str))
+		if trimmed != exp {
+			t.Errorf("Invalid TrimLen result for '%s': %d (expected %d)",
+				str, trimmed, exp)
+		}
+	}
+	check("hello", 5)
+	check("hello ", 5)
+	check("hello  ", 5)
+	check(" hello", 5)
+	check("  hello", 5)
+	check(" hello ", 5)
+	check("  hello  ", 5)
+	check("h   o", 5)
+	check("  h   o  ", 5)
+	check("         ", 0)
+}

test/test_go.rb

@@ -8,7 +8,7 @@ DEFAULT_TIMEOUT = 20
 
 base = File.expand_path('../../', __FILE__)
 Dir.chdir base
-FZF = "#{base}/bin/fzf"
+FZF = "FZF_DEFAULT_OPTS= FZF_DEFAULT_COMMAND= #{base}/bin/fzf"
 
 class NilClass
   def include? str
@@ -213,7 +213,7 @@ class TestGoFZF < TestBase
   end
 
   def test_fzf_default_command
-    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' #{fzf}", :Enter
+    tmux.send_keys fzf.sub('FZF_DEFAULT_COMMAND=', "FZF_DEFAULT_COMMAND='echo hello'"), :Enter
     tmux.until { |lines| lines.last =~ /^>/ }
 
     tmux.send_keys :Enter
@@ -527,6 +527,53 @@ class TestGoFZF < TestBase
     assert_equal output, `cat #{tempname} | #{FZF} -fh -n2 -d:`.split($/)
   end
 
+  def test_tiebreak_length_with_nth_trim_length
+    input = [
+      "apple juice   bottle 1",
+      "apple  ui     bottle 2",
+      "app     ice   bottle 3",
+      "app     ic    bottle 4",
+    ]
+    writelines tempname, input
+
+    # len(1)
+    output = [
+      "app     ice   bottle 3",
+      "app     ic    bottle 4",
+      "apple juice   bottle 1",
+      "apple  ui     bottle 2",
+    ]
+    assert_equal output, `cat #{tempname} | #{FZF} -fa -n1`.split($/)
+
+    # len(1 ~ 2)
+    output = [
+      "apple  ui     bottle 2",
+      "app     ic    bottle 4",
+      "apple juice   bottle 1",
+      "app     ice   bottle 3",
+    ]
+    assert_equal output, `cat #{tempname} | #{FZF} -fai -n1..2`.split($/)
+
+    # len(1) + len(2)
+    output = [
+      "app     ic    bottle 4",
+      "app     ice   bottle 3",
+      "apple  ui     bottle 2",
+      "apple juice   bottle 1",
+    ]
+    assert_equal output, `cat #{tempname} | #{FZF} -x -f"a i" -n1,2`.split($/)
+
+    # len(2)
+    output = [
+      "apple  ui     bottle 2",
+      "app     ic    bottle 4",
+      "app     ice   bottle 3",
+      "apple juice   bottle 1",
+    ]
+    assert_equal output, `cat #{tempname} | #{FZF} -fi -n2`.split($/)
+    assert_equal output, `cat #{tempname} | #{FZF} -fi -n2,1..2`.split($/)
+  end
+
   def test_tiebreak_end_backward_scan
     input = %w[
       foobar-fb
@@ -666,6 +713,24 @@ 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_cycle
     tmux.send_keys "seq 8 | #{fzf :cycle}", :Enter
     tmux.until { |lines| lines[-2].include? '8/8' }
@@ -857,6 +922,23 @@ class TestGoFZF < TestBase
     end
   end
 
+  def test_default_extended
+    assert_equal '100', `seq 100 | #{FZF} -f "1 00$"`.chomp
+    assert_equal '', `seq 100 | #{FZF} -f "1 00$" +x`.chomp
+  end
+
+  def test_exact
+    assert_equal 4, `seq 123 | #{FZF} -f 13`.lines.length
+    assert_equal 2, `seq 123 | #{FZF} -f 13 -e`.lines.length
+    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
+
 private
   def writelines path, lines
     File.unlink path while File.exists? path
@@ -923,6 +1005,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