Add test case for 7e2c18a

Related: #135

.travis.yml

@@ -1,10 +1,15 @@
 language: ruby
+rvm:
+- 2.2.0
 
 install:
+- sudo apt-get update
 - sudo apt-get install -y libncurses-dev lib32ncurses5-dev
 - sudo add-apt-repository -y ppa:pi-rho/dev
+- sudo apt-add-repository -y ppa:fish-shell/release-2
 - sudo apt-get update
 - sudo apt-get install -y tmux=1.9a-1~ppa1~p
+- sudo apt-get install -y zsh fish
 
 script: |
   export GOROOT=~/go1.4

CHANGELOG.md

@@ -0,0 +1,60 @@
+CHANGELOG
+=========
+
+0.9.4
+-----
+
+### New features
+
+#### Added `--tac` option to reverse the order of the input.
+
+One might argue that this option is unnecessary since we can already put `tac`
+or `tail -r` in the command pipeline to achieve the same result. However, the
+advantage of `--tac` is that it does not block until the input is complete.
+
+### *Backward incompatible changes*
+
+#### Changed behavior on `--no-sort`
+
+`--no-sort` option will no longer reverse the display order within finder. You
+may want to use the new `--tac` option with `--no-sort`.
+
+```
+history | fzf +s --tac
+```
+
+### Improvements
+
+#### `--filter` will not block when sort is disabled
+
+When fzf works in filtering mode (`--filter`) and sort is disabled
+(`--no-sort`), there's no need to block until input is complete. The new
+version of fzf will print the matches on-the-fly when the following condition
+is met:
+
+    --filter TERM --no-sort [--no-tac --no-sync]
+
+or simply:
+
+    -f TERM +s
+
+This change removes unnecessary delay in the use cases like the following:
+
+    fzf -f xxx +s | head -5
+
+However, in this case, fzf processes the lines sequentially, so it cannot
+utilize multiple cores, and fzf will run slightly slower than the previous
+mode of execution where filtering is done in parallel after the entire input
+is loaded. If the user is concerned about this performance problem, one can
+add `--sync` option to re-enable buffering.
+
+0.9.3
+-----
+
+### New features
+- Added `--sync` option for multi-staged filtering
+
+### Improvements
+- `--select-1` and `--exit-0` will start finder immediately when the condition
+  cannot be met
+

README.md

@@ -11,6 +11,20 @@ the likes.
 Installation
 ------------
 
+fzf project consists of the followings:
+
+- `fzf` executable
+- Shell extensions
+    - Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
+    - Fuzzy auto-completion (bash)
+
+You can [download fzf executable][bin] alone, but it's recommended that you
+install the extra stuff using the attached install script.
+
+[bin]: https://github.com/junegunn/fzf-bin/releases
+
+### Using git (recommended)
+
 Clone this repository and run
 [install](https://github.com/junegunn/fzf/blob/master/install) script.
 
@@ -19,6 +33,8 @@ git clone https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
+### Using curl
+
 In case you don't have git installed:
 
 ```sh
@@ -28,15 +44,16 @@ curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
 ~/.fzf/install
 ```
 
-The script will setup:
+### Using Homebrew
 
-- `fzf` function (bash, zsh, fish)
-- Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
-- Fuzzy auto-completion (bash)
+On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
 
-If you don't use any of the aforementioned shells, you have to manually place
-fzf executable in a directory included in `$PATH`. Key bindings and
-auto-completion will not be available in that case.
+```sh
+brew install fzf
+
+# Install shell extensions - this should be done whenever fzf is updated
+/usr/local/Cellar/fzf/$(fzf --version)/install
+```
 
 ### Install as Vim plugin
 
@@ -46,8 +63,7 @@ Once you have cloned the repository, add the following line to your .vimrc.
 set rtp+=~/.fzf
 ```
 
-Or you may use [vim-plug](https://github.com/junegunn/vim-plug) to manage fzf
-inside Vim:
+Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf:
 
 ```vim
 Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
@@ -59,7 +75,7 @@ Usage
 ```
 usage: fzf [options]
 
-  Search
+  Search mode
     -x, --extended        Extended-search mode
     -e, --extended-exact  Extended-search mode (exact match)
     -i                    Case-insensitive match (default: smart-case match)
@@ -71,8 +87,9 @@ usage: fzf [options]
     -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
 
   Search result
-    -s, --sort=MAX        Maximum number of matched items to sort (default: 1000)
-    +s, --no-sort         Do not sort the result. Keep the sequence unchanged.
+    +s, --no-sort         Do not sort the result
+        --tac             Reverse the order of the input
+                          (e.g. 'history | fzf --tac --no-sort')
 
   Interface
     -m, --multi           Enable multi-select with tab/shift-tab
@@ -89,10 +106,12 @@ usage: fzf [options]
     -0, --exit-0          Exit immediately when there's no match
     -f, --filter=STR      Filter mode. Do not start interactive finder.
         --print-query     Print query as the first line
+        --sync            Synchronous search for multi-staged filtering
+                          (e.g. 'fzf --multi | fzf --sync')
 
   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      Defaults options. (e.g. '-x -m')
 ```
 
 fzf will launch curses-based finder, read the list from STDIN, and write the
@@ -110,13 +129,6 @@ files excluding hidden ones. (You can override the default command with
 vim $(fzf)
 ```
 
-If you want to preserve the exact sequence of the input, provide `--no-sort` (or
-`+s`) option.
-
-```sh
-history | fzf +s
-```
-
 ### Keys
 
 Use CTRL-J and CTRL-K (or CTRL-N and CTRL-P) to change the selection, press
@@ -179,7 +191,7 @@ fd() {
 
 # fh - repeat history
 fh() {
-  eval $(([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s | sed 's/ *[0-9]* *//')
+  eval $(([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed 's/ *[0-9]* *//')
 }
 
 # fkill - kill process
@@ -542,4 +554,3 @@ Author
 ------
 
 Junegunn Choi
-

fzf-completion.bash

@@ -88,7 +88,7 @@ _fzf_path_completion() {
         [ "$dir" = './' ] && dir=''
         tput sc
         matches=$(find -L "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
-          printf '%q ' "$item"
+          printf "%q$3 " "$item"
         done)
         matches=${matches% }
         if [ -n "$matches" ]; then
@@ -103,6 +103,7 @@ _fzf_path_completion() {
       [[ "$dir" =~ /$ ]] || dir="$dir"/
     done
   else
+    shift
     shift
     shift
     _fzf_handle_dynamic_completion "$cmd" "$@"
@@ -136,19 +137,19 @@ _fzf_list_completion() {
 _fzf_all_completion() {
   _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
-    "-m" "$@"
+    "-m" "" "$@"
 }
 
 _fzf_file_completion() {
   _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
-    "-m" "$@"
+    "-m" "" "$@"
 }
 
 _fzf_dir_completion() {
   _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print" \
-    "" "$@"
+    "" "/" "$@"
 }
 
 _fzf_kill_completion() {
@@ -219,7 +220,7 @@ fi
 
 # Directory
 for cmd in $d_cmds; do
-  complete -F _fzf_dir_completion -o default -o bashdefault $cmd
+  complete -F _fzf_dir_completion -o nospace -o plusdirs $cmd
 done
 
 # File

install

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-version=0.9.2
+version=0.9.4
 
 cd $(dirname $BASH_SOURCE)
 fzf_base=$(pwd)
@@ -159,7 +159,7 @@ for shell in bash zsh; do
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
-  fzf_completion="[[ \$- =~ i ]] && source $fzf_base/fzf-completion.${shell}"
+  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/fzf-completion.${shell}\""
   if [ $auto_completion -ne 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
@@ -202,10 +202,10 @@ EOF
 # Key bindings
 # ------------
 __fsel() {
-  command find * -path '*/\.*' -prune \
+  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 | fzf -m | while read item; do
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
     printf '%q ' "$item"
   done
   echo
@@ -226,7 +226,8 @@ __fsel_tmux() {
 
 __fcd() {
   local dir
-  dir=$(command find -L ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf +m) && printf 'cd %q' "$dir"
+  dir=$(command find -L ${1:-.} \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m) && printf 'cd %q' "$dir"
 }
 
 __use_tmux=0
@@ -244,7 +245,7 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
   fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s +m -n2..,.. | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
+  bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s --tac +m -n2..,.. | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
 
   # ALT-C - cd into the selected directory
   bind '"\ec": " \C-e\C-u$(__fcd)\e\C-e\er\C-m"'
@@ -262,7 +263,7 @@ else
   bind -m vi-command '"\C-t": "i\C-t"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s +m -n2..,.. | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
+  bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s --tac +m -n2..,.. | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
   bind -m vi-command '"\C-r": "i\C-r"'
 
   # ALT-C - cd into the selected directory
@@ -274,17 +275,16 @@ unset __use_tmux
 
 fi
 EOFZF
-    else
+    else  # zsh
       cat >> $src << "EOFZF"
 # Key bindings
 # ------------
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
-  set -o nonomatch
-  command find * -path '*/\.*' -prune \
+  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 | fzf -m | while read item; do
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
     printf '%q ' "$item"
   done
   echo
@@ -314,8 +314,8 @@ bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  cd "${$(set -o nonomatch; command find -L * -path '*/\.*' -prune \
-          -o -type d -print 2> /dev/null | fzf):-.}"
+  cd "${$(command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m):-.}"
   zle reset-prompt
 }
 zle     -N    fzf-cd-widget
@@ -323,7 +323,7 @@ bindkey '\ec' fzf-cd-widget
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  LBUFFER=$(fc -l 1 | fzf +s +m -n2..,.. | sed "s/ *[0-9*]* *//")
+  LBUFFER=$(fc -l 1 | fzf +s --tac +m -n2..,.. | sed "s/ *[0-9*]* *//")
   zle redisplay
 }
 zle     -N   fzf-history-widget
@@ -369,14 +369,15 @@ function fzf_key_bindings
   end
 
   function __fzf_list
-    command find * -path '*/\.*' -prune \
+    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
+      -o -type l -print 2> /dev/null | sed 1d | cut -b3-
   end
 
   function __fzf_list_dir
-    command find -L * -path '*/\.*' -prune -o -type d -print 2> /dev/null
+    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) \
+      -prune -o -type d -print 2> /dev/null | sed 1d | cut -b3-
   end
 
   function __fzf_escape
@@ -411,7 +412,7 @@ function fzf_key_bindings
   end
 
   function __fzf_ctrl_r
-    history | __fzf_reverse | fzf +s +m > $TMPDIR/fzf.result
+    history | __fzf_reverse | fzf +s --tac +m > $TMPDIR/fzf.result
     and commandline (cat $TMPDIR/fzf.result)
     commandline -f repaint
     rm -f $TMPDIR/fzf.result

src/Dockerfile.arch

@@ -6,7 +6,7 @@ RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/Dockerfile.centos

@@ -6,7 +6,7 @@ RUN yum install -y git gcc make tar ncurses-devel
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/Dockerfile.ubuntu

@@ -7,7 +7,7 @@ RUN apt-get update && apt-get -y upgrade && \
 
 # Install Go 1.4
 RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
     tar -xz && mv go go1.4
 
 ENV GOPATH /go

src/constants.go

@@ -5,7 +5,7 @@ import (
 )
 
 // Current version
-const Version = "0.9.2"
+const Version = "0.9.4"
 
 // fzf events
 const (

src/core.go

@@ -85,61 +85,55 @@ func Run(options *Options) {
 	}
 
 	// Reader
-	reader := Reader{func(str string) { chunkList.Push(str) }, eventBox}
-	go reader.ReadSource()
+	streamingFilter := opts.Filter != nil && opts.Sort == 0 && !opts.Tac && !opts.Sync
+	if !streamingFilter {
+		reader := Reader{func(str string) { chunkList.Push(str) }, eventBox}
+		go reader.ReadSource()
+	}
 
 	// Matcher
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
 			opts.Mode, opts.Case, opts.Nth, opts.Delimiter, runes)
 	}
-	matcher := NewMatcher(patternBuilder, opts.Sort > 0, eventBox)
+	matcher := NewMatcher(patternBuilder, opts.Sort > 0, opts.Tac, eventBox)
 
-	// Defered-interactive / Non-interactive
-	//   --select-1 | --exit-0 | --filter
-	if filtering := opts.Filter != nil; filtering || opts.Select1 || opts.Exit0 {
-		limit := 0
-		var patternString string
-		if filtering {
-			patternString = *opts.Filter
-		} else {
-			if opts.Select1 || opts.Exit0 {
-				limit = 1
-			}
-			patternString = opts.Query
+	// Filtering mode
+	if opts.Filter != nil {
+		if opts.PrintQuery {
+			fmt.Println(*opts.Filter)
 		}
-		pattern := patternBuilder([]rune(patternString))
 
-		looping := true
-		eventBox.Unwatch(EvtReadNew)
-		for looping {
-			eventBox.Wait(func(events *util.Events) {
-				for evt := range *events {
-					switch evt {
-					case EvtReadFin:
-						looping = false
-						return
+		pattern := patternBuilder([]rune(*opts.Filter))
+
+		if streamingFilter {
+			reader := Reader{
+				func(str string) {
+					item := chunkList.trans(&str, 0)
+					if pattern.MatchItem(item) {
+						fmt.Println(*item.text)
 					}
-				}
-			})
-		}
+				}, eventBox}
+			reader.ReadSource()
+		} else {
+			eventBox.Unwatch(EvtReadNew)
+			eventBox.WaitFor(EvtReadFin)
 
-		snapshot, _ := chunkList.Snapshot()
-		merger, cancelled := matcher.scan(MatchRequest{
-			chunks:  snapshot,
-			pattern: pattern}, limit)
-
-		if !cancelled && (filtering ||
-			opts.Exit0 && merger.Length() == 0 ||
-			opts.Select1 && merger.Length() == 1) {
-			if opts.PrintQuery {
-				fmt.Println(patternString)
-			}
+			snapshot, _ := chunkList.Snapshot()
+			merger, _ := matcher.scan(MatchRequest{
+				chunks:  snapshot,
+				pattern: pattern})
 			for i := 0; i < merger.Length(); i++ {
 				fmt.Println(merger.Get(i).AsString())
 			}
-			os.Exit(0)
 		}
+		os.Exit(0)
+	}
+
+	// Synchronous search
+	if opts.Sync {
+		eventBox.Unwatch(EvtReadNew)
+		eventBox.WaitFor(EvtReadFin)
 	}
 
 	// Go interactive
@@ -147,7 +141,11 @@ func Run(options *Options) {
 
 	// Terminal I/O
 	terminal := NewTerminal(opts, eventBox)
+	deferred := opts.Select1 || opts.Exit0
 	go terminal.Loop()
+	if !deferred {
+		terminal.startChan <- true
+	}
 
 	// Event coordination
 	reading := true
@@ -165,11 +163,11 @@ func Run(options *Options) {
 					reading = reading && evt == EvtReadNew
 					snapshot, count := chunkList.Snapshot()
 					terminal.UpdateCount(count, !reading)
-					matcher.Reset(snapshot, terminal.Input(), false)
+					matcher.Reset(snapshot, terminal.Input(), false, !reading)
 
 				case EvtSearchNew:
 					snapshot, _ := chunkList.Snapshot()
-					matcher.Reset(snapshot, terminal.Input(), true)
+					matcher.Reset(snapshot, terminal.Input(), true, !reading)
 					delay = false
 
 				case EvtSearchProgress:
@@ -181,6 +179,25 @@ func Run(options *Options) {
 				case EvtSearchFin:
 					switch val := value.(type) {
 					case *Merger:
+						if deferred {
+							count := val.Length()
+							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
+								deferred = false
+								terminal.startChan <- true
+							} else if val.final {
+								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
+									if opts.PrintQuery {
+										fmt.Println(opts.Query)
+									}
+									for i := 0; i < count; i++ {
+										fmt.Println(val.Get(i).AsString())
+									}
+									os.Exit(0)
+								}
+								deferred = false
+								terminal.startChan <- true
+							}
+						}
 						terminal.UpdateList(val)
 					}
 				}

src/item.go

@@ -87,10 +87,28 @@ func (a ByRelevance) Less(i, j int) bool {
 	irank := a[i].Rank(true)
 	jrank := a[j].Rank(true)
 
-	return compareRanks(irank, jrank)
+	return compareRanks(irank, jrank, false)
 }
 
-func compareRanks(irank Rank, jrank Rank) bool {
+// ByRelevanceTac is for sorting Items
+type ByRelevanceTac []*Item
+
+func (a ByRelevanceTac) Len() int {
+	return len(a)
+}
+
+func (a ByRelevanceTac) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevanceTac) Less(i, j int) bool {
+	irank := a[i].Rank(true)
+	jrank := a[j].Rank(true)
+
+	return compareRanks(irank, jrank, true)
+}
+
+func compareRanks(irank Rank, jrank Rank, tac bool) bool {
 	if irank.matchlen < jrank.matchlen {
 		return true
 	} else if irank.matchlen > jrank.matchlen {
@@ -103,8 +121,5 @@ func compareRanks(irank Rank, jrank Rank) bool {
 		return false
 	}
 
-	if irank.index <= jrank.index {
-		return true
-	}
-	return false
+	return (irank.index <= jrank.index) != tac
 }

src/item_test.go

@@ -20,12 +20,19 @@ func TestOffsetSort(t *testing.T) {
 }
 
 func TestRankComparison(t *testing.T) {
-	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}) ||
-		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}) ||
-		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}) ||
-		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}) {
+	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, false) ||
+		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
+		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, false) ||
+		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
 		t.Error("Invalid order")
 	}
+
+	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, true) ||
+		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
+		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, true) ||
+		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
+		t.Error("Invalid order (tac)")
+	}
 }
 
 // Match length, string length, index

src/matcher.go

@@ -14,12 +14,14 @@ import (
 type MatchRequest struct {
 	chunks  []*Chunk
 	pattern *Pattern
+	final   bool
 }
 
 // Matcher is responsible for performing search
 type Matcher struct {
 	patternBuilder func([]rune) *Pattern
 	sort           bool
+	tac            bool
 	eventBox       *util.EventBox
 	reqBox         *util.EventBox
 	partitions     int
@@ -37,10 +39,11 @@ const (
 
 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
-	sort bool, eventBox *util.EventBox) *Matcher {
+	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
 	return &Matcher{
 		patternBuilder: patternBuilder,
 		sort:           sort,
+		tac:            tac,
 		eventBox:       eventBox,
 		reqBox:         util.NewEventBox(),
 		partitions:     runtime.NumCPU(),
@@ -86,11 +89,12 @@ func (m *Matcher) Loop() {
 		}
 
 		if !foundCache {
-			merger, cancelled = m.scan(request, 0)
+			merger, cancelled = m.scan(request)
 		}
 
 		if !cancelled {
 			m.mergerCache[patternString] = merger
+			merger.final = request.final
 			m.eventBox.Set(EvtSearchFin, merger)
 		}
 	}
@@ -121,7 +125,7 @@ type partialResult struct {
 	matches []*Item
 }
 
-func (m *Matcher) scan(request MatchRequest, limit int) (*Merger, bool) {
+func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 	startedAt := time.Now()
 
 	numChunks := len(request.chunks)
@@ -157,7 +161,11 @@ func (m *Matcher) scan(request MatchRequest, limit int) (*Merger, bool) {
 				countChan <- len(matches)
 			}
 			if !empty && m.sort {
-				sort.Sort(ByRelevance(sliceMatches))
+				if m.tac {
+					sort.Sort(ByRelevanceTac(sliceMatches))
+				} else {
+					sort.Sort(ByRelevance(sliceMatches))
+				}
 			}
 			resultChan <- partialResult{idx, sliceMatches}
 		}(idx, chunks)
@@ -175,15 +183,11 @@ func (m *Matcher) scan(request MatchRequest, limit int) (*Merger, bool) {
 		count++
 		matchCount += matchesInChunk
 
-		if limit > 0 && matchCount > limit {
-			return nil, wait() // For --select-1 and --exit-0
-		}
-
 		if count == numChunks {
 			break
 		}
 
-		if !empty && m.reqBox.Peak(reqReset) {
+		if !empty && m.reqBox.Peek(reqReset) {
 			return nil, wait()
 		}
 
@@ -197,11 +201,11 @@ func (m *Matcher) scan(request MatchRequest, limit int) (*Merger, bool) {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(partialResults, !empty && m.sort), false
+	return NewMerger(partialResults, !empty && m.sort, m.tac), false
 }
 
 // Reset is called to interrupt/signal the ongoing search
-func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool) {
 	pattern := m.patternBuilder(patternRunes)
 
 	var event util.EventType
@@ -210,5 +214,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool) {
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern})
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final})
 }

src/merger.go

@@ -3,7 +3,7 @@ package fzf
 import "fmt"
 
 // Merger with no data
-var EmptyMerger = NewMerger([][]*Item{}, false)
+var EmptyMerger = NewMerger([][]*Item{}, false, false)
 
 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
@@ -12,16 +12,20 @@ type Merger struct {
 	merged  []*Item
 	cursors []int
 	sorted  bool
+	tac     bool
+	final   bool
 	count   int
 }
 
 // NewMerger returns a new Merger
-func NewMerger(lists [][]*Item, sorted bool) *Merger {
+func NewMerger(lists [][]*Item, sorted bool, tac bool) *Merger {
 	mg := Merger{
 		lists:   lists,
 		merged:  []*Item{},
 		cursors: make([]int, len(lists)),
 		sorted:  sorted,
+		tac:     tac,
+		final:   false,
 		count:   0}
 
 	for _, list := range mg.lists {
@@ -37,19 +41,21 @@ func (mg *Merger) Length() int {
 
 // Get returns the pointer to the Item object indexed by the given integer
 func (mg *Merger) Get(idx int) *Item {
-	if len(mg.lists) == 1 {
-		return mg.lists[0][idx]
-	} else if !mg.sorted {
-		for _, list := range mg.lists {
-			numItems := len(list)
-			if idx < numItems {
-				return list[idx]
-			}
-			idx -= numItems
-		}
-		panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+	if mg.sorted {
+		return mg.mergedGet(idx)
 	}
-	return mg.mergedGet(idx)
+
+	if mg.tac {
+		idx = mg.Length() - idx - 1
+	}
+	for _, list := range mg.lists {
+		numItems := len(list)
+		if idx < numItems {
+			return list[idx]
+		}
+		idx -= numItems
+	}
+	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
 }
 
 func (mg *Merger) mergedGet(idx int) *Item {
@@ -64,7 +70,7 @@ func (mg *Merger) mergedGet(idx int) *Item {
 			}
 			if cursor >= 0 {
 				rank := list[cursor].Rank(false)
-				if minIdx < 0 || compareRanks(rank, minRank) {
+				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
 					minRank = rank
 					minIdx = listIdx
 				}

src/merger_test.go

@@ -62,7 +62,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)
 
 	// Not sorted: same order
-	mg := NewMerger(lists, false)
+	mg := NewMerger(lists, false, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	for i := 0; i < cnt; i++ {
 		assert(t, items[i] == mg.Get(i), "Invalid Get")
@@ -74,7 +74,7 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)
 
 	// Sorted sorted order
-	mg := NewMerger(lists, true)
+	mg := NewMerger(lists, true, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
 	for i := 0; i < cnt; i++ {
@@ -84,7 +84,7 @@ func TestMergerSorted(t *testing.T) {
 	}
 
 	// Inverse order
-	mg2 := NewMerger(lists, true)
+	mg2 := NewMerger(lists, true, false)
 	for i := cnt - 1; i >= 0; i-- {
 		if items[i] != mg2.Get(i) {
 			t.Error("Not sorted", items[i], mg2.Get(i))

src/options.go

@@ -11,7 +11,7 @@ import (
 
 const usage = `usage: fzf [options]
 
-  Search
+  Search mode
     -x, --extended        Extended-search mode
     -e, --extended-exact  Extended-search mode (exact match)
     -i                    Case-insensitive match (default: smart-case match)
@@ -23,8 +23,9 @@ const usage = `usage: fzf [options]
     -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
 
   Search result
-    -s, --sort            Sort the result
-    +s, --no-sort         Do not sort the result. Keep the sequence unchanged.
+    +s, --no-sort         Do not sort the result
+        --tac             Reverse the order of the input
+                          (e.g. 'history | fzf --tac --no-sort')
 
   Interface
     -m, --multi           Enable multi-select with tab/shift-tab
@@ -41,10 +42,12 @@ const usage = `usage: fzf [options]
     -0, --exit-0          Exit immediately when there's no match
     -f, --filter=STR      Filter mode. Do not start interactive finder.
         --print-query     Print query as the first line
+        --sync            Synchronous search for multi-staged filtering
+                          (e.g. 'fzf --multi | fzf --sync')
 
   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. '-x -m')
 
 `
 
@@ -76,6 +79,7 @@ type Options struct {
 	WithNth    []Range
 	Delimiter  *regexp.Regexp
 	Sort       int
+	Tac        bool
 	Multi      bool
 	Mouse      bool
 	Color      bool
@@ -88,6 +92,7 @@ type Options struct {
 	Exit0      bool
 	Filter     *string
 	PrintQuery bool
+	Sync       bool
 	Version    bool
 }
 
@@ -99,6 +104,7 @@ func defaultOptions() *Options {
 		WithNth:    make([]Range, 0),
 		Delimiter:  nil,
 		Sort:       1000,
+		Tac:        false,
 		Multi:      false,
 		Mouse:      true,
 		Color:      true,
@@ -111,6 +117,7 @@ func defaultOptions() *Options {
 		Exit0:      false,
 		Filter:     nil,
 		PrintQuery: false,
+		Sync:       false,
 		Version:    false}
 }
 
@@ -208,6 +215,10 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Sort = optionalNumeric(allArgs, &i)
 		case "+s", "--no-sort":
 			opts.Sort = 0
+		case "--tac":
+			opts.Tac = true
+		case "--no-tac":
+			opts.Tac = false
 		case "-i":
 			opts.Case = CaseIgnore
 		case "+i":
@@ -244,6 +255,12 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.PrintQuery = false
 		case "--prompt":
 			opts.Prompt = nextString(allArgs, &i, "prompt string required")
+		case "--sync":
+			opts.Sync = true
+		case "--no-sync":
+			opts.Sync = false
+		case "--async":
+			opts.Sync = false
 		case "--version":
 			opts.Version = true
 		default:

src/pattern.go

@@ -219,12 +219,7 @@ Loop:
 		}
 	}
 
-	var matches []*Item
-	if p.mode == ModeFuzzy {
-		matches = p.fuzzyMatch(space)
-	} else {
-		matches = p.extendedMatch(space)
-	}
+	matches := p.matchChunk(space)
 
 	if !p.hasInvTerm {
 		_cache.Add(chunk, cacheKey, matches)
@@ -232,6 +227,35 @@ Loop:
 	return matches
 }
 
+func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
+	matches := []*Item{}
+	if p.mode == ModeFuzzy {
+		for _, item := range *chunk {
+			if sidx, eidx := p.fuzzyMatch(item); sidx >= 0 {
+				matches = append(matches,
+					dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
+			}
+		}
+	} else {
+		for _, item := range *chunk {
+			if offsets := p.extendedMatch(item); len(offsets) == len(p.terms) {
+				matches = append(matches, dupItem(item, offsets))
+			}
+		}
+	}
+	return matches
+}
+
+// MatchItem returns true if the Item is a match
+func (p *Pattern) MatchItem(item *Item) bool {
+	if p.mode == ModeFuzzy {
+		sidx, _ := p.fuzzyMatch(item)
+		return sidx >= 0
+	}
+	offsets := p.extendedMatch(item)
+	return len(offsets) == len(p.terms)
+}
+
 func dupItem(item *Item, offsets []Offset) *Item {
 	sort.Sort(ByOrder(offsets))
 	return &Item{
@@ -243,39 +267,26 @@ func dupItem(item *Item, offsets []Offset) *Item {
 		rank:        Rank{0, 0, item.index}}
 }
 
-func (p *Pattern) fuzzyMatch(chunk *Chunk) []*Item {
-	matches := []*Item{}
-	for _, item := range *chunk {
-		input := p.prepareInput(item)
-		if sidx, eidx := p.iter(algo.FuzzyMatch, input, p.text); sidx >= 0 {
-			matches = append(matches,
-				dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
-		}
-	}
-	return matches
+func (p *Pattern) fuzzyMatch(item *Item) (int, int) {
+	input := p.prepareInput(item)
+	return p.iter(algo.FuzzyMatch, input, p.text)
 }
 
-func (p *Pattern) extendedMatch(chunk *Chunk) []*Item {
-	matches := []*Item{}
-	for _, item := range *chunk {
-		input := p.prepareInput(item)
-		offsets := []Offset{}
-		for _, term := range p.terms {
-			pfun := p.procFun[term.typ]
-			if sidx, eidx := p.iter(pfun, input, term.text); sidx >= 0 {
-				if term.inv {
-					break
-				}
-				offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
-			} else if term.inv {
-				offsets = append(offsets, Offset{0, 0})
+func (p *Pattern) extendedMatch(item *Item) []Offset {
+	input := p.prepareInput(item)
+	offsets := []Offset{}
+	for _, term := range p.terms {
+		pfun := p.procFun[term.typ]
+		if sidx, eidx := p.iter(pfun, input, term.text); sidx >= 0 {
+			if term.inv {
+				break
 			}
-		}
-		if len(offsets) == len(p.terms) {
-			matches = append(matches, dupItem(item, offsets))
+			offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
+		} else if term.inv {
+			offsets = append(offsets, Offset{0, 0})
 		}
 	}
-	return matches
+	return offsets
 }
 
 func (p *Pattern) prepareInput(item *Item) *Transformed {

src/pattern_test.go

@@ -98,14 +98,15 @@ func TestOrigTextAndTransformed(t *testing.T) {
 	tokens := Tokenize(strptr("junegunn"), nil)
 	trans := Transform(tokens, []Range{Range{1, 1}})
 
-	for _, fun := range []func(*Chunk) []*Item{pattern.fuzzyMatch, pattern.extendedMatch} {
+	for _, mode := range []Mode{ModeFuzzy, ModeExtended} {
 		chunk := Chunk{
 			&Item{
 				text:        strptr("junegunn"),
 				origText:    strptr("junegunn.choi"),
 				transformed: trans},
 		}
-		matches := fun(&chunk)
+		pattern.mode = mode
+		matches := pattern.matchChunk(&chunk)
 		if *matches[0].text != "junegunn" || *matches[0].origText != "junegunn.choi" ||
 			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
 			matches[0].transformed != trans {

src/reader_test.go

@@ -14,7 +14,7 @@ func TestReadFromCommand(t *testing.T) {
 		eventBox: eb}
 
 	// Check EventBox
-	if eb.Peak(EvtReadNew) {
+	if eb.Peek(EvtReadNew) {
 		t.Error("EvtReadNew should not be set yet")
 	}
 
@@ -25,7 +25,7 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Check EventBox again
-	if !eb.Peak(EvtReadNew) {
+	if !eb.Peek(EvtReadNew) {
 		t.Error("EvtReadNew should be set yet")
 	}
 
@@ -38,7 +38,7 @@ func TestReadFromCommand(t *testing.T) {
 	})
 
 	// EventBox is cleared
-	if eb.Peak(EvtReadNew) {
+	if eb.Peek(EvtReadNew) {
 		t.Error("EvtReadNew should not be set yet")
 	}
 
@@ -50,7 +50,7 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Check EventBox again
-	if eb.Peak(EvtReadNew) {
+	if eb.Peek(EvtReadNew) {
 		t.Error("Command failed. EvtReadNew should be set")
 	}
 }

src/terminal.go

@@ -22,7 +22,6 @@ import (
 type Terminal struct {
 	prompt     string
 	reverse    bool
-	tac        bool
 	cx         int
 	cy         int
 	offset     int
@@ -40,6 +39,7 @@ type Terminal struct {
 	mutex      sync.Mutex
 	initFunc   func()
 	suppress   bool
+	startChan  chan bool
 }
 
 type selectedItem struct {
@@ -84,7 +84,6 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 	input := []rune(opts.Query)
 	return &Terminal{
 		prompt:     opts.Prompt,
-		tac:        opts.Sort == 0,
 		reverse:    opts.Reverse,
 		cx:         len(input),
 		cy:         0,
@@ -99,6 +98,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
 		suppress:   true,
+		startChan:  make(chan bool, 1),
 		initFunc: func() {
 			C.Init(opts.Color, opts.Color256, opts.Black, opts.Mouse)
 		}}
@@ -146,13 +146,6 @@ func (t *Terminal) UpdateList(merger *Merger) {
 	t.reqBox.Set(reqList, nil)
 }
 
-func (t *Terminal) listIndex(y int) int {
-	if t.tac {
-		return t.merger.Length() - y - 1
-	}
-	return y
-}
-
 func (t *Terminal) output() {
 	if t.printQuery {
 		fmt.Println(string(t.input))
@@ -160,7 +153,7 @@ func (t *Terminal) output() {
 	if len(t.selected) == 0 {
 		cnt := t.merger.Length()
 		if cnt > 0 && cnt > t.cy {
-			fmt.Println(t.merger.Get(t.listIndex(t.cy)).AsString())
+			fmt.Println(t.merger.Get(t.cy).AsString())
 		}
 	} else {
 		sels := make([]selectedItem, 0, len(t.selected))
@@ -244,7 +237,7 @@ func (t *Terminal) printList() {
 	for i := 0; i < maxy; i++ {
 		t.move(i+2, 0, true)
 		if i < count {
-			t.printItem(t.merger.Get(t.listIndex(i+t.offset)), i == t.cy-t.offset)
+			t.printItem(t.merger.Get(i+t.offset), i == t.cy-t.offset)
 		}
 	}
 }
@@ -446,6 +439,7 @@ func (t *Terminal) rubout(pattern string) {
 
 // Loop is called to start Terminal I/O
 func (t *Terminal) Loop() {
+	<-t.startChan
 	{ // Late initialization
 		t.mutex.Lock()
 		t.initFunc()
@@ -522,9 +516,8 @@ func (t *Terminal) Loop() {
 			}
 		}
 		toggle := func() {
-			idx := t.listIndex(t.cy)
-			if idx < t.merger.Length() {
-				item := t.merger.Get(idx)
+			if t.cy < t.merger.Length() {
+				item := t.merger.Get(t.cy)
 				if _, found := t.selected[item.text]; !found {
 					var strptr *string
 					if item.origText != nil {
@@ -647,7 +640,7 @@ func (t *Terminal) Loop() {
 			} else if me.Double {
 				// Double-click
 				if my >= 2 {
-					if t.vset(my-2) && t.listIndex(t.cy) < t.merger.Length() {
+					if t.vset(my-2) && t.cy < t.merger.Length() {
 						req(reqClose)
 					}
 				}

src/util/eventbox.go

@@ -53,8 +53,8 @@ func (events *Events) Clear() {
 	}
 }
 
-// Peak peaks at the event box if the given event is set
-func (b *EventBox) Peak(event EventType) bool {
+// Peek peeks at the event box if the given event is set
+func (b *EventBox) Peek(event EventType) bool {
 	b.cond.L.Lock()
 	defer b.cond.L.Unlock()
 	_, ok := b.events[event]
@@ -78,3 +78,18 @@ func (b *EventBox) Unwatch(events ...EventType) {
 		b.ignore[event] = true
 	}
 }
+
+func (b *EventBox) WaitFor(event EventType) {
+	looping := true
+	for looping {
+		b.Wait(func(events *Events) {
+			for evt := range *events {
+				switch evt {
+				case event:
+					looping = false
+					return
+				}
+			}
+		})
+	}
+}

test/fzf.vader

@@ -7,16 +7,16 @@ Execute (fzf#run with dir option):
   AssertEqual ['fzf.vader'], result
 
   let result = sort(fzf#run({ 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_fzf.rb'], result
+  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], result
 
 Execute (fzf#run with Funcref command):
   let g:ret = []
-  function! g:proc(e)
+  function! g:FzfTest(e)
     call add(g:ret, a:e)
   endfunction
-  let result = sort(fzf#run({ 'sink': function('g:proc'), 'options': '--filter e', 'dir': g:dir }))
-  AssertEqual ['fzf.vader', 'test_fzf.rb'], result
-  AssertEqual ['fzf.vader', 'test_fzf.rb'], sort(g:ret)
+  let result = sort(fzf#run({ 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
+  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], result
+  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], sort(g:ret)
 
 Execute (fzf#run with string source):
   let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))

test/test_go.rb

@@ -2,11 +2,20 @@
 # encoding: utf-8
 
 require 'minitest/autorun'
+require 'fileutils'
 
 class NilClass
   def include? str
     false
   end
+
+  def start_with? str
+    false
+  end
+
+  def end_with? str
+    false
+  end
 end
 
 module Temp
@@ -15,7 +24,7 @@ module Temp
     waited = 0
     while waited < 5
       begin
-        data = File.read(name)
+        data = `cat #{name}`
         return data unless data.empty?
       rescue
         sleep 0.1
@@ -30,6 +39,20 @@ module Temp
   end
 end
 
+class Shell
+  class << self
+    def bash
+      'PS1= PROMPT_COMMAND= bash --rcfile ~/.fzf.bash'
+    end
+
+    def zsh
+      FileUtils.mkdir_p '/tmp/fzf-zsh'
+      FileUtils.cp File.expand_path('~/.fzf.zsh'), '/tmp/fzf-zsh/.zshrc'
+      'PS1= PROMPT_COMMAND= HISTSIZE=100 ZDOTDIR=/tmp/fzf-zsh zsh'
+    end
+  end
+end
+
 class Tmux
   include Temp
 
@@ -37,18 +60,33 @@ class Tmux
 
   attr_reader :win
 
-  def initialize shell = 'bash'
-    @win = go("new-window -d -P -F '#I' 'PS1=FIN PROMPT_COMMAND= bash --rcfile ~/.fzf.#{shell}'").first
+  def initialize shell = :bash
+    @win =
+      case shell
+      when :bash
+        go("new-window -d -P -F '#I' '#{Shell.bash}'").first
+      when :zsh
+        go("new-window -d -P -F '#I' '#{Shell.zsh}'").first
+      when :fish
+        go("new-window -d -P -F '#I' 'fish'").first
+      else
+        raise "Unknown shell: #{shell}"
+      end
     @lines = `tput lines`.chomp.to_i
+
+    if shell == :fish
+      send_keys('function fish_prompt; end; clear', :Enter)
+      self.until { |lines| lines.empty? }
+    end
   end
 
   def closed?
     !go("list-window -F '#I'").include?(win)
   end
 
-  def close timeout = 1
+  def close
     send_keys 'C-c', 'C-u', 'exit', :Enter
-    wait(timeout) { closed? }
+    wait { closed? }
   end
 
   def kill
@@ -56,35 +94,68 @@ class Tmux
   end
 
   def send_keys *args
+    target =
+      if args.last.is_a?(Hash)
+        hash = args.pop
+        go("select-window -t #{win}")
+        "#{win}.#{hash[:pane]}"
+      else
+        win
+      end
     args = args.map { |a| %{"#{a}"} }.join ' '
-    go("send-keys -t #{win} #{args}")
+    go("send-keys -t #{target} #{args}")
   end
 
-  def capture
-    go("capture-pane -t #{win} \\; save-buffer #{TEMPNAME}")
-    raise "Window not found" if $?.exitstatus != 0
+  def capture opts = {}
+    timeout, pane = defaults(opts).values_at(:timeout, :pane)
+    waited = 0
+    loop do
+      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME}")
+      break if $?.exitstatus == 0
+
+      if waited > timeout
+        raise "Window not found"
+      end
+      waited += 0.1
+      sleep 0.1
+    end
     readonce.split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
   end
 
-  def until timeout = 1
-    wait(timeout) { yield capture }
+  def until opts = {}
+    lines = nil
+    wait(opts) do
+      yield lines = capture(opts)
+    end
+    lines
   end
 
+  def prepare
+    self.send_keys 'echo hello', :Enter
+    self.until { |lines| lines[-1].start_with?('hello') }
+    self.send_keys 'clear', :Enter
+    self.until { |lines| lines.empty? }
+  end
 private
-  def wait timeout = 1
+  def defaults opts
+    { timeout: 5, pane: 0 }.merge(opts)
+  end
+
+  def wait opts = {}
+    timeout, pane = defaults(opts).values_at(:timeout, :pane)
     waited = 0
     until yield
-      waited += 0.1
-      sleep 0.1
       if waited > timeout
         hl = '=' * 10
         puts hl
-        capture.each_with_index do |line, idx|
+        capture(opts).each_with_index do |line, idx|
           puts [idx.to_s.rjust(2), line].join(': ')
         end
         puts hl
         raise "timeout"
       end
+      waited += 0.1
+      sleep 0.1
     end
   end
 
@@ -93,9 +164,10 @@ private
   end
 end
 
-class TestGoFZF < MiniTest::Unit::TestCase
+class TestBase < Minitest::Test
   include Temp
 
+  FIN = 'FIN'
   TEMPNAME = '/tmp/output'
 
   attr_reader :tmux
@@ -103,6 +175,31 @@ class TestGoFZF < MiniTest::Unit::TestCase
   def setup
     ENV.delete 'FZF_DEFAULT_OPTS'
     ENV.delete 'FZF_DEFAULT_COMMAND'
+  end
+
+  def fzf(*opts)
+    fzf!(*opts) + " > #{TEMPNAME} && echo #{FIN}"
+  end
+
+  def fzf!(*opts)
+    opts = opts.map { |o|
+      case o
+      when Symbol
+        o = o.to_s
+        o.length > 1 ? "--#{o.gsub('_', '-')}" : "-#{o}"
+      when String, Numeric
+        o.to_s
+      else
+        nil
+      end
+    }.compact
+    "fzf #{opts.join ' '}"
+  end
+end
+
+class TestGoFZF < TestBase
+  def setup
+    super
     @tmux = Tmux.new
   end
 
@@ -111,8 +208,9 @@ class TestGoFZF < MiniTest::Unit::TestCase
   end
 
   def test_vanilla
-    tmux.send_keys "seq 1 100000 | fzf > #{TEMPNAME}", :Enter
-    tmux.until(10) { |lines| lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
+    tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
+    tmux.until(timeout: 10) { |lines|
+      lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
     lines = tmux.capture
     assert_equal '  2',             lines[-4]
     assert_equal '> 1',             lines[-3]
@@ -134,7 +232,7 @@ class TestGoFZF < MiniTest::Unit::TestCase
   end
 
   def test_fzf_default_command
-    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' fzf > #{TEMPNAME}", :Enter
+    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' #{fzf}", :Enter
     tmux.until { |lines| lines.last =~ /^>/ }
 
     tmux.send_keys :Enter
@@ -209,7 +307,7 @@ class TestGoFZF < MiniTest::Unit::TestCase
   end
 
   def test_multi_order
-    tmux.send_keys "seq 1 10 | fzf --multi > #{TEMPNAME}", :Enter
+    tmux.send_keys "seq 1 10 | #{fzf :multi}", :Enter
     tmux.until { |lines| lines.last =~ /^>/ }
 
     tmux.send_keys :Tab, :Up, :Up, :Tab, :Tab, :Tab, # 3, 2
@@ -217,7 +315,7 @@ class TestGoFZF < MiniTest::Unit::TestCase
                    :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
     tmux.until { |lines| lines[-2].include? '(6)' }
     tmux.send_keys "C-M"
-    tmux.until { |lines| lines[-1].include?('FIN') }
+    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal %w[3 2 5 6 8 7], readonce.split($/)
     tmux.close
   end
@@ -226,7 +324,7 @@ class TestGoFZF < MiniTest::Unit::TestCase
     [true, false].each do |multi|
       tmux.send_keys "(echo '  1st 2nd 3rd/';
                        echo '  first second third/') |
-                      fzf #{"--multi" if multi} -x --nth 2 --with-nth 2,-1,1 > #{TEMPNAME}",
+                       #{fzf multi && :multi, :x, :nth, 2, :with_nth, '2,-1,1'}",
                       :Enter
       tmux.until { |lines| lines[-2].include?('2/2') }
 
@@ -238,13 +336,13 @@ class TestGoFZF < MiniTest::Unit::TestCase
       # However, the output must not be transformed
       if multi
         tmux.send_keys :BTab, :BTab, :Enter
-        tmux.until { |lines| lines[-1].include?('FIN') }
+        tmux.until { |lines| lines[-1].include?(FIN) }
         assert_equal ['  1st 2nd 3rd/', '  first second third/'], readonce.split($/)
       else
         tmux.send_keys '^', '3'
         tmux.until { |lines| lines[-2].include?('1/2') }
         tmux.send_keys :Enter
-        tmux.until { |lines| lines[-1].include?('FIN') }
+        tmux.until { |lines| lines[-1].include?(FIN) }
         assert_equal ['  1st 2nd 3rd/'], readonce.split($/)
       end
     end
@@ -252,34 +350,228 @@ class TestGoFZF < MiniTest::Unit::TestCase
 
   def test_scroll
     [true, false].each do |rev|
-      tmux.send_keys "seq 1 100 | fzf #{'--reverse' if rev} > #{TEMPNAME}", :Enter
+      tmux.send_keys "seq 1 100 | #{fzf rev && :reverse}", :Enter
       tmux.until { |lines| lines.include? '  100/100' }
       tmux.send_keys *110.times.map { rev ? :Down : :Up }
       tmux.until { |lines| lines.include? '> 100' }
       tmux.send_keys :Enter
-      tmux.until { |lines| lines[-1].include?('FIN') }
+      tmux.until { |lines| lines[-1].include?(FIN) }
       assert_equal '100', readonce.chomp
     end
   end
 
   def test_select_1
-    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 5555 -1 > #{TEMPNAME}", :Enter
-    tmux.until { |lines| lines[-1].include?('FIN') }
+    tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 5555, :'1'}", :Enter
+    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['5555', '55'], readonce.split($/)
   end
 
   def test_exit_0
-    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 555555 -0 > #{TEMPNAME}", :Enter
-    tmux.until { |lines| lines[-1].include?('FIN') }
+    tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 555555, :'0'}", :Enter
+    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['555555'], readonce.split($/)
   end
 
+  def test_select_1_exit_0_fail
+    [:'0', :'1', [:'1', :'0']].each do |opt|
+      tmux.send_keys "seq 1 100 | #{fzf :print_query, :multi, :q, 5, *opt}", :Enter
+      tmux.until { |lines| lines.last =~ /^> 5/ }
+      tmux.send_keys :BTab, :BTab, :BTab, :Enter
+      tmux.until { |lines| lines[-1].include?(FIN) }
+      assert_equal ['5', '5', '15', '25'], readonce.split($/)
+    end
+  end
+
   def test_query_unicode
-    tmux.send_keys "(echo abc; echo 가나다) | fzf --query 가다 > #{TEMPNAME}", :Enter
+    tmux.send_keys "(echo abc; echo 가나다) | #{fzf :query, '가다'}", :Enter
     tmux.until { |lines| lines.last.start_with? '>' }
     tmux.send_keys :Enter
-    tmux.until { |lines| lines[-1].include?('FIN') }
+    tmux.until { |lines| lines[-1].include?(FIN) }
     assert_equal ['가나다'], readonce.split($/)
   end
+
+  def test_sync
+    tmux.send_keys "seq 1 100 | #{fzf! :multi} | awk '{print \\$1 \\$1}' | #{fzf :sync}", :Enter
+    tmux.until { |lines| lines[-1] == '>' }
+    tmux.send_keys 9
+    tmux.until { |lines| lines[-2] == '  19/100' }
+    tmux.send_keys :BTab, :BTab, :BTab, :Enter
+    tmux.until { |lines| lines[-1] == '>' }
+    tmux.send_keys 'C-K', :Enter
+    assert_equal ['1919'], readonce.split($/)
+  end
+
+  def test_tac
+    tmux.send_keys "seq 1 1000 | #{fzf :tac, :multi}", :Enter
+    tmux.until { |lines| lines[-2].include? '1000/1000' }
+    tmux.send_keys :BTab, :BTab, :BTab, :Enter
+    assert_equal %w[1000 999 998], readonce.split($/)
+  end
+
+  def test_tac_sort
+    tmux.send_keys "seq 1 1000 | #{fzf :tac, :multi}", :Enter
+    tmux.until { |lines| lines[-2].include? '1000/1000' }
+    tmux.send_keys '99'
+    tmux.send_keys :BTab, :BTab, :BTab, :Enter
+    assert_equal %w[99 999 998], readonce.split($/)
+  end
+
+  def test_tac_nosort
+    tmux.send_keys "seq 1 1000 | #{fzf :tac, :no_sort, :multi}", :Enter
+    tmux.until { |lines| lines[-2].include? '1000/1000' }
+    tmux.send_keys '00'
+    tmux.send_keys :BTab, :BTab, :BTab, :Enter
+    assert_equal %w[1000 900 800], readonce.split($/)
+  end
+end
+
+module TestShell
+  def setup
+    super
+  end
+
+  def teardown
+    @tmux.kill
+  end
+
+  def test_ctrl_t
+    tmux.prepare
+    tmux.send_keys 'C-t', pane: 0
+    lines = tmux.until(pane: 1) { |lines| lines[-1].start_with? '>' }
+    expected = lines.values_at(-3, -4).map { |line| line[2..-1] }.join(' ')
+    tmux.send_keys :BTab, :BTab, :Enter, pane: 1
+    tmux.until(pane: 0) { |lines| lines[-1].include? expected }
+    tmux.send_keys 'C-c'
+
+    # FZF_TMUX=0
+    new_shell
+    tmux.send_keys 'C-t', pane: 0
+    lines = tmux.until(pane: 0) { |lines| lines[-1].start_with? '>' }
+    expected = lines.values_at(-3, -4).map { |line| line[2..-1] }.join(' ')
+    tmux.send_keys :BTab, :BTab, :Enter, pane: 0
+    tmux.until(pane: 0) { |lines| lines[-1].include? expected }
+    tmux.send_keys 'C-c', 'C-d'
+  end
+
+  def test_alt_c
+    tmux.prepare
+    tmux.send_keys :Escape, :c
+    lines = tmux.until { |lines| lines[-1].start_with? '>' }
+    expected = lines[-3][2..-1]
+    p expected
+    tmux.send_keys :Enter
+    tmux.prepare
+    tmux.send_keys :pwd, :Enter
+    tmux.until { |lines| p lines; lines[-1].end_with?(expected) }
+  end
+
+  def test_ctrl_r
+    tmux.prepare
+    tmux.send_keys 'echo 1st', :Enter; tmux.prepare
+    tmux.send_keys 'echo 2nd', :Enter; tmux.prepare
+    tmux.send_keys 'echo 3d',  :Enter; tmux.prepare
+    tmux.send_keys 'echo 3rd', :Enter; tmux.prepare
+    tmux.send_keys 'echo 4th', :Enter; tmux.prepare
+    tmux.send_keys 'C-r'
+    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.send_keys '3d'
+    tmux.until { |lines| lines[-3].end_with? 'echo 3rd' } # --no-sort
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == 'echo 3rd' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == '3rd' }
+  end
+end
+
+class TestBash < TestBase
+  include TestShell
+
+  def new_shell
+    tmux.send_keys "FZF_TMUX=0 #{Shell.bash}", :Enter
+    tmux.prepare
+  end
+
+  def setup
+    super
+    @tmux = Tmux.new :bash
+  end
+
+  def test_file_completion
+    tmux.send_keys 'mkdir -p /tmp/fzf-test; touch /tmp/fzf-test/{1..100}', :Enter
+    tmux.prepare
+    tmux.send_keys 'cat /tmp/fzf-test/10**', :Tab
+    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.send_keys :BTab, :BTab, :Enter
+    tmux.until { |lines|
+      lines[-1].include?('/tmp/fzf-test/10') &&
+      lines[-1].include?('/tmp/fzf-test/100')
+    }
+  end
+
+  def test_dir_completion
+    tmux.send_keys 'mkdir -p /tmp/fzf-test/d{1..100}; touch /tmp/fzf-test/d55/xxx', :Enter
+    tmux.prepare
+    tmux.send_keys 'cd /tmp/fzf-test/**', :Tab
+    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.send_keys :BTab, :BTab # BTab does not work here
+    tmux.send_keys 55
+    tmux.until { |lines| lines[-2].start_with? '  1/' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' }
+    tmux.send_keys :xx
+    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
+
+    # Should not match regular files
+    tmux.send_keys :Tab
+    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/xx' }
+
+    # Fail back to plusdirs
+    tmux.send_keys :BSpace, :BSpace, :BSpace
+    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55' }
+    tmux.send_keys :Tab
+    tmux.until { |lines| lines[-1] == 'cd /tmp/fzf-test/d55/' }
+  end
+
+  def test_process_completion
+    tmux.send_keys 'sleep 12345 &', :Enter
+    lines = tmux.until { |lines| lines[-1].start_with? '[1]' }
+    pid = lines[-1].split.last
+    tmux.prepare
+    tmux.send_keys 'kill ', :Tab
+    tmux.until { |lines| lines[-1].start_with? '>' }
+    tmux.send_keys 'sleep12345'
+    tmux.until { |lines| lines[-3].include? 'sleep 12345' }
+    tmux.send_keys :Enter
+    tmux.until { |lines| lines[-1] == "kill #{pid}" }
+  end
+end
+
+class TestZsh < TestBase
+  include TestShell
+
+  def new_shell
+    tmux.send_keys "FZF_TMUX=0 #{Shell.zsh}", :Enter
+    tmux.prepare
+  end
+
+  def setup
+    super
+    @tmux = Tmux.new :zsh
+  end
+end
+
+class TestFish < TestBase
+  include TestShell
+
+  def new_shell
+    tmux.send_keys 'env FZF_TMUX=0 fish', :Enter
+    tmux.send_keys 'function fish_prompt; end; clear', :Enter
+    tmux.until { |lines| lines.empty? }
+  end
+
+  def setup
+    super
+    @tmux = Tmux.new :fish
+  end
 end
 

test/test_ruby.rb

@@ -54,7 +54,7 @@ class MockTTY
   end
 end
 
-class TestRubyFZF < MiniTest::Unit::TestCase
+class TestRubyFZF < Minitest::Test
   def setup
     ENV.delete 'FZF_DEFAULT_SORT'
     ENV.delete 'FZF_DEFAULT_OPTS'