[vim] up/down/left/right options to take boolean values

When 1 is given, 50% of the screen width or height will be used as the
default size of the pane.

.gitignore

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

.travis.yml

@@ -0,0 +1,28 @@
+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
+  export GOPATH=~/go
+  export FZF_BASE=~/go/src/github.com/junegunn/fzf
+
+  mkdir -p ~/go/src/github.com/junegunn
+  ln -s $(pwd) $FZF_BASE
+
+  curl https://storage.googleapis.com/golang/go1.4.1.linux-amd64.tar.gz | tar -xz
+  mv go $GOROOT
+
+  cd $FZF_BASE/src && make test fzf/fzf-linux_amd64 install &&
+  cd $FZF_BASE/bin && ln -sf fzf-linux_amd64 fzf-$(./fzf --version)-linux_amd64 &&
+  cd $FZF_BASE && yes | ./install &&
+  tmux new "rake test > out && touch ok" && cat out && [ -e ok ]

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
+

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.

README.md

@@ -8,14 +8,24 @@ fzf is a general-purpose fuzzy finder for your shell.
 It was heavily inspired by [ctrlp.vim](https://github.com/kien/ctrlp.vim) and
 the likes.
 
-Requirements
-------------
-
-fzf requires Ruby (>= 1.8.5).
-
 Installation
 ------------
 
+fzf project consists of the followings:
+
+- `fzf` executable
+- `fzf-tmux` script for launching fzf in a tmux pane
+- Shell extensions
+    - Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
+    - Fuzzy auto-completion (bash only)
+
+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.
 
@@ -24,44 +34,46 @@ git clone https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-The script will generate `~/.fzf.bash` and `~/.fzf.zsh` and update your
+#### Using curl
-`.bashrc` and `.zshrc` to load them.
 
-Or you can just download
+In case you don't have git installed:
-[fzf executable](https://raw.github.com/junegunn/fzf/master/fzf) and put it
-somewhere in your search $PATH.
 
-### Install as Vim plugin
+```sh
+mkdir -p ~/.fzf
+curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
+    tar xz --strip-components 1 -C ~/.fzf
+~/.fzf/install
+```
 
-You can use any Vim plugin manager to install fzf for Vim. If you don't use one,
+#### Using Homebrew
-I recommend you try [vim-plug](https://github.com/junegunn/vim-plug).
 
-1. [Install vim-plug](https://github.com/junegunn/vim-plug#usage)
+On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
-2. Edit your .vimrc
 
-        call plug#begin()
+```sh
-        Plug 'junegunn/fzf'
+brew install fzf
-        " ...
-        call plug#end()
 
-3. Run `:PlugInstall`
+# Install shell extensions - this should be done whenever fzf is updated
+$(brew info fzf | grep /install)
+```
+
+#### Install as Vim plugin
+
+Once you have cloned the repository, add the following line to your .vimrc.
+
+```vim
+set rtp+=~/.fzf
+```
+
+Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf
+(recommended):
+
+```vim
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
+```
 
 Usage
 -----
 
-```
-usage: fzf [options]
-
-    -m, --multi      Enable multi-select
-    -x, --extended   Extended-search mode
-    -q, --query=STR  Initial query
-    -s, --sort=MAX   Maximum number of matched items to sort. Default: 1000
-    +s, --no-sort    Do not sort the result. Keep the sequence unchanged.
-    -i               Case-insensitive match (default: smart-case match)
-    +i               Case-sensitive match
-    +c, --no-color   Disable colors
-```
-
 fzf will launch curses-based finder, read the list from STDIN, and write the
 selected item to STDOUT.
 
@@ -77,29 +89,16 @@ 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
+#### Using the finder
-`+s`) option.
 
-```sh
+- `CTRL-J` / `CTRL-K` (or `CTRL-N` / `CTRL-P)` to move cursor up and down
-history | fzf +s
+- `Enter` key to select the item, `CTRL-C` / `CTRL-G` / `ESC` to exit
-```
+- On multi-select mode (`-m`), `TAB` and `Shift-TAB` to mark multiple items
+- Emacs style key bindings
+- Mouse: scroll, click, double-click; shift-click and shift-scroll on
+  multi-select mode
 
-### Key binding
+#### Extended-search mode
-
-Use CTRL-J and CTRL-K (or CTRL-N and CTRL-P) to change the selection, press
-enter key to select the item. CTRL-C, CTRL-G, or ESC will terminate the finder.
-
-The following readline key bindings should also work as expected.
-
-- CTRL-A / CTRL-E
-- CTRL-B / CTRL-F
-- CTRL-W / CTRL-U
-- ALT-B / ALT-F
-
-If you enable multi-select mode with `-m` option, you can select multiple items
-with TAB or Shift-TAB key.
-
-### Extended-search mode
 
 With `-x` or `--extended` option, fzf will start in "extended-search mode".
 
@@ -115,153 +114,59 @@ such as: `^music .mp3$ sbtrkt !rmx`
 | `'wild`  | Items that include `wild`        | exact-match (quoted) |
 | `!'fire` | Items that do not include `fire` | inverse-exact-match  |
 
-Usage as Vim plugin
+If you don't need fuzzy matching and do not wish to "quote" every word, start
--------------------
+fzf with `-e` or `--extended-exact` option.
 
-If you install fzf as a Vim plugin, `:FZF` command will be added.
+Examples
+--------
 
-```vim
+Many useful examples can be found on [the wiki
-" Look for files under current directory
+page](https://github.com/junegunn/fzf/wiki/examples). Feel free to add your
-:FZF
+own as well.
-
-" Look for files under your home directory
-:FZF ~
-
-" With options
-:FZF --no-sort -m /tmp
-```
-
-You can override the source command which produces input to fzf.
-
-```vim
-let g:fzf_source = 'find . -type f'
-```
-
-And you can predefine default options to fzf command.
-
-```vim
-let g:fzf_options = '--no-color --extended'
-```
-
-For more advanced uses, you can call `fzf#run` function as follows.
-
-```vim
-:call fzf#run('tabedit', '-m +c')
-```
-
-Most of the time, you will prefer native Vim plugins with better integration
-with Vim. The only reason one might consider using fzf in Vim is its speed. For
-a very large list of files, fzf is significantly faster and it does not block.
-
-Useful examples
----------------
-
-```sh
-# vimf - Open selected file in Vim
-vimf() {
-  FILE=$(fzf) && vim "$FILE"
-}
-
-# fd - cd to selected directory
-fd() {
-  DIR=$(find ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf) && cd "$DIR"
-}
-
-# fda - including hidden directories
-fda() {
-  DIR=$(find ${1:-.} -type d 2> /dev/null | fzf) && cd "$DIR"
-}
-
-# fh - repeat history
-fh() {
-  eval $(history | fzf +s | sed 's/ *[0-9]* *//')
-}
-
-# fkill - kill process
-fkill() {
-  ps -ef | sed 1d | fzf -m | awk '{print $2}' | xargs kill -${1:-9}
-}
-```
 
 Key bindings for command line
 -----------------------------
 
-The install script will add the following key bindings to your configuration
+The install script will setup the following key bindings for bash, zsh, and
-files.
+fish.
-
-### bash
-
-- `CTRL-T` - Paste the selected file path(s) into the command line
-- `CTRL-R` - Paste the selected command from history into the command line
-
-```sh
-# Required to refresh the prompt after fzf
-bind '"\er": redraw-current-line'
-
-# CTRL-T - Paste the selected file path into the command line
-fsel() {
-  find * -path '*/\.*' -prune \
-    -o -type f -print \
-    -o -type l -print 2> /dev/null | fzf -m | while read item; do
-    printf '%q ' "$item"
-  done
-  echo
-}
-bind '"\C-t": " \C-u \C-a\C-k$(fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er"'
-
-# CTRL-R - Paste the selected command from history into the command line
-bind '"\C-r": " \C-e\C-u$(history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
-```
-
-### zsh
 
 - `CTRL-T` - Paste the selected file path(s) into the command line
 - `CTRL-R` - Paste the selected command from history into the command line
 - `ALT-C` - cd into the selected directory
 
+If you're on a tmux session, `CTRL-T` will launch fzf in a new split-window. You
+may disable this tmux integration by setting `FZF_TMUX` to 0, or change the
+height of the window with `FZF_TMUX_HEIGHT` (e.g. `20`, `50%`).
+
+If you use vi mode on bash, you need to add `set -o vi` *before* `source
+~/.fzf.bash` in your .bashrc, so that it correctly sets up key bindings for vi
+mode.
+
+If you want to customize the key bindings, consider editing the
+installer-generated source code: `~/.fzf.bash`, `~/.fzf.zsh`, and
+`~/.config/fish/functions/fzf_key_bindings.fish`.
+
+`fzf-tmux` script
+-----------------
+
+[fzf-tmux](bin/fzf-tmux) is a bash script that opens fzf in a tmux pane.
+
 ```sh
-# CTRL-T - Paste the selected file path(s) into the command line
+# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
-fzf-file-widget() {
+#        (-[udlr]: up/down/left/right)
-  local FILES
-  local IFS="
-"
-  FILES=($(
-    find * -path '*/\.*' -prune \
-    -o -type f -print \
-    -o -type l -print 2> /dev/null | fzf -m))
-  unset IFS
-  FILES=$FILES:q
-  LBUFFER="${LBUFFER%% #} $FILES"
-  zle redisplay
-}
-zle     -N   fzf-file-widget
-bindkey '^T' fzf-file-widget
 
-# ALT-C - cd into the selected directory
+# select git branches in horizontal split below (15 lines)
-fzf-cd-widget() {
+git branch | fzf-tmux -d 15
-  cd "${$(find * -path '*/\.*' -prune \
-          -o -type d -print 2> /dev/null | fzf):-.}"
-  zle reset-prompt
-}
-zle     -N    fzf-cd-widget
-bindkey '\ec' fzf-cd-widget
 
-# CTRL-R - Paste the selected command from history into the command line
+# select multiple words in vertical split on the left (20% of screen width)
-fzf-history-widget() {
+cat /usr/share/dict/words | fzf-tmux -l 20% --multi --reverse
-  LBUFFER=$(history | fzf +s | sed "s/ *[0-9]* *//")
-  zle redisplay
-}
-zle     -N   fzf-history-widget
-bindkey '^R' fzf-history-widget
 ```
 
-Auto-completion
+It will still work even when you're not on tmux, silently ignoring `-[udlr]`
----------------
+options, so you can invariably use `fzf-tmux` in your scripts.
 
-Disclaimer: *Auto-completion feature is currently experimental, it can change
+Fuzzy completion for bash
-over time*
+-------------------------
-
-### bash
 
 #### Files and directories
 
@@ -305,11 +210,19 @@ kill -9 <TAB>
 #### Host names
 
 For ssh and telnet commands, fuzzy completion for host names is provided. The
-names are extracted from /etc/hosts file.
+names are extracted from /etc/hosts and ~/.ssh/config.
 
 ```sh
-ssh <TAB>
+ssh **<TAB>
-telnet <TAB>
+telnet **<TAB>
+```
+
+#### Environment variables / Aliases
+
+```sh
+unset **<TAB>
+export **<TAB>
+unalias **<TAB>
 ```
 
 #### Settings
@@ -322,65 +235,255 @@ export FZF_COMPLETION_TRIGGER='~~'
 export FZF_COMPLETION_OPTS='+c -x'
 ```
 
-### zsh
+Usage as Vim plugin
+-------------------
 
-TODO :smiley:
+(Note: To use fzf in GVim, an external terminal emulator is required.)
 
-(Pull requests are appreciated.)
+#### `:FZF[!]`
+
+If you have set up fzf for Vim, `:FZF` command will be added.
+
+```vim
+" Look for files under current directory
+:FZF
+
+" Look for files under your home directory
+:FZF ~
+
+" With options
+:FZF --no-sort -m /tmp
+```
+
+Note that the environment variables `FZF_DEFAULT_COMMAND` and `FZF_DEFAULT_OPTS`
+also apply here.
+
+If you're on a tmux session, `:FZF` will launch fzf in a new split-window whose
+height can be adjusted with `g:fzf_tmux_height` (default: '40%'). However, the
+bang version (`:FZF!`) will always start in fullscreen.
+
+In GVim, you need an external terminal emulator to start fzf with. `xterm`
+command is used by default, but you can customize it with `g:fzf_launcher`.
+
+```vim
+" This is the default. %s is replaced with fzf command
+let g:fzf_launcher = 'xterm -e bash -ic %s'
+
+" Use urxvt instead
+let g:fzf_launcher = 'urxvt -geometry 120x30 -e sh -c %s'
+```
+
+If you're running MacVim on OSX, I recommend you to use iTerm2 as the launcher.
+Refer to the [this wiki
+page](https://github.com/junegunn/fzf/wiki/fzf-with-MacVim-and-iTerm2) to see
+how to set up.
+
+#### `fzf#run([options])`
+
+For more advanced uses, you can call `fzf#run()` function which returns the list
+of the selected items.
+
+`fzf#run()` may take an options-dictionary:
+
+| Option name                | Type          | Description                                                      |
+| -------------------------- | ------------- | ---------------------------------------------------------------- |
+| `source`                   | string        | External command to generate input to fzf (e.g. `find .`)        |
+| `source`                   | list          | Vim list as input to fzf                                         |
+| `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)       |
+| `sink`                     | funcref       | Reference to function to process each selected item              |
+| `options`                  | string        | Options to fzf                                                   |
+| `dir`                      | string        | Working directory                                                |
+| `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
+| `launcher`                 | string        | External terminal emulator to start fzf with (Only used in GVim) |
+
+##### Examples
+
+If `sink` option is not given, `fzf#run` will simply return the list.
+
+```vim
+let items = fzf#run({ 'options': '-m +c', 'dir': '~', 'source': 'ls' })
+```
+
+But if `sink` is given as a string, the command will be executed for each
+selected item.
+
+```vim
+" Each selected item will be opened in a new tab
+let items = fzf#run({ 'sink': 'tabe', 'options': '-m +c', 'dir': '~', 'source': 'ls' })
+```
+
+We can also use a Vim list as the source as follows:
+
+```vim
+" Choose a color scheme with fzf
+nnoremap <silent> <Leader>C :call fzf#run({
+\   'source':
+\     map(split(globpath(&rtp, "colors/*.vim"), "\n"),
+\         "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"),
+\   'sink':     'colo',
+\   'options':  '+m',
+\   'left':     20,
+\   'launcher': 'xterm -geometry 20x30 -e bash -ic %s'
+\ })<CR>
+```
+
+`sink` option can be a function reference. The following example creates a
+handy mapping that selects an open buffer.
+
+```vim
+" List of buffers
+function! BufList()
+  redir => ls
+  silent ls
+  redir END
+  return split(ls, '\n')
+endfunction
+
+function! BufOpen(e)
+  execute 'buffer '. matchstr(a:e, '^[ 0-9]*')
+endfunction
+
+nnoremap <silent> <Leader><Enter> :call fzf#run({
+\   'source':  reverse(BufList()),
+\   'sink':    function('BufOpen'),
+\   'options': '+m',
+\   'down':    '40%'
+\ })<CR>
+```
+
+More examples can be found on [the wiki
+page](https://github.com/junegunn/fzf/wiki/Examples-(vim)).
+
+#### Articles
+
+- [fzf+vim+tmux](http://junegunn.kr/2014/04/fzf+vim+tmux)
 
 Tips
 ----
 
-### Faster startup with `--disable-gems` options
+#### Rendering issues
 
-If you're running Ruby 1.9 or above, you can improve the startup time with
+If you have any rendering issues, check the followings:
-`--disable-gems` option to Ruby.
 
-- `time ruby ~/bin/fzf -h`
+1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
-    - 0.077 sec
+  contains `256` (e.g. `xterm-256color`)
-- `time ruby --disable-gems ~/bin/fzf -h`
+2. If you're on screen or tmux, `$TERM` should be either `screen` or
-    - 0.025 sec
+  `screen-256color`
+3. Some terminal emulators (e.g. mintty) have problem displaying default
+  background color and make some text unable to read. In that case, try `--black`
+  option. And if it solves your problem, I recommend including it in
+  `FZF_DEFAULT_OPTS` for further convenience.
+4. If you still have problem, try `--no-256` option or even `--no-color`.
 
-You can define fzf function with the option as follows:
+#### Respecting `.gitignore`, `.hgignore`, and `svn:ignore`
+
+[ag](https://github.com/ggreer/the_silver_searcher) or
+[pt](https://github.com/monochromegane/the_platinum_searcher) will do the
+filtering:
 
 ```sh
-fzf() {
+# Feed the output of ag into fzf
-  ruby --disable-gems ~/bin/fzf "$@"
+ag -l -g "" | fzf
-}
+
-export -f fzf
+# Setting ag as the default source for fzf
+export FZF_DEFAULT_COMMAND='ag -l -g ""'
+
+# Now fzf (w/o pipe) will use ag instead of find
+fzf
 ```
 
-However, this is automatically set up in your .bashrc and .zshrc if you use the
+#### `git ls-tree` for fast traversal
-bundled [install](https://github.com/junegunn/fzf/blob/master/install) script.
 
-### Incorrect display on Ruby 1.8
+If you're running fzf in a large git repository, `git ls-tree` can boost up the
-
+speed of the traversal.
-It is reported that the output of fzf can become unreadable on some terminals
-when it's running on Ruby 1.8. If you experience the problem, upgrade your Ruby
-to 1.9 or above. Ruby 1.9 or above is also required for displaying Unicode
-characters.
-
-### Ranking algorithm
-
-fzf sorts the result first by the length of the matched substring, then by the
-length of the whole string. However it only does so when the number of matches
-is less than the limit which is by default 1000, in order to avoid the cost of
-sorting a large list and limit the response time of the query.
-
-This limit can be adjusted with `-s` option, or with the environment variable
-`FZF_DEFAULT_SORT`.
 
 ```sh
-export FZF_DEFAULT_SORT=10000
+# Copy the original fzf function to __fzf
+declare -f __fzf > /dev/null ||
+  eval "$(echo "__fzf() {"; declare -f fzf | \grep -v '^{' | tail -n +2)"
+
+# Use git ls-tree when possible
+fzf() {
+  if [ -n "$(git rev-parse HEAD 2> /dev/null)" ]; then
+    FZF_DEFAULT_COMMAND="git ls-tree -r --name-only HEAD" __fzf "$@"
+  else
+    __fzf "$@"
+  fi
+}
+```
+
+#### Using fzf with tmux panes
+
+The supplied [fzf-tmux](bin/fzf-tmux) script should suffice in most of the
+cases, but if you want to be able to update command line like the default
+`CTRL-T` key binding, you'll have to use `send-keys` command of tmux. The
+following example will show you how it can be done.
+
+```sh
+# This is a helper function that splits the current pane to start the given
+# command ($1) and sends its output back to the original pane with any number of
+# optional keys (shift; $*).
+fzf_tmux_helper() {
+  [ -n "$TMUX_PANE" ] || return
+  local cmd=$1
+  shift
+  tmux split-window -p 40 \
+    "bash -c \"\$(tmux send-keys -t $TMUX_PANE \"\$(source ~/.fzf.bash; $cmd)\" $*)\""
+}
+
+# This is the function we are going to run in the split pane.
+# - "find" to list the directories
+# - "sed" will escape spaces in the paths.
+# - "paste" will join the selected paths into a single line
+fzf_tmux_dir() {
+  fzf_tmux_helper \
+    'find * -path "*/\.*" -prune -o -type d -print 2> /dev/null |
+     fzf --multi |
+     sed "s/ /\\\\ /g" |
+     paste -sd" " -' Space
+}
+
+# Bind CTRL-X-CTRL-D to fzf_tmux_dir
+bind '"\C-x\C-d": "$(fzf_tmux_dir)\e\C-e"'
+```
+
+#### Fish shell
+
+It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
+that it doesn't allow reading from STDIN in command substitution, which means
+simple `vim (fzf)` won't work as expected. The workaround is to store the result
+of fzf to a temporary file.
+
+```sh
+function vimf
+  if fzf > $TMPDIR/fzf.result
+    vim (cat $TMPDIR/fzf.result)
+  end
+end
+
+function fe
+  set tmp $TMPDIR/fzf.result
+  fzf --query="$argv[1]" --select-1 --exit-0 > $tmp
+  if [ (cat $tmp | wc -l) -gt 0 ]
+    vim (cat $tmp)
+  end
+end
+```
+
+#### Handling UTF-8 NFD paths on OSX
+
+Use iconv to convert NFD paths to NFC:
+
+```sh
+find . | iconv -f utf-8-mac -t utf8//ignore | fzf
 ```
 
 License
 -------
 
-MIT
+[MIT](LICENSE)
 
 Author
 ------
 
 Junegunn Choi
-

Rakefile

@@ -2,7 +2,11 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |test|
-  test.pattern = 'test/**/test_*.rb'
+  test.pattern = 'test/test_go.rb'
-  test.verbose = true
 end
 
+Rake::TestTask.new(:testall) do |test|
+  test.pattern = 'test/test_*.rb'
+end
+
+task :default => :test

bin/fzf-tmux

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# fzf-tmux: starts fzf in a tmux pane
+# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+
+args=()
+opt=""
+skip=""
+swap=""
+close=""
+term=""
+while [ $# -gt 0 ]; do
+  arg="$1"
+  case "$arg" in
+    -)
+      term=1
+      ;;
+    -w*|-h*|-d*|-u*|-r*|-l*)
+      if [ -n "$skip" ]; then
+        args+=("$1")
+        shift
+        continue
+      fi
+      if [[ "$arg" =~ ^.[lrw] ]]; then
+        opt="-h"
+        if [[ "$arg" =~ ^.l ]]; then
+          opt="$opt -d"
+          swap="; swap-pane -D ; select-pane -L"
+          close="; tmux swap-pane -D"
+        fi
+      else
+        opt=""
+        if [[ "$arg" =~ ^.u ]]; then
+          opt="$opt -d"
+          swap="; swap-pane -D ; select-pane -U"
+          close="; tmux swap-pane -D"
+        fi
+      fi
+      if [ ${#arg} -gt 2 ]; then
+        size="${arg:2}"
+      else
+        shift
+        if [[ "$1" =~ ^[0-9]+%?$ ]]; then
+          size="$1"
+        else
+          [ -n "$1" -a "$1" != "--" ] && args+=("$1")
+          shift
+          continue
+        fi
+      fi
+
+      if [[ "$size" =~ %$ ]]; then
+        size=${size:0:((${#size}-1))}
+        if [ -n "$swap" ]; then
+          opt="$opt -p $(( 100 - size ))"
+        else
+          opt="$opt -p $size"
+        fi
+      else
+        if [ -n "$swap" ]; then
+          if [[ "$arg" =~ ^.l ]]; then
+            [ -n "$COLUMNS" ] && max=$COLUMNS || max=$(tput cols)
+          else
+            [ -n "$LINES" ] && max=$LINES || max=$(tput lines)
+          fi
+          size=$(( max - size ))
+          [ $size -lt 0 ] && size=0
+          opt="$opt -l $size"
+        else
+          opt="$opt -l $size"
+        fi
+      fi
+      ;;
+    --)
+      # "--" can be used to separate fzf-tmux options from fzf options to
+      # avoid conflicts
+      skip=1
+      ;;
+    *)
+      args+=("$1")
+      ;;
+  esac
+  shift
+done
+
+if [ -z "$TMUX_PANE" ]; then
+  fzf "${args[@]}"
+  exit $?
+fi
+
+set -e
+
+# Build arguments to fzf
+[ ${#args[@]} -gt 0 ] && fzf_args=$(printf '\\"%s\\" ' "${args[@]}"; echo '')
+
+# Clean up named pipes on exit
+id=$RANDOM
+fifo1=/tmp/fzf-fifo1-$id
+fifo2=/tmp/fzf-fifo2-$id
+fifo3=/tmp/fzf-fifo3-$id
+cleanup() {
+  rm -f $fifo1 $fifo2 $fifo3
+}
+trap cleanup EXIT SIGINT SIGTERM
+
+fail() {
+  >&2 echo "$1"
+  exit 1
+}
+fzf=$(which fzf 2> /dev/null) || fail "fzf executable not found"
+envs="FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS") FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
+
+mkfifo $fifo2
+mkfifo $fifo3
+if [ -n "$term" -o -t 0 ]; then
+  tmux set-window-option -q synchronize-panes off \;\
+    split-window $opt "$envs"' sh -c "'$fzf' '"$fzf_args"' > '$fifo2'; echo \$? > '$fifo3' '"$close"'"' $swap
+else
+  mkfifo $fifo1
+  tmux set-window-option -q synchronize-panes off \;\
+    split-window $opt "$envs"' sh -c "'$fzf' '"$fzf_args"' < '$fifo1' > '$fifo2'; echo \$? > '$fifo3' '"$close"'"' $swap
+  cat <&0 > $fifo1 &
+fi
+cat $fifo2
+[ "$(cat $fifo3)" = '0' ]
+

ext/mkrf_conf.rb

@@ -0,0 +1,9 @@
+require 'rubygems/dependency_installer'
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
+  Gem::DependencyInstaller.new.install 'curses', '~> 1.0'
+end
+
+File.open(File.expand_path('../Rakefile', __FILE__), 'w') do |f|
+  f.puts 'task :default'
+end

fzf-completion.bash

@@ -8,19 +8,36 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+_fzf_orig_completion_filter() {
+  sed 's/.*-F *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\2=\1;/' |
+  sed 's/[^a-z0-9_= ;]/_/g'
+}
+
 _fzf_opts_completion() {
-  local cur prev opts
+  local cur opts
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
-  prev="${COMP_WORDS[COMP_CWORD-1]}"
+  opts="
-  opts="-m --multi -x --extended -s --sort +s +i +c --no-color"
+    -x --extended
-
+    -e --extended-exact
-  case "${prev}" in
+    -i +i
-  --sort|-s)
+    -n --nth
-    COMPREPLY=( $(compgen -W "$(seq 2000 1000 10000)" -- ${cur}) )
+    -d --delimiter
-    return 0
+    +s --no-sort
-    ;;
+    --tac
-  esac
+    -m --multi
+    --no-mouse
+    +c --no-color
+    +2 --no-256
+    --black
+    --reverse
+    --prompt
+    -q --query
+    -1 --select-1
+    -0 --exit-0
+    -f --filter
+    --print-query
+    --sync"
 
   if [[ ${cur} =~ ^-|\+ ]]; then
     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
@@ -30,13 +47,31 @@ _fzf_opts_completion() {
   return 0
 }
 
-_fzf_generic_completion() {
+_fzf_handle_dynamic_completion() {
-  local cur base dir leftover matches
+  local cmd orig ret
+  cmd="$1"
+  shift
+
+  orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+  if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
+    $orig "$@"
+  elif [ -n "$_fzf_completion_loader" ]; then
+    _completion_loader "$@"
+    ret=$?
+    eval $(complete | \grep "\-F.* $cmd$" | _fzf_orig_completion_filter)
+    source $BASH_SOURCE
+    return $ret
+  fi
+}
+
+_fzf_path_completion() {
+  local cur base dir leftover matches trigger cmd
+  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
-  FZF_COMPLETION_TRIGGER=${FZF_COMPLETION_TRIGGER:-**}
+  trigger=${FZF_COMPLETION_TRIGGER:-**}
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$FZF_COMPLETION_TRIGGER" ]]; then
+  if [[ ${cur} == *"$trigger" ]]; then
-    base=${cur:0:${#cur}-${#FZF_COMPLETION_TRIGGER}}
+    base=${cur:0:${#cur}-${#trigger}}
     eval base=$base
 
     dir="$base"
@@ -46,8 +81,8 @@ _fzf_generic_completion() {
         leftover=${leftover/#\/}
         [ "$dir" = './' ] && dir=''
         tput sc
-        matches=$(find "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+        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
@@ -61,25 +96,54 @@ _fzf_generic_completion() {
       dir=$(dirname "$dir")
       [[ "$dir" =~ /$ ]] || dir="$dir"/
     done
+  else
+    shift
+    shift
+    shift
+    _fzf_handle_dynamic_completion "$cmd" "$@"
+  fi
+}
+
+_fzf_list_completion() {
+  local cur selected trigger cmd src
+  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}}
+
+    tput sc
+    selected=$(eval "$src | fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
+    selected=${selected% }
+    tput rc
+
+    if [ -n "$selected" ]; then
+      COMPREPLY=("$selected")
+      return 0
+    fi
+  else
+    shift
+    _fzf_handle_dynamic_completion "$cmd" "$@"
   fi
 }
 
 _fzf_all_completion() {
-  _fzf_generic_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_generic_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_generic_completion \
+  _fzf_path_completion \
     "-name .git -prune -o -name .svn -prune -o -type d -print" \
-    ""
+    "" "/" "$@"
 }
 
 _fzf_kill_completion() {
@@ -96,44 +160,70 @@ _fzf_kill_completion() {
   fi
 }
 
-_fzf_host_completion() {
+_fzf_telnet_completion() {
-  local cur prev selected
+  _fzf_list_completion '+m' "$@" << "EOF"
-  cur="${COMP_WORDS[COMP_CWORD]}"
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{if (length($2) > 0) {print $2}}' | sort -u
-  prev="${COMP_WORDS[COMP_CWORD-1]}"
+EOF
-  [[ "$cur" =~ ^- || "$prev" =~ ^- ]] && return 1
-
-  tput sc
-  selected=$(grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=("$selected")
-    return 0
-  fi
 }
 
+_fzf_ssh_completion() {
+  _fzf_list_completion '+m' "$@" << "EOF"
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i ^host | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts) | awk '{print $2}' | sort -u
+EOF
+}
+
+_fzf_env_var_completion() {
+  _fzf_list_completion '-m' "$@" << "EOF"
+  declare -xp | sed 's/=.*//' | sed 's/.* //'
+EOF
+}
+
+_fzf_alias_completion() {
+  _fzf_list_completion '-m' "$@" << "EOF"
+  alias | sed 's/=.*//' | sed 's/.* //'
+EOF
+}
+
+# fzf options
 complete -F _fzf_opts_completion fzf
 
-# Directory
+d_cmds="cd pushd rmdir"
-for cmd in "cd pushd rmdir"; do
+f_cmds="
-  complete -F _fzf_dir_completion -o default -o bashdefault $cmd
-done
-
-# File
-for cmd in "
   awk cat diff diff3
   emacs ex file ftp g++ gcc gvim head hg java
   javac ld less more mvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc"; do
+  sed sftp sort source tail tee uniq vi view vim wc"
+a_cmds="
+  basename bunzip2 bzip2 chmod chown curl cp dirname du
+  find git grep gunzip gzip hg jar
+  ln ls mv open rm rsync scp
+  svn tar unzip zip"
+x_cmds="kill ssh telnet unset unalias export"
+
+# Preserve existing completion
+if [ "$_fzf_completion_loaded" != '0.8.6-1' ]; then
+  # Really wish I could use associative array but OSX comes with bash 3.2 :(
+  eval $(complete | \grep '\-F' | \grep -v _fzf_ |
+    \grep -E " ($(echo $d_cmds $f_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
+  export _fzf_completion_loaded=0.8.6-1
+fi
+
+if type _completion_loader > /dev/null 2>&1; then
+  _fzf_completion_loader=1
+fi
+
+# Directory
+for cmd in $d_cmds; do
+  complete -F _fzf_dir_completion -o nospace -o plusdirs $cmd
+done
+
+# File
+for cmd in $f_cmds; do
   complete -F _fzf_file_completion -o default -o bashdefault $cmd
 done
 
 # Anything
-for cmd in "
+for cmd in $a_cmds; do
-  basename bunzip2 bzip2 chmod chown curl cp dirname du
-  find git grep gunzip gzip hg jar
-  ln ls mv open rm rsync scp
-  svn tar unzip zip"; do
   complete -F _fzf_all_completion -o default -o bashdefault $cmd
 done
 
@@ -141,7 +231,12 @@ done
 complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
 
 # Host completion
-for cmd in "ssh telnet"; do
+complete -F _fzf_ssh_completion -o default -o bashdefault ssh
-  complete -F _fzf_host_completion -o default -o bashdefault $cmd
+complete -F _fzf_telnet_completion -o default -o bashdefault telnet
-done
 
+# Environment variables / Aliases
+complete -F _fzf_env_var_completion -o default -o bashdefault unset
+complete -F _fzf_env_var_completion -o default -o bashdefault export
+complete -F _fzf_alias_completion -o default -o bashdefault unalias
+
+unset cmd d_cmds f_cmds a_cmds x_cmds

fzf.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = 'fzf'
-  spec.version       = '0.6.0'
+  spec.version       = '0.8.4'
   spec.authors       = ['Junegunn Choi']
   spec.email         = ['junegunn.c@gmail.com']
   spec.description   = %q{Fuzzy finder for your shell}
@@ -12,4 +12,6 @@ Gem::Specification.new do |spec|
   spec.bindir        = '.'
   spec.files         = %w[fzf.gemspec]
   spec.executables   = 'fzf'
+
+  spec.extensions   += ['ext/mkrf_conf.rb']
 end

install

@@ -1,47 +1,157 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-cd `dirname $BASH_SOURCE`
+version=0.9.4
-fzf_base=`pwd`
 
-# ruby executable
+cd $(dirname $BASH_SOURCE)
-echo -n "Checking Ruby executable ... "
+fzf_base=$(pwd)
-ruby=`which ruby`
-if [ $? -ne 0 ]; then
-  echo "ruby executable not found!"
-  exit 1
-fi
-echo "OK"
 
-# Curses-support
+ask() {
-echo -n "Checking Curses support ... "
+  read -p "$1 ([y]/n) " -n 1 -r
-/usr/bin/env ruby -e "begin; require 'curses'; rescue Exception; exit 1; end"
+  echo
-if [ $? -ne 0 ]; then
+  [[ ! $REPLY =~ ^[Nn]$ ]]
-  echo "Your ruby does not support 'curses'"
+}
-  exit 1
-fi
-echo "OK"
 
-# Ruby version
+check_binary() {
-echo -n "Checking Ruby version ... "
+  echo -n "  - Checking fzf executable ... "
-/usr/bin/env ruby -e 'exit RUBY_VERSION >= "1.9"'
+  local output=$("$fzf_base"/bin/fzf --version 2>&1)
-if [ $? -eq 0 ]; then
+  if [ "$version" = "$output" ]; then
-  echo ">= 1.9"
+    echo "$output"
-  fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
+    binary_error=""
-else
+  else
-  echo "< 1.9"
+    echo "$output != $version"
-  fzf_cmd="$ruby $fzf_base/fzf"
+    rm -f "$fzf_base"/bin/fzf
+    binary_error="Invalid binary"
+    return 1
+  fi
+}
+
+symlink() {
+  echo "  - Creating symlink: bin/$1 -> bin/fzf"
+  (cd "$fzf_base"/bin &&
+   rm -f fzf &&
+   ln -sf $1 fzf)
+  if [ $? -ne 0 ]; then
+    binary_error="Failed to create symlink"
+    return 1
+  fi
+}
+
+download() {
+  echo "Downloading bin/fzf ..."
+  if [[ ! $1 =~ dev && -x "$fzf_base"/bin/fzf ]]; then
+    echo "  - Already exists"
+    check_binary && return
+  elif [ -x "$fzf_base"/bin/$1 ]; then
+    symlink $1 && check_binary && return
+  fi
+  mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
+  if [ $? -ne 0 ]; then
+    binary_error="Failed to create bin directory"
+    return
+  fi
+
+  local url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}.tgz
+  if which curl > /dev/null; then
+    curl -fL $url | tar -xz
+  elif which wget > /dev/null; then
+    wget -O - $url | tar -xz
+  else
+    binary_error="curl or wget not found"
+    return
+  fi
+
+  if [ ! -f $1 ]; then
+    binary_error="Failed to download ${1}"
+    return
+  fi
+
+  chmod +x $1 && symlink $1 && check_binary
+}
+
+# Try to download binary executable
+archi=$(uname -sm)
+binary_available=1
+binary_error=""
+case "$archi" in
+  Darwin\ x86_64) download fzf-$version-darwin_amd64 ;;
+  Darwin\ i*86)   download fzf-$version-darwin_386   ;;
+  Linux\ x86_64)  download fzf-$version-linux_amd64  ;;
+  Linux\ i*86)    download fzf-$version-linux_386    ;;
+  *)              binary_available=0                 ;;
+esac
+
+cd "$fzf_base"
+if [ -n "$binary_error" ]; then
+  if [ $binary_available -eq 0 ]; then
+    echo "No prebuilt binary for $archi ... "
+  else
+    echo "  - $binary_error !!!"
+  fi
+  echo "Installing legacy Ruby version ..."
+
+  # ruby executable
+  echo -n "Checking Ruby executable ... "
+  ruby=`which ruby`
+  if [ $? -ne 0 ]; then
+    echo "ruby executable not found !!!"
+    exit 1
+  fi
+
+  # System ruby is preferred
+  system_ruby=/usr/bin/ruby
+  if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
+    $system_ruby --disable-gems -rcurses -e0 2> /dev/null
+    [ $? -eq 0 ] && ruby=$system_ruby
+  fi
+
+  echo "OK ($ruby)"
+
+  # Curses-support
+  echo -n "Checking Curses support ... "
+  "$ruby" -rcurses -e0 2> /dev/null
+  if [ $? -eq 0 ]; then
+    echo "OK"
+  else
+    echo "Not found"
+    echo "Installing 'curses' gem ... "
+    if (( EUID )); then
+      /usr/bin/env gem install curses --user-install
+    else
+      /usr/bin/env gem install curses
+    fi
+    if [ $? -ne 0 ]; then
+      echo
+      echo "Failed to install 'curses' gem."
+      if [[ $(uname -r) =~ 'ARCH' ]]; then
+        echo "Make sure that base-devel package group is installed."
+      fi
+      exit 1
+    fi
+  fi
+
+  # Ruby version
+  echo -n "Checking Ruby version ... "
+  "$ruby" -e 'exit RUBY_VERSION >= "1.9"'
+  if [ $? -eq 0 ]; then
+    echo ">= 1.9"
+    "$ruby" --disable-gems -rcurses -e0 2> /dev/null
+    if [ $? -eq 0 ]; then
+      fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
+    else
+      fzf_cmd="$ruby $fzf_base/fzf"
+    fi
+  else
+    echo "< 1.9"
+    fzf_cmd="$ruby $fzf_base/fzf"
+  fi
 fi
 
 # Auto-completion
-read -p "Do you want to add auto-completion support? ([y]/n) " -n 1 -r
+ask "Do you want to add auto-completion support?"
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
 auto_completion=$?
 
 # Key-bindings
-read -p "Do you want to add key bindings? ([y]/n) " -n 1 -r
+ask "Do you want to add key bindings?"
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
 key_bindings=$?
 
 echo
@@ -49,12 +159,13 @@ for shell in bash zsh; do
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
-  fzf_completion="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
 
-  cat > $src << EOF
+  if [ -n "$binary_error" ]; then
+    cat > $src << EOF
 # Setup fzf function
 # ------------------
 unalias fzf 2> /dev/null
@@ -68,55 +179,143 @@ export -f fzf > /dev/null
 $fzf_completion
 
 EOF
+  else
+    cat > $src << EOF
+# Setup fzf
+# ---------
+unalias fzf 2> /dev/null
+unset fzf 2> /dev/null
+if [[ ! "\$PATH" =~ "$fzf_base/bin" ]]; then
+  export PATH="$fzf_base/bin:\$PATH"
+fi
+
+# Auto-completion
+# ---------------
+$fzf_completion
+
+EOF
+  fi
 
   if [ $key_bindings -eq 0 ]; then
     if [ $shell = bash ]; then
-      cat >> $src << "EOF"
+      cat >> $src << "EOFZF"
 # Key bindings
 # ------------
-# Required to refresh the prompt after fzf
+__fsel() {
-bind '"\er": redraw-current-line'
+  command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-
-# CTRL-T - Paste the selected file path into the command line
-fsel() {
-  find * -path '*/\.*' -prune \
     -o -type f -print \
-    -o -type l -print 2> /dev/null | fzf -m | while read item; do
+    -o -type d -print \
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
     printf '%q ' "$item"
   done
   echo
 }
-bind '"\C-t": " \C-u \C-a\C-k$(fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er"'
 
-# CTRL-R - Paste the selected command from history into the command line
+if [[ $- =~ i ]]; then
-bind '"\C-r": " \C-e\C-u$(history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
 
-EOF
+__fsel_tmux() {
-    else
+  local height
-      cat >> $src << "EOF"
+  height=${FZF_TMUX_HEIGHT:-40%}
+  if [[ $height =~ %$ ]]; then
+    height="-p ${height%\%}"
+  else
+    height="-l $height"
+  fi
+  tmux split-window $height "bash -c 'source ~/.fzf.bash; tmux send-keys -t $TMUX_PANE \"\$(__fsel)\"'"
+}
+
+__fcd() {
+  local 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
+[ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
+
+if [ -z "$(set -o | \grep '^vi.*on')" ]; then
+  # Required to refresh the prompt after fzf
+  bind '"\er": redraw-current-line'
+
+  # CTRL-T - Paste the selected file path into the command line
+  if [ $__use_tmux -eq 1 ]; then
+    bind '"\C-t": " \C-u \C-a\C-k$(__fsel_tmux)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
+  else
+    bind '"\C-t": " \C-u \C-a\C-k$(__fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
+  fi
+
+  # CTRL-R - Paste the selected command from history into the command line
+  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"'
+else
+  bind '"\C-x\C-e": shell-expand-line'
+  bind '"\C-x\C-r": redraw-current-line'
+
+  # CTRL-T - Paste the selected file path into the command line
+  # - FIXME: Selected items are attached to the end regardless of cursor position
+  if [ $__use_tmux -eq 1 ]; then
+    bind '"\C-t": "\e$a \eddi$(__fsel_tmux)\C-x\C-e\e0P$xa"'
+  else
+    bind '"\C-t": "\e$a \eddi$(__fsel)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
+  fi
+  bind -m vi-command '"\C-t": "i\C-t"'
+
+  # CTRL-R - Paste the selected command from history into the command line
+  bind '"\C-r": "\eddi$(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
+  bind '"\ec": "\eddi$(__fcd)\C-x\C-e\C-x\C-r\C-m"'
+  bind -m vi-command '"\ec": "i\ec"'
+fi
+
+unset __use_tmux
+
+fi
+EOFZF
+    else  # zsh
+      cat >> $src << "EOFZF"
 # Key bindings
 # ------------
 # CTRL-T - Paste the selected file path(s) into the command line
-fzf-file-widget() {
+__fsel() {
-  local FILES
+  command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-  local IFS="
-"
-  FILES=($(
-    find * -path '*/\.*' -prune \
     -o -type f -print \
-    -o -type l -print 2> /dev/null | fzf -m))
+    -o -type d -print \
-  unset IFS
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
-  FILES=$FILES:q
+    printf '%q ' "$item"
-  LBUFFER="${LBUFFER%% #} $FILES"
+  done
-  zle redisplay
+  echo
 }
+
+if [[ $- =~ i ]]; then
+
+if [ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ]; then
+  fzf-file-widget() {
+    local height
+    height=${FZF_TMUX_HEIGHT:-40%}
+    if [[ $height =~ %$ ]]; then
+      height="-p ${height%\%}"
+    else
+      height="-l $height"
+    fi
+    tmux split-window $height "zsh -c 'source ~/.fzf.zsh; tmux send-keys -t $TMUX_PANE \"\$(__fsel)\"'"
+  }
+else
+  fzf-file-widget() {
+    LBUFFER="${LBUFFER}$(__fsel)"
+    zle redisplay
+  }
+fi
 zle     -N   fzf-file-widget
 bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  cd "${$(find * -path '*/\.*' -prune \
+  cd "${$(command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-          -o -type d -print 2> /dev/null | fzf):-.}"
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | fzf +m):-.}"
   zle reset-prompt
 }
 zle     -N    fzf-cd-widget
@@ -124,40 +323,176 @@ bindkey '\ec' fzf-cd-widget
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  LBUFFER=$(history | fzf +s | sed "s/ *[0-9]* *//")
+  LBUFFER=$(fc -l 1 | fzf +s --tac +m -n2..,.. | sed "s/ *[0-9*]* *//")
   zle redisplay
 }
 zle     -N   fzf-history-widget
 bindkey '^R' fzf-history-widget
 
-EOF
+fi
+EOFZF
     fi
   fi
 
   echo "OK"
 done
 
-echo
+# fish
-for shell in bash zsh; do
+has_fish=0
-  rc=~/.${shell}rc
+if [ -n "$(which fish)" ]; then
-  src="source ~/.fzf.${shell}"
+  has_fish=1
-
+  echo -n "Generate ~/.config/fish/functions/fzf.fish ... "
-  echo "Update $rc:"
+  mkdir -p ~/.config/fish/functions
-  echo "  - $src"
+  if [ -n "$binary_error" ]; then
-  if [ $(grep -F "$src" $rc | wc -l) -gt 0 ]; then
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
-    echo "    - Not added (already being sourced)"
+function fzf
+  $fzf_cmd \$argv
+end
+EOFZF
   else
-    echo $src >> $rc
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
-    echo "    - Added"
+function fzf
+  $fzf_base/bin/fzf \$argv
+end
+EOFZF
+  fi
+  echo "OK"
+
+  if [ $key_bindings -eq 0 ]; then
+    echo -n "Generate ~/.config/fish/functions/fzf_key_bindings.fish ... "
+    cat > ~/.config/fish/functions/fzf_key_bindings.fish << "EOFZF"
+function fzf_key_bindings
+  # Due to a bug of fish, we cannot use command substitution,
+  # so we use temporary file instead
+  if [ -z "$TMPDIR" ]
+    set -g TMPDIR /tmp
+  end
+
+  function __fzf_list
+    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-
+  end
+
+  function __fzf_list_dir
+    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
+    while read item
+      echo -n (echo -n "$item" | sed -E 's/([ "$~'\''([{<>})])/\\\\\\1/g')' '
+    end
+  end
+
+  function __fzf_ctrl_t
+    if [ -n "$TMUX_PANE" -a "$FZF_TMUX" != "0" ]
+      tmux split-window (__fzf_tmux_height) "fish -c 'fzf_key_bindings; __fzf_ctrl_t_tmux \\$TMUX_PANE'"
+    else
+      __fzf_list | fzf -m > $TMPDIR/fzf.result
+      and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
+      commandline -f repaint
+      rm -f $TMPDIR/fzf.result
+    end
+  end
+
+  function __fzf_ctrl_t_tmux
+    __fzf_list | fzf -m > $TMPDIR/fzf.result
+    and tmux send-keys -t $argv[1] (cat $TMPDIR/fzf.result | __fzf_escape)
+    rm -f $TMPDIR/fzf.result
+  end
+
+  function __fzf_reverse
+    if which tac > /dev/null
+      tac $argv
+    else
+      tail -r $argv
+    end
+  end
+
+  function __fzf_ctrl_r
+    history | __fzf_reverse | fzf +s --tac +m > $TMPDIR/fzf.result
+    and commandline (cat $TMPDIR/fzf.result)
+    commandline -f repaint
+    rm -f $TMPDIR/fzf.result
+  end
+
+  function __fzf_alt_c
+    # Fish hangs if the command before pipe redirects (2> /dev/null)
+    __fzf_list_dir | fzf +m > $TMPDIR/fzf.result
+    [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
+    and cd (cat $TMPDIR/fzf.result)
+    commandline -f repaint
+    rm -f $TMPDIR/fzf.result
+  end
+
+  function __fzf_tmux_height
+    if set -q FZF_TMUX_HEIGHT
+      set height $FZF_TMUX_HEIGHT
+    else
+      set height 40%
+    end
+    if echo $height | \grep -q -E '%$'
+      echo "-p "(echo $height | sed 's/%$//')
+    else
+      echo "-l $height"
+    end
+    set -e height
+  end
+
+  bind \ct '__fzf_ctrl_t'
+  bind \cr '__fzf_ctrl_r'
+  bind \ec '__fzf_alt_c'
+end
+EOFZF
+    echo "OK"
+  fi
+fi
+
+append_line() {
+  echo "Update $2:"
+  echo "  - $1"
+  [ -f "$2" ] || touch "$2"
+  if [ $# -lt 3 ]; then
+    line=$(\grep -nF "$1" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  else
+    line=$(\grep -nF "$3" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  fi
+  if [ -n "$line" ]; then
+    echo "    - Already exists: line #$line"
+  else
+    echo "$1" >> "$2"
+    echo "    + Added"
   fi
   echo
+}
+
+echo
+for shell in bash zsh; do
+  append_line "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" ~/.${shell}rc "~/.fzf.${shell}"
 done
 
-cat << EOF
+if [ $key_bindings -eq 0 -a $has_fish -eq 1 ]; then
-Finished. Reload your .bashrc or .zshrc to take effect.
+  bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
-   source ~/.bashrc  # bash"
+  append_line "fzf_key_bindings" "$bind_file"
-   source ~/.zshrc   # zsh"
 
-To uninstall fzf, simply remove the added line.
+  echo '  * Due to a known bug of fish, you may have issues running fzf on fish.'
+  echo '  * If that happens, try the following:'
+  echo '    - Remove ~/.config/fish/functions/fzf.fish'
+  echo '    - Place fzf executable in a directory included in $PATH'
+  echo
+fi
+
+cat << EOF
+Finished. Restart your shell or reload config file.
+   source ~/.bashrc  # bash
+   source ~/.zshrc   # zsh
+EOF
+[ $has_fish -eq 1 ] && echo "   fzf_key_bindings  # fish"; cat << EOF
+
+Use uninstall script to remove fzf.
+
+For more information, see: https://github.com/junegunn/fzf
 EOF
 

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2013 Junegunn Choi
+" Copyright (c) 2015 Junegunn Choi
 "
 " MIT License
 "
@@ -21,39 +21,235 @@
 " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-let s:exec = expand('<sfile>:h:h').'/fzf'
+let s:default_tmux_height = '40%'
+let s:launcher = 'xterm -e bash -ic %s'
+let s:fzf_go = expand('<sfile>:h:h').'/bin/fzf'
+let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
+let s:fzf_tmux = expand('<sfile>:h:h').'/bin/fzf-tmux'
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! s:fzf_exec()
+  if !exists('s:exec')
+    if executable(s:fzf_go)
+      let s:exec = s:fzf_go
+    else
+      let path = split(system('which fzf 2> /dev/null'), '\n')
+      if !v:shell_error && !empty(path)
+        let s:exec = path[0]
+      elseif executable(s:fzf_rb)
+        let s:exec = s:fzf_rb
+      else
+        call system('type fzf')
+        if v:shell_error
+          throw 'fzf executable not found'
+        else
+          let s:exec = 'fzf'
+        endif
+      endif
+    endif
+    return s:exec
+  else
+    return s:exec
+  endif
+endfunction
+
+function! s:tmux_enabled()
+  if has('gui_running')
+    return 0
+  endif
+
+  if exists('s:tmux')
+    return s:tmux
+  endif
+
+  let s:tmux = 0
+  if exists('$TMUX') && executable(s:fzf_tmux)
+    let output = system('tmux -V')
+    let s:tmux = !v:shell_error && output >= 'tmux 1.7'
+  endif
+  return s:tmux
+endfunction
+
+function! s:shellesc(arg)
+  return '"'.substitute(a:arg, '"', '\\"', 'g').'"'
+endfunction
 
 function! s:escape(path)
   return substitute(a:path, ' ', '\\ ', 'g')
 endfunction
 
-function! fzf#run(command, ...)
+" Upgrade legacy options
-  let cwd = getcwd()
+function! s:upgrade(dict)
+  let copy = copy(a:dict)
+  if has_key(copy, 'tmux')
+    let copy.down = remove(copy, 'tmux')
+  endif
+  if has_key(copy, 'tmux_height')
+    let copy.down = remove(copy, 'tmux_height')
+  endif
+  if has_key(copy, 'tmux_width')
+    let copy.right = remove(copy, 'tmux_width')
+  endif
+  return copy
+endfunction
+
+function! fzf#run(...) abort
+  let dict   = exists('a:1') ? s:upgrade(a:1) : {}
+  let temps  = { 'result': tempname() }
+  let optstr = get(dict, 'options', '')
   try
-    let args = copy(a:000)
+    let fzf_exec = s:fzf_exec()
-    if len(args) > 0 && isdirectory(expand(args[-1]))
+  catch
-      let dir = remove(args, -1)
+    throw v:exception
-      execute 'chdir '.s:escape(dir)
+  endtry
+
+  if has_key(dict, 'source')
+    let source = dict.source
+    let type = type(source)
+    if type == 1
+      let prefix = source.'|'
+    elseif type == 3
+      let temps.input = tempname()
+      call writefile(source, temps.input)
+      let prefix = 'cat '.s:shellesc(temps.input).'|'
+    else
+      throw 'Invalid source type'
     endif
-    let argstr  = join(args)
+  else
-    let tf      = tempname()
+    let prefix = ''
-    let prefix  = exists('g:fzf_source') ? g:fzf_source.'|' : ''
+  endif
-    let fzf     = executable(s:exec)     ? s:exec : 'fzf'
+  let split = s:tmux_enabled() && s:tmux_splittable(dict)
-    let options = empty(argstr)          ? get(g:, 'fzf_options', '') : argstr
+  let command = prefix.(split ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
-    execute "silent !".prefix.fzf.' '.options." > ".tf
+
-    if !v:shell_error
+  if split
-      for line in readfile(tf)
+    return s:execute_tmux(dict, command, temps)
-        if !empty(line)
+  else
-          execute a:command.' '.s:escape(line)
+    return s:execute(dict, command, temps)
+  endif
+endfunction
+
+function! s:present(dict, ...)
+  for key in a:000
+    if !empty(get(a:dict, key, ''))
+      return 1
+    endif
+  endfor
+  return 0
+endfunction
+
+function! s:fzf_tmux(dict)
+  let size = ''
+  for o in ['up', 'down', 'left', 'right']
+    if s:present(a:dict, o)
+      let size = '-'.o[0].(a:dict[o] == 1 ? '' : a:dict[o])
+    endif
+  endfor
+  return printf('LINES=%d COLUMNS=%d %s %s %s --',
+    \ &lines, &columns, s:fzf_tmux, size, (has_key(a:dict, 'source') ? '' : '-'))
+endfunction
+
+function! s:tmux_splittable(dict)
+  return s:present(a:dict, 'up', 'down', 'left', 'right')
+endfunction
+
+function! s:pushd(dict)
+  if s:present(a:dict, 'dir')
+    let a:dict.prev_dir = getcwd()
+    execute 'chdir '.s:escape(a:dict.dir)
+    return 1
+  endif
+  return 0
+endfunction
+
+function! s:popd(dict)
+  if has_key(a:dict, 'prev_dir')
+    execute 'chdir '.s:escape(remove(a:dict, 'prev_dir'))
+  endif
+endfunction
+
+function! s:execute(dict, command, temps)
+  call s:pushd(a:dict)
+  silent !clear
+  if has('gui_running')
+    let launcher = get(a:dict, 'launcher', get(g:, 'fzf_launcher', s:launcher))
+    let command = printf(launcher, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
+  else
+    let command = a:command
+  endif
+  execute 'silent !'.command
+  redraw!
+  if v:shell_error
+    " Do not print error message on exit status 1
+    if v:shell_error > 1
+      echohl ErrorMsg
+      echo 'Error running ' . command
+    endif
+    return []
+  else
+    return s:callback(a:dict, a:temps)
+  endif
+endfunction
+
+function! s:env_var(name)
+  if exists('$'.a:name)
+    return a:name . "='". substitute(expand('$'.a:name), "'", "'\\\\''", 'g') . "' "
+  else
+    return ''
+  endif
+endfunction
+
+function! s:execute_tmux(dict, command, temps)
+  let command = a:command
+  if s:pushd(a:dict)
+    " -c '#{pane_current_path}' is only available on tmux 1.9 or above
+    let command = 'cd '.s:escape(a:dict.dir).' && '.command
+  endif
+
+  call system(command)
+  return s:callback(a:dict, a:temps)
+endfunction
+
+function! s:callback(dict, temps)
+  if !filereadable(a:temps.result)
+    let lines = []
+  else
+    let lines = readfile(a:temps.result)
+    if has_key(a:dict, 'sink')
+      for line in lines
+        if type(a:dict.sink) == 2
+          call a:dict.sink(line)
+        else
+          execute a:dict.sink.' '.s:escape(line)
         endif
       endfor
     endif
-  finally
+  endif
-    execute 'chdir '.s:escape(cwd)
+
-    redraw!
+  for tf in values(a:temps)
     silent! call delete(tf)
-  endtry
+  endfor
+
+  call s:popd(a:dict)
+
+  return lines
 endfunction
 
-command! -nargs=* -complete=dir FZF call fzf#run('silent e', <f-args>)
+function! s:cmd(bang, ...) abort
+  let args = copy(a:000)
+  let opts = {}
+  if len(args) > 0 && isdirectory(expand(args[-1]))
+    let opts.dir = remove(args, -1)
+  endif
+  if !a:bang
+    let opts.down = get(g:, 'fzf_tmux_height', s:default_tmux_height)
+  endif
+  call fzf#run(extend({ 'sink': 'e', 'options': join(args) }, opts))
+endfunction
+
+command! -nargs=* -complete=dir -bang FZF call s:cmd('<bang>' == '!', <f-args>)
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
 

src/Dockerfile.arch

@@ -0,0 +1,27 @@
+FROM base/archlinux:2014.07.03
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# For i386 build
+RUN echo '[multilib]' >> /etc/pacman.conf && \
+    echo 'Include = /etc/pacman.d/mirrorlist' >> /etc/pacman.conf && \
+    pacman-db-upgrade && yes | pacman -Sy gcc-multilib lib32-ncurses && \
+    cd $GOROOT/src && GOARCH=386 ./make.bash
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/Dockerfile.centos

@@ -0,0 +1,21 @@
+FROM centos:centos7
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# yum
+RUN yum install -y git gcc make tar ncurses-devel
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/Dockerfile.ubuntu

@@ -0,0 +1,26 @@
+FROM ubuntu:14.04
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN apt-get update && apt-get -y upgrade && \
+    apt-get install -y --force-yes git curl build-essential libncurses-dev
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4
+
+ENV GOPATH /go
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+# For i386 build
+RUN apt-get install -y lib32ncurses5-dev && \
+    cd $GOROOT/src && GOARCH=386 ./make.bash
+
+# Volume
+VOLUME /go
+
+# Default CMD
+CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+

src/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.

src/Makefile

@@ -0,0 +1,74 @@
+ifndef GOPATH
+$(error GOPATH is undefined)
+endif
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+	GOOS := darwin
+else ifeq ($(UNAME_S),Linux)
+	GOOS := linux
+endif
+
+ifneq ($(shell uname -m),x86_64)
+$(error "Build on $(UNAME_M) is not supported, yet.")
+endif
+
+SOURCES   := $(wildcard *.go */*.go)
+BINDIR    := ../bin
+
+BINARY32  := fzf-$(GOOS)_386
+BINARY64  := fzf-$(GOOS)_amd64
+VERSION    = $(shell fzf/$(BINARY64) --version)
+RELEASE32  = fzf-$(VERSION)-$(GOOS)_386
+RELEASE64  = fzf-$(VERSION)-$(GOOS)_amd64
+
+all: release
+
+release: build
+	cd fzf && \
+	cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32) && \
+	cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
+	rm $(RELEASE32) $(RELEASE64)
+
+build: test fzf/$(BINARY32) fzf/$(BINARY64)
+
+test:
+	go get
+	go test -v ./...
+
+install: $(BINDIR)/fzf
+
+uninstall:
+	rm -f $(BINDIR)/fzf $(BINDIR)/$(BINARY64)
+
+clean:
+	cd fzf && rm -f $(BINARY32) $(BINARY64) $(RELEASE32).tgz $(RELEASE64).tgz
+
+fzf/$(BINARY32): $(SOURCES)
+	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -o $(BINARY32)
+
+fzf/$(BINARY64): $(SOURCES)
+	cd fzf && go build -o $(BINARY64)
+
+$(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
+	cp -f fzf/$(BINARY64) $(BINDIR)
+	cd $(BINDIR) && ln -sf $(BINARY64) fzf
+
+$(BINDIR):
+	mkdir -p $@
+
+# Linux distribution to build fzf on
+DISTRO := arch
+
+docker:
+	docker build -t junegunn/$(DISTRO)-sandbox - < Dockerfile.$(DISTRO)
+
+linux: docker
+	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
+		/bin/bash -ci 'cd /go/src/github.com/junegunn/fzf/src; make'
+
+$(DISTRO): docker
+	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
+		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+
+.PHONY: all build release test install uninstall clean docker linux $(DISTRO)

src/README.md

@@ -0,0 +1,121 @@
+fzf in Go
+=========
+
+<img src="https://cloud.githubusercontent.com/assets/700826/5725028/028ea834-9b93-11e4-9198-43088c3f295d.gif" height="463" alt="fzf in go">
+
+This directory contains the source code for the new fzf implementation in
+[Go][go].
+
+Upgrade from Ruby version
+-------------------------
+
+The install script has been updated to download the right binary for your
+system. If you already have installed fzf, simply git-pull the repository and
+rerun the install script.
+
+```sh
+cd ~/.fzf
+git pull
+./install
+```
+
+Otherwise, follow [the instruction][install] as before. You can also install
+fzf using Homebrew if you prefer that way.
+
+Motivations
+-----------
+
+### No Ruby dependency
+
+There have always been complaints about fzf being a Ruby script. To make
+matters worse, Ruby 2.1 removed ncurses binding from its standard libary.
+Because of the change, users running Ruby 2.1 or above are forced to build C
+extensions of curses gem to meet the requirement of fzf. The new Go version
+will be distributed as an executable binary so it will be much more accessible
+and should be easier to setup.
+
+### Performance
+
+Many people have been surprised to see how fast fzf is even when it was
+written in Ruby. It stays quite responsive even for 100k+ lines, which is
+well above the size of the usual input.
+
+The new Go version, of course, is significantly faster than that. It has all
+the performance optimization techniques used in Ruby implementation and more.
+It also doesn't suffer from [GIL][gil], so the search performance scales
+proportional to the number of CPU cores. On my MacBook Pro (Mid 2012), the new
+version was shown to be an order of magnitude faster on certain cases. It also
+starts much faster though the difference may not be noticeable.
+
+Differences with Ruby version
+-----------------------------
+
+The Go version is designed to be perfectly compatible with the previous Ruby
+version. The only behavioral difference is that the new version ignores the
+numeric argument to `--sort=N` option and always sorts the result regardless
+of the number of matches. The value was introduced to limit the response time
+of the query, but the Go version is blazingly fast (almost instant response
+even for 1M+ items) so I decided that it's no longer required.
+
+System requirements
+-------------------
+
+Currently, prebuilt binaries are provided only for OS X and Linux. The install
+script will fall back to the legacy Ruby version on the other systems, but if
+you have Go 1.4 installed, you can try building it yourself.
+
+However, as pointed out in [golang.org/doc/install][req], the Go version may
+not run on CentOS/RHEL 5.x, and if that's the case, the install script will
+choose the Ruby version instead.
+
+The Go version depends on [ncurses][ncurses] and some Unix system calls, so it
+shouldn't run natively on Windows at the moment. But it won't be impossible to
+support Windows by falling back to a cross-platform alternative such as
+[termbox][termbox] only on Windows. If you're interested in making fzf work on
+Windows, please let me know.
+
+Build
+-----
+
+```sh
+# Build fzf executables and tarballs
+make
+
+# Install the executable to ../bin directory
+make install
+
+# Build executables and tarballs for Linux using Docker
+make linux
+```
+
+Contribution
+------------
+
+For the time being, I will not add or accept any new features until we can be
+sure that the implementation is stable and we have a sufficient number of test
+cases. However, fixes for obvious bugs and new test cases are welcome.
+
+I also care much about the performance of the implementation, so please make
+sure that your change does not result in performance regression. And please be
+noted that we don't have a quantitative measure of the performance yet.
+
+Third-party libraries used
+--------------------------
+
+- [ncurses][ncurses]
+- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
+    - Licensed under [MIT](http://mattn.mit-license.org/2013)
+- [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
+    - Licensed under [MIT](http://mattn.mit-license.org/2014)
+
+License
+-------
+
+[MIT](LICENSE)
+
+[install]: https://github.com/junegunn/fzf#installation
+[go]:      https://golang.org/
+[gil]:     http://en.wikipedia.org/wiki/Global_Interpreter_Lock
+[ncurses]: https://www.gnu.org/software/ncurses/
+[req]:     http://golang.org/doc/install
+[termbox]: https://github.com/nsf/termbox-go

src/algo/algo.go

@@ -0,0 +1,155 @@
+package algo
+
+import "strings"
+
+/*
+ * String matching algorithms here do not use strings.ToLower to avoid
+ * performance penalty. And they assume pattern runes are given in lowercase
+ * letters when caseSensitive is false.
+ *
+ * In short: They try to do as little work as possible.
+ */
+
+// FuzzyMatch performs fuzzy-match
+func FuzzyMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+
+	// 0. (FIXME) How to find the shortest match?
+	//    a_____b__c__abc
+	//    ^^^^^^^^^^  ^^^
+	// 1. forward scan (abc)
+	//   *-----*-----*>
+	//   a_____b___abc__
+	// 2. reverse scan (cba)
+	//   a_____b___abc__
+	//            <***
+	pidx := 0
+	sidx := -1
+	eidx := -1
+
+	for index, char := range runes {
+		// This is considerably faster than blindly applying strings.ToLower to the
+		// whole string
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char == pattern[pidx] {
+			if sidx < 0 {
+				sidx = index
+			}
+			if pidx++; pidx == len(pattern) {
+				eidx = index + 1
+				break
+			}
+		}
+	}
+
+	if sidx >= 0 && eidx >= 0 {
+		pidx--
+		for index := eidx - 1; index >= sidx; index-- {
+			char := runes[index]
+			if !caseSensitive && char >= 65 && char <= 90 {
+				char += 32
+			}
+			if char == pattern[pidx] {
+				if pidx--; pidx < 0 {
+					sidx = index
+					break
+				}
+			}
+		}
+		return sidx, eidx
+	}
+	return -1, -1
+}
+
+// ExactMatchStrings performs exact-match using strings package.
+// Currently not used.
+func ExactMatchStrings(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	var str string
+	if caseSensitive {
+		str = *input
+	} else {
+		str = strings.ToLower(*input)
+	}
+
+	if idx := strings.Index(str, string(pattern)); idx >= 0 {
+		prefixRuneLen := len([]rune((*input)[:idx]))
+		return prefixRuneLen, prefixRuneLen + len(pattern)
+	}
+	return -1, -1
+}
+
+// ExactMatchNaive is a basic string searching algorithm that handles case
+// sensitivity. Although naive, it still performs better than the combination
+// of strings.ToLower + strings.Index for typical fzf use cases where input
+// strings and patterns are not very long.
+//
+// We might try to implement better algorithms in the future:
+// http://en.wikipedia.org/wiki/String_searching_algorithm
+func ExactMatchNaive(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+	numRunes := len(runes)
+	plen := len(pattern)
+	if numRunes < plen {
+		return -1, -1
+	}
+
+	pidx := 0
+	for index := 0; index < numRunes; index++ {
+		char := runes[index]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if pattern[pidx] == char {
+			pidx++
+			if pidx == plen {
+				return index - plen + 1, index + 1
+			}
+		} else {
+			index -= pidx
+			pidx = 0
+		}
+	}
+	return -1, -1
+}
+
+// PrefixMatch performs prefix-match
+func PrefixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(*input)
+	if len(runes) < len(pattern) {
+		return -1, -1
+	}
+
+	for index, r := range pattern {
+		char := runes[index]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char != r {
+			return -1, -1
+		}
+	}
+	return 0, len(pattern)
+}
+
+// SuffixMatch performs suffix-match
+func SuffixMatch(caseSensitive bool, input *string, pattern []rune) (int, int) {
+	runes := []rune(strings.TrimRight(*input, " "))
+	trimmedLen := len(runes)
+	diff := trimmedLen - len(pattern)
+	if diff < 0 {
+		return -1, -1
+	}
+
+	for index, r := range pattern {
+		char := runes[index+diff]
+		if !caseSensitive && char >= 65 && char <= 90 {
+			char += 32
+		}
+		if char != r {
+			return -1, -1
+		}
+	}
+	return trimmedLen - len(pattern), trimmedLen
+}

src/algo/algo_test.go

@@ -0,0 +1,44 @@
+package algo
+
+import (
+	"strings"
+	"testing"
+)
+
+func assertMatch(t *testing.T, fun func(bool, *string, []rune) (int, int), caseSensitive bool, input string, pattern string, sidx int, eidx int) {
+	if !caseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
+	s, e := fun(caseSensitive, &input, []rune(pattern))
+	if s != sidx {
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", s, sidx, input, pattern)
+	}
+	if e != eidx {
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", e, eidx, input, pattern)
+	}
+}
+
+func TestFuzzyMatch(t *testing.T) {
+	assertMatch(t, FuzzyMatch, false, "fooBarbaz", "oBZ", 2, 9)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBZ", -1, -1)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBz", 2, 9)
+	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "fooBarbazz", -1, -1)
+}
+
+func TestExactMatchNaive(t *testing.T) {
+	assertMatch(t, ExactMatchNaive, false, "fooBarbaz", "oBA", 2, 5)
+	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "oBA", -1, -1)
+	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "fooBarbazz", -1, -1)
+}
+
+func TestPrefixMatch(t *testing.T) {
+	assertMatch(t, PrefixMatch, false, "fooBarbaz", "Foo", 0, 3)
+	assertMatch(t, PrefixMatch, true, "fooBarbaz", "Foo", -1, -1)
+	assertMatch(t, PrefixMatch, false, "fooBarbaz", "baz", -1, -1)
+}
+
+func TestSuffixMatch(t *testing.T) {
+	assertMatch(t, SuffixMatch, false, "fooBarbaz", "Foo", -1, -1)
+	assertMatch(t, SuffixMatch, false, "fooBarbaz", "baz", 6, 9)
+	assertMatch(t, SuffixMatch, true, "fooBarbaz", "Baz", -1, -1)
+}

src/cache.go

@@ -0,0 +1,53 @@
+package fzf
+
+import "sync"
+
+// QueryCache associates strings to lists of items
+type QueryCache map[string][]*Item
+
+// ChunkCache associates Chunk and query string to lists of items
+type ChunkCache struct {
+	mutex sync.Mutex
+	cache map[*Chunk]*QueryCache
+}
+
+// NewChunkCache returns a new ChunkCache
+func NewChunkCache() ChunkCache {
+	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*QueryCache)}
+}
+
+// Add adds the list to the cache
+func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Item) {
+	if len(key) == 0 || !chunk.IsFull() {
+		return
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		cc.cache[chunk] = &QueryCache{}
+		qc = cc.cache[chunk]
+	}
+	(*qc)[key] = list
+}
+
+// Find is called to lookup ChunkCache
+func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Item, bool) {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil, false
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if ok {
+		list, ok := (*qc)[key]
+		if ok {
+			return list, true
+		}
+	}
+	return nil, false
+}

src/cache_test.go

@@ -0,0 +1,40 @@
+package fzf
+
+import "testing"
+
+func TestChunkCache(t *testing.T) {
+	cache := NewChunkCache()
+	chunk2 := make(Chunk, ChunkSize)
+	chunk1p := &Chunk{}
+	chunk2p := &chunk2
+	items1 := []*Item{&Item{}}
+	items2 := []*Item{&Item{}, &Item{}}
+	cache.Add(chunk1p, "foo", items1)
+	cache.Add(chunk2p, "foo", items1)
+	cache.Add(chunk2p, "bar", items2)
+
+	{ // chunk1 is not full
+		cached, found := cache.Find(chunk1p, "foo")
+		if found {
+			t.Error("Cached disabled for non-empty chunks", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk2p, "foo")
+		if !found || len(cached) != 1 {
+			t.Error("Expected 1 item cached", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk2p, "bar")
+		if !found || len(cached) != 2 {
+			t.Error("Expected 2 items cached", found, cached)
+		}
+	}
+	{
+		cached, found := cache.Find(chunk1p, "foobar")
+		if found {
+			t.Error("Expected 0 item cached", found, cached)
+		}
+	}
+}

src/chunklist.go

@@ -0,0 +1,88 @@
+package fzf
+
+import "sync"
+
+// Capacity of each chunk
+const ChunkSize int = 100
+
+// Chunk is a list of Item pointers whose size has the upper limit of ChunkSize
+type Chunk []*Item // >>> []Item
+
+// ItemBuilder is a closure type that builds Item object from a pointer to a
+// string and an integer
+type ItemBuilder func(*string, int) *Item
+
+// ChunkList is a list of Chunks
+type ChunkList struct {
+	chunks []*Chunk
+	count  int
+	mutex  sync.Mutex
+	trans  ItemBuilder
+}
+
+// NewChunkList returns a new ChunkList
+func NewChunkList(trans ItemBuilder) *ChunkList {
+	return &ChunkList{
+		chunks: []*Chunk{},
+		count:  0,
+		mutex:  sync.Mutex{},
+		trans:  trans}
+}
+
+func (c *Chunk) push(trans ItemBuilder, data *string, index int) {
+	*c = append(*c, trans(data, index))
+}
+
+// IsFull returns true if the Chunk is full
+func (c *Chunk) IsFull() bool {
+	return len(*c) == ChunkSize
+}
+
+func (cl *ChunkList) lastChunk() *Chunk {
+	return cl.chunks[len(cl.chunks)-1]
+}
+
+// CountItems returns the total number of Items
+func CountItems(cs []*Chunk) int {
+	if len(cs) == 0 {
+		return 0
+	}
+	return ChunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
+}
+
+// Push adds the item to the list
+func (cl *ChunkList) Push(data string) {
+	cl.mutex.Lock()
+	defer cl.mutex.Unlock()
+
+	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
+		newChunk := Chunk(make([]*Item, 0, ChunkSize))
+		cl.chunks = append(cl.chunks, &newChunk)
+	}
+
+	cl.lastChunk().push(cl.trans, &data, cl.count)
+	cl.count++
+}
+
+// Snapshot returns immutable snapshot of the ChunkList
+func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
+	cl.mutex.Lock()
+	defer cl.mutex.Unlock()
+
+	ret := make([]*Chunk, len(cl.chunks))
+	copy(ret, cl.chunks)
+
+	// Duplicate the last chunk
+	if cnt := len(ret); cnt > 0 {
+		ret[cnt-1] = ret[cnt-1].dupe()
+	}
+	return ret, cl.count
+}
+
+func (c *Chunk) dupe() *Chunk {
+	newChunk := make(Chunk, len(*c))
+	for idx, ptr := range *c {
+		newChunk[idx] = ptr
+	}
+	return &newChunk
+}

src/chunklist_test.go

@@ -0,0 +1,74 @@
+package fzf
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestChunkList(t *testing.T) {
+	cl := NewChunkList(func(s *string, i int) *Item {
+		return &Item{text: s, rank: Rank{0, 0, uint32(i * 2)}}
+	})
+
+	// Snapshot
+	snapshot, count := cl.Snapshot()
+	if len(snapshot) > 0 || count > 0 {
+		t.Error("Snapshot should be empty now")
+	}
+
+	// Add some data
+	cl.Push("hello")
+	cl.Push("world")
+
+	// Previously created snapshot should remain the same
+	if len(snapshot) > 0 {
+		t.Error("Snapshot should not have changed")
+	}
+
+	// But the new snapshot should contain the added items
+	snapshot, count = cl.Snapshot()
+	if len(snapshot) != 1 && count != 2 {
+		t.Error("Snapshot should not be empty now")
+	}
+
+	// Check the content of the ChunkList
+	chunk1 := snapshot[0]
+	if len(*chunk1) != 2 {
+		t.Error("Snapshot should contain only two items")
+	}
+	if *(*chunk1)[0].text != "hello" || (*chunk1)[0].rank.index != 0 ||
+		*(*chunk1)[1].text != "world" || (*chunk1)[1].rank.index != 2 {
+		t.Error("Invalid data")
+	}
+	if chunk1.IsFull() {
+		t.Error("Chunk should not have been marked full yet")
+	}
+
+	// Add more data
+	for i := 0; i < ChunkSize*2; i++ {
+		cl.Push(fmt.Sprintf("item %d", i))
+	}
+
+	// Previous snapshot should remain the same
+	if len(snapshot) != 1 {
+		t.Error("Snapshot should stay the same")
+	}
+
+	// New snapshot
+	snapshot, count = cl.Snapshot()
+	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
+		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != ChunkSize*2+2 {
+		t.Error("Expected two full chunks and one more chunk")
+	}
+	if len(*snapshot[2]) != 2 {
+		t.Error("Unexpected number of items")
+	}
+
+	cl.Push("hello")
+	cl.Push("world")
+
+	lastChunkCount := len(*snapshot[len(snapshot)-1])
+	if lastChunkCount != 2 {
+		t.Error("Unexpected number of items:", lastChunkCount)
+	}
+}

src/constants.go

@@ -0,0 +1,18 @@
+package fzf
+
+import (
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Current version
+const Version = "0.9.4"
+
+// fzf events
+const (
+	EvtReadNew util.EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtClose
+)

src/core.go

@@ -0,0 +1,213 @@
+/*
+Package fzf implements fzf, a command-line fuzzy finder.
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const coordinatorDelayMax time.Duration = 100 * time.Millisecond
+const coordinatorDelayStep time.Duration = 10 * time.Millisecond
+
+func initProcs() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+}
+
+/*
+Reader   -> EvtReadFin
+Reader   -> EvtReadNew        -> Matcher  (restart)
+Terminal -> EvtSearchNew      -> Matcher  (restart)
+Matcher  -> EvtSearchProgress -> Terminal (update info)
+Matcher  -> EvtSearchFin      -> Terminal (update list)
+*/
+
+// Run starts fzf
+func Run(options *Options) {
+	initProcs()
+
+	opts := ParseOptions()
+
+	if opts.Version {
+		fmt.Println(Version)
+		os.Exit(0)
+	}
+
+	// Event channel
+	eventBox := util.NewEventBox()
+
+	// Chunk list
+	var chunkList *ChunkList
+	if len(opts.WithNth) == 0 {
+		chunkList = NewChunkList(func(data *string, index int) *Item {
+			return &Item{
+				text:  data,
+				index: uint32(index),
+				rank:  Rank{0, 0, uint32(index)}}
+		})
+	} else {
+		chunkList = NewChunkList(func(data *string, index int) *Item {
+			tokens := Tokenize(data, opts.Delimiter)
+			item := Item{
+				text:     Transform(tokens, opts.WithNth).whole,
+				origText: data,
+				index:    uint32(index),
+				rank:     Rank{0, 0, uint32(index)}}
+			return &item
+		})
+	}
+
+	// Reader
+	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, opts.Tac, eventBox)
+
+	// Filtering mode
+	if opts.Filter != nil {
+		if opts.PrintQuery {
+			fmt.Println(*opts.Filter)
+		}
+
+		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, _ := matcher.scan(MatchRequest{
+				chunks:  snapshot,
+				pattern: pattern})
+			for i := 0; i < merger.Length(); i++ {
+				fmt.Println(merger.Get(i).AsString())
+			}
+		}
+		os.Exit(0)
+	}
+
+	// Synchronous search
+	if opts.Sync {
+		eventBox.Unwatch(EvtReadNew)
+		eventBox.WaitFor(EvtReadFin)
+	}
+
+	// Go interactive
+	go matcher.Loop()
+
+	// Terminal I/O
+	terminal := NewTerminal(opts, eventBox)
+	deferred := opts.Select1 || opts.Exit0
+	go terminal.Loop()
+	if !deferred {
+		terminal.startChan <- true
+	}
+
+	// Event coordination
+	reading := true
+	ticks := 0
+	eventBox.Watch(EvtReadNew)
+	for {
+		delay := true
+		ticks++
+		eventBox.Wait(func(events *util.Events) {
+			defer events.Clear()
+			for evt, value := range *events {
+				switch evt {
+
+				case EvtReadNew, EvtReadFin:
+					reading = reading && evt == EvtReadNew
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading)
+					matcher.Reset(snapshot, terminal.Input(), false, !reading)
+
+				case EvtSearchNew:
+					snapshot, _ := chunkList.Snapshot()
+					matcher.Reset(snapshot, terminal.Input(), true, !reading)
+					delay = false
+
+				case EvtSearchProgress:
+					switch val := value.(type) {
+					case float32:
+						terminal.UpdateProgress(val)
+					}
+
+				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)
+					}
+				}
+			}
+		})
+		if delay && reading {
+			dur := util.DurWithin(
+				time.Duration(ticks)*coordinatorDelayStep,
+				0, coordinatorDelayMax)
+			time.Sleep(dur)
+		}
+	}
+}

src/curses/curses.go

@@ -0,0 +1,430 @@
+package curses
+
+/*
+#include <ncurses.h>
+#include <locale.h>
+#cgo LDFLAGS: -lncurses
+void swapOutput() {
+  FILE* temp = stdout;
+  stdout = stderr;
+  stderr = temp;
+}
+*/
+import "C"
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+	"unicode/utf8"
+)
+
+// Types of user action
+const (
+	Rune = iota
+
+	CtrlA
+	CtrlB
+	CtrlC
+	CtrlD
+	CtrlE
+	CtrlF
+	CtrlG
+	CtrlH
+	Tab
+	CtrlJ
+	CtrlK
+	CtrlL
+	CtrlM
+	CtrlN
+	CtrlO
+	CtrlP
+	CtrlQ
+	CtrlR
+	CtrlS
+	CtrlT
+	CtrlU
+	CtrlV
+	CtrlW
+	CtrlX
+	CtrlY
+	CtrlZ
+	ESC
+
+	Invalid
+	Mouse
+
+	BTab
+
+	Del
+	PgUp
+	PgDn
+
+	AltB
+	AltF
+	AltD
+	AltBS
+)
+
+// Pallete
+const (
+	ColNormal = iota
+	ColPrompt
+	ColMatch
+	ColCurrent
+	ColCurrentMatch
+	ColSpinner
+	ColInfo
+	ColCursor
+	ColSelected
+)
+
+const (
+	doubleClickDuration = 500 * time.Millisecond
+)
+
+type Event struct {
+	Type       int
+	Char       rune
+	MouseEvent *MouseEvent
+}
+
+type MouseEvent struct {
+	Y      int
+	X      int
+	S      int
+	Down   bool
+	Double bool
+	Mod    bool
+}
+
+var (
+	_buf          []byte
+	_in           *os.File
+	_color        func(int, bool) C.int
+	_prevDownTime time.Time
+	_prevDownY    int
+	_clickY       []int
+)
+
+func init() {
+	_prevDownTime = time.Unix(0, 0)
+	_clickY = []int{}
+}
+
+func attrColored(pair int, bold bool) C.int {
+	var attr C.int
+	if pair > ColNormal {
+		attr = C.COLOR_PAIR(C.int(pair))
+	}
+	if bold {
+		attr = attr | C.A_BOLD
+	}
+	return attr
+}
+
+func attrMono(pair int, bold bool) C.int {
+	var attr C.int
+	switch pair {
+	case ColCurrent:
+		if bold {
+			attr = C.A_REVERSE
+		}
+	case ColMatch:
+		attr = C.A_UNDERLINE
+	case ColCurrentMatch:
+		attr = C.A_UNDERLINE | C.A_REVERSE
+	}
+	if bold {
+		attr = attr | C.A_BOLD
+	}
+	return attr
+}
+
+func MaxX() int {
+	return int(C.COLS)
+}
+
+func MaxY() int {
+	return int(C.LINES)
+}
+
+func getch(nonblock bool) int {
+	b := make([]byte, 1)
+	syscall.SetNonblock(int(_in.Fd()), nonblock)
+	_, err := _in.Read(b)
+	if err != nil {
+		return -1
+	}
+	return int(b[0])
+}
+
+func Init(color bool, color256 bool, black bool, mouse bool) {
+	{
+		in, err := os.OpenFile("/dev/tty", syscall.O_RDONLY, 0)
+		if err != nil {
+			panic("Failed to open /dev/tty")
+		}
+		_in = in
+		// Break STDIN
+		// syscall.Dup2(int(in.Fd()), int(os.Stdin.Fd()))
+	}
+
+	C.swapOutput()
+
+	C.setlocale(C.LC_ALL, C.CString(""))
+	C.initscr()
+	if mouse {
+		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
+	}
+	C.cbreak()
+	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(1)
+	}()
+
+	if color {
+		C.start_color()
+		var bg C.short
+		if black {
+			bg = C.COLOR_BLACK
+		} else {
+			C.use_default_colors()
+			bg = -1
+		}
+		if color256 {
+			C.init_pair(ColPrompt, 110, bg)
+			C.init_pair(ColMatch, 108, bg)
+			C.init_pair(ColCurrent, 254, 236)
+			C.init_pair(ColCurrentMatch, 151, 236)
+			C.init_pair(ColSpinner, 148, bg)
+			C.init_pair(ColInfo, 144, bg)
+			C.init_pair(ColCursor, 161, 236)
+			C.init_pair(ColSelected, 168, 236)
+		} else {
+			C.init_pair(ColPrompt, C.COLOR_BLUE, bg)
+			C.init_pair(ColMatch, C.COLOR_GREEN, bg)
+			C.init_pair(ColCurrent, C.COLOR_YELLOW, C.COLOR_BLACK)
+			C.init_pair(ColCurrentMatch, C.COLOR_GREEN, C.COLOR_BLACK)
+			C.init_pair(ColSpinner, C.COLOR_GREEN, bg)
+			C.init_pair(ColInfo, C.COLOR_WHITE, bg)
+			C.init_pair(ColCursor, C.COLOR_RED, C.COLOR_BLACK)
+			C.init_pair(ColSelected, C.COLOR_MAGENTA, C.COLOR_BLACK)
+		}
+		_color = attrColored
+	} else {
+		_color = attrMono
+	}
+}
+
+func Close() {
+	C.endwin()
+	C.swapOutput()
+}
+
+func GetBytes() []byte {
+	c := getch(false)
+	_buf = append(_buf, byte(c))
+
+	for {
+		c = getch(true)
+		if c == -1 {
+			break
+		}
+		_buf = append(_buf, byte(c))
+	}
+
+	return _buf
+}
+
+// 27 (91 79) 77 type x y
+func mouseSequence(sz *int) Event {
+	if len(_buf) < 6 {
+		return Event{Invalid, 0, nil}
+	}
+	*sz = 6
+	switch _buf[3] {
+	case 32, 36, 40, 48, // mouse-down / shift / cmd / ctrl
+		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
+		mod := _buf[3] >= 36
+		down := _buf[3]%2 == 0
+		x := int(_buf[4] - 33)
+		y := int(_buf[5] - 33)
+		double := false
+		if down {
+			now := time.Now()
+			if now.Sub(_prevDownTime) < doubleClickDuration {
+				_clickY = append(_clickY, y)
+			} else {
+				_clickY = []int{y}
+			}
+			_prevDownTime = now
+		} else {
+			if len(_clickY) > 1 && _clickY[0] == _clickY[1] &&
+				time.Now().Sub(_prevDownTime) < doubleClickDuration {
+				double = true
+			}
+		}
+		return Event{Mouse, 0, &MouseEvent{y, x, 0, down, double, mod}}
+	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
+		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
+		mod := _buf[3] >= 100
+		s := 1 - int(_buf[3]%2)*2
+		return Event{Mouse, 0, &MouseEvent{0, 0, s, false, false, mod}}
+	}
+	return Event{Invalid, 0, nil}
+}
+
+func escSequence(sz *int) Event {
+	if len(_buf) < 2 {
+		return Event{ESC, 0, nil}
+	}
+	*sz = 2
+	switch _buf[1] {
+	case 98:
+		return Event{AltB, 0, nil}
+	case 100:
+		return Event{AltD, 0, nil}
+	case 102:
+		return Event{AltF, 0, nil}
+	case 127:
+		return Event{AltBS, 0, nil}
+	case 91, 79:
+		if len(_buf) < 3 {
+			return Event{Invalid, 0, nil}
+		}
+		*sz = 3
+		switch _buf[2] {
+		case 68:
+			return Event{CtrlB, 0, nil}
+		case 67:
+			return Event{CtrlF, 0, nil}
+		case 66:
+			return Event{CtrlJ, 0, nil}
+		case 65:
+			return Event{CtrlK, 0, nil}
+		case 90:
+			return Event{BTab, 0, nil}
+		case 72:
+			return Event{CtrlA, 0, nil}
+		case 70:
+			return Event{CtrlE, 0, nil}
+		case 77:
+			return mouseSequence(sz)
+		case 49, 50, 51, 52, 53, 54:
+			if len(_buf) < 4 {
+				return Event{Invalid, 0, nil}
+			}
+			*sz = 4
+			switch _buf[2] {
+			case 50:
+				return Event{Invalid, 0, nil} // INS
+			case 51:
+				return Event{Del, 0, nil}
+			case 52:
+				return Event{CtrlE, 0, nil}
+			case 53:
+				return Event{PgUp, 0, nil}
+			case 54:
+				return Event{PgDn, 0, nil}
+			case 49:
+				switch _buf[3] {
+				case 126:
+					return Event{CtrlA, 0, nil}
+				case 59:
+					if len(_buf) != 6 {
+						return Event{Invalid, 0, nil}
+					}
+					*sz = 6
+					switch _buf[4] {
+					case 50:
+						switch _buf[5] {
+						case 68:
+							return Event{CtrlA, 0, nil}
+						case 67:
+							return Event{CtrlE, 0, nil}
+						}
+					case 53:
+						switch _buf[5] {
+						case 68:
+							return Event{AltB, 0, nil}
+						case 67:
+							return Event{AltF, 0, nil}
+						}
+					} // _buf[4]
+				} // _buf[3]
+			} // _buf[2]
+		} // _buf[2]
+	} // _buf[1]
+	return Event{Invalid, 0, nil}
+}
+
+func GetChar() Event {
+	if len(_buf) == 0 {
+		_buf = GetBytes()
+	}
+	if len(_buf) == 0 {
+		panic("Empty _buffer")
+	}
+
+	sz := 1
+	defer func() {
+		_buf = _buf[sz:]
+	}()
+
+	switch _buf[0] {
+	case CtrlC, CtrlG, CtrlQ:
+		return Event{CtrlC, 0, nil}
+	case 127:
+		return Event{CtrlH, 0, nil}
+	case ESC:
+		return escSequence(&sz)
+	}
+
+	// CTRL-A ~ CTRL-Z
+	if _buf[0] <= CtrlZ {
+		return Event{int(_buf[0]), 0, nil}
+	}
+	r, rsz := utf8.DecodeRune(_buf)
+	sz = rsz
+	return Event{Rune, r, nil}
+}
+
+func Move(y int, x int) {
+	C.move(C.int(y), C.int(x))
+}
+
+func MoveAndClear(y int, x int) {
+	Move(y, x)
+	C.clrtoeol()
+}
+
+func Print(text string) {
+	C.addstr(C.CString(text))
+}
+
+func CPrint(pair int, bold bool, text string) {
+	attr := _color(pair, bold)
+	C.attron(attr)
+	Print(text)
+	C.attroff(attr)
+}
+
+func Clear() {
+	C.clear()
+}
+
+func Endwin() {
+	C.endwin()
+}
+
+func Refresh() {
+	C.refresh()
+}

src/fzf/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "github.com/junegunn/fzf/src"
+
+func main() {
+	fzf.Run(fzf.ParseOptions())
+}

src/item.go

@@ -0,0 +1,125 @@
+package fzf
+
+// Offset holds two 32-bit integers denoting the offsets of a matched substring
+type Offset [2]int32
+
+// Item represents each input line
+type Item struct {
+	text        *string
+	origText    *string
+	transformed *Transformed
+	index       uint32
+	offsets     []Offset
+	rank        Rank
+}
+
+// Rank is used to sort the search result
+type Rank struct {
+	matchlen uint16
+	strlen   uint16
+	index    uint32
+}
+
+// Rank calculates rank of the Item
+func (i *Item) Rank(cache bool) Rank {
+	if cache && (i.rank.matchlen > 0 || i.rank.strlen > 0) {
+		return i.rank
+	}
+	matchlen := 0
+	prevEnd := 0
+	for _, offset := range i.offsets {
+		begin := int(offset[0])
+		end := int(offset[1])
+		if prevEnd > begin {
+			begin = prevEnd
+		}
+		if end > prevEnd {
+			prevEnd = end
+		}
+		if end > begin {
+			matchlen += end - begin
+		}
+	}
+	rank := Rank{uint16(matchlen), uint16(len(*i.text)), i.index}
+	if cache {
+		i.rank = rank
+	}
+	return rank
+}
+
+// AsString returns the original string
+func (i *Item) AsString() string {
+	if i.origText != nil {
+		return *i.origText
+	}
+	return *i.text
+}
+
+// ByOrder is for sorting substring offsets
+type ByOrder []Offset
+
+func (a ByOrder) Len() int {
+	return len(a)
+}
+
+func (a ByOrder) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByOrder) Less(i, j int) bool {
+	ioff := a[i]
+	joff := a[j]
+	return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
+}
+
+// ByRelevance is for sorting Items
+type ByRelevance []*Item
+
+func (a ByRelevance) Len() int {
+	return len(a)
+}
+
+func (a ByRelevance) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevance) Less(i, j int) bool {
+	irank := a[i].Rank(true)
+	jrank := a[j].Rank(true)
+
+	return compareRanks(irank, jrank, false)
+}
+
+// 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 {
+		return false
+	}
+
+	if irank.strlen < jrank.strlen {
+		return true
+	} else if irank.strlen > jrank.strlen {
+		return false
+	}
+
+	return (irank.index <= jrank.index) != tac
+}

src/item_test.go

@@ -0,0 +1,74 @@
+package fzf
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestOffsetSort(t *testing.T) {
+	offsets := []Offset{
+		Offset{3, 5}, Offset{2, 7},
+		Offset{1, 3}, Offset{2, 9}}
+	sort.Sort(ByOrder(offsets))
+
+	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
+		offsets[1][0] != 2 || offsets[1][1] != 7 ||
+		offsets[2][0] != 2 || offsets[2][1] != 9 ||
+		offsets[3][0] != 3 || offsets[3][1] != 5 {
+		t.Error("Invalid order:", offsets)
+	}
+}
+
+func TestRankComparison(t *testing.T) {
+	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
+func TestItemRank(t *testing.T) {
+	strs := []string{"foo", "foobar", "bar", "baz"}
+	item1 := Item{text: &strs[0], index: 1, offsets: []Offset{}}
+	rank1 := item1.Rank(true)
+	if rank1.matchlen != 0 || rank1.strlen != 3 || rank1.index != 1 {
+		t.Error(item1.Rank(true))
+	}
+	// Only differ in index
+	item2 := Item{text: &strs[0], index: 0, offsets: []Offset{}}
+
+	items := []*Item{&item1, &item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item1 {
+		t.Error(items)
+	}
+
+	items = []*Item{&item2, &item1, &item1, &item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item2 ||
+		items[2] != &item1 || items[3] != &item1 {
+		t.Error(items)
+	}
+
+	// Sort by relevance
+	item3 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item4 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item5 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item6 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	items = []*Item{&item1, &item2, &item3, &item4, &item5, &item6}
+	sort.Sort(ByRelevance(items))
+	if items[0] != &item2 || items[1] != &item1 ||
+		items[2] != &item6 || items[3] != &item4 ||
+		items[4] != &item5 || items[5] != &item3 {
+		t.Error(items)
+	}
+}

src/matcher.go

@@ -0,0 +1,218 @@
+package fzf
+
+import (
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// MatchRequest represents a search request
+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
+	mergerCache    map[string]*Merger
+}
+
+const (
+	reqRetry util.EventType = iota
+	reqReset
+)
+
+const (
+	progressMinDuration = 200 * time.Millisecond
+)
+
+// NewMatcher returns a new Matcher
+func NewMatcher(patternBuilder func([]rune) *Pattern,
+	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
+	return &Matcher{
+		patternBuilder: patternBuilder,
+		sort:           sort,
+		tac:            tac,
+		eventBox:       eventBox,
+		reqBox:         util.NewEventBox(),
+		partitions:     runtime.NumCPU(),
+		mergerCache:    make(map[string]*Merger)}
+}
+
+// Loop puts Matcher in action
+func (m *Matcher) Loop() {
+	prevCount := 0
+
+	for {
+		var request MatchRequest
+
+		m.reqBox.Wait(func(events *util.Events) {
+			for _, val := range *events {
+				switch val := val.(type) {
+				case MatchRequest:
+					request = val
+				default:
+					panic(fmt.Sprintf("Unexpected type: %T", val))
+				}
+			}
+			events.Clear()
+		})
+
+		// Restart search
+		patternString := request.pattern.AsString()
+		var merger *Merger
+		cancelled := false
+		count := CountItems(request.chunks)
+
+		foundCache := false
+		if count == prevCount {
+			// Look up mergerCache
+			if cached, found := m.mergerCache[patternString]; found {
+				foundCache = true
+				merger = cached
+			}
+		} else {
+			// Invalidate mergerCache
+			prevCount = count
+			m.mergerCache = make(map[string]*Merger)
+		}
+
+		if !foundCache {
+			merger, cancelled = m.scan(request)
+		}
+
+		if !cancelled {
+			m.mergerCache[patternString] = merger
+			merger.final = request.final
+			m.eventBox.Set(EvtSearchFin, merger)
+		}
+	}
+}
+
+func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
+	perSlice := len(chunks) / m.partitions
+
+	// No need to parallelize
+	if perSlice == 0 {
+		return [][]*Chunk{chunks}
+	}
+
+	slices := make([][]*Chunk, m.partitions)
+	for i := 0; i < m.partitions; i++ {
+		start := i * perSlice
+		end := start + perSlice
+		if i == m.partitions-1 {
+			end = len(chunks)
+		}
+		slices[i] = chunks[start:end]
+	}
+	return slices
+}
+
+type partialResult struct {
+	index   int
+	matches []*Item
+}
+
+func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
+	startedAt := time.Now()
+
+	numChunks := len(request.chunks)
+	if numChunks == 0 {
+		return EmptyMerger, false
+	}
+	pattern := request.pattern
+	empty := pattern.IsEmpty()
+	cancelled := util.NewAtomicBool(false)
+
+	slices := m.sliceChunks(request.chunks)
+	numSlices := len(slices)
+	resultChan := make(chan partialResult, numSlices)
+	countChan := make(chan int, numChunks)
+	waitGroup := sync.WaitGroup{}
+
+	for idx, chunks := range slices {
+		waitGroup.Add(1)
+		go func(idx int, chunks []*Chunk) {
+			defer func() { waitGroup.Done() }()
+			sliceMatches := []*Item{}
+			for _, chunk := range chunks {
+				var matches []*Item
+				if empty {
+					matches = *chunk
+				} else {
+					matches = request.pattern.Match(chunk)
+				}
+				sliceMatches = append(sliceMatches, matches...)
+				if cancelled.Get() {
+					return
+				}
+				countChan <- len(matches)
+			}
+			if !empty && m.sort {
+				if m.tac {
+					sort.Sort(ByRelevanceTac(sliceMatches))
+				} else {
+					sort.Sort(ByRelevance(sliceMatches))
+				}
+			}
+			resultChan <- partialResult{idx, sliceMatches}
+		}(idx, chunks)
+	}
+
+	wait := func() bool {
+		cancelled.Set(true)
+		waitGroup.Wait()
+		return true
+	}
+
+	count := 0
+	matchCount := 0
+	for matchesInChunk := range countChan {
+		count++
+		matchCount += matchesInChunk
+
+		if count == numChunks {
+			break
+		}
+
+		if !empty && m.reqBox.Peek(reqReset) {
+			return nil, wait()
+		}
+
+		if time.Now().Sub(startedAt) > progressMinDuration {
+			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
+		}
+	}
+
+	partialResults := make([][]*Item, numSlices)
+	for range slices {
+		partialResult := <-resultChan
+		partialResults[partialResult.index] = partialResult.matches
+	}
+	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, final bool) {
+	pattern := m.patternBuilder(patternRunes)
+
+	var event util.EventType
+	if cancel {
+		event = reqReset
+	} else {
+		event = reqRetry
+	}
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final})
+}

src/merger.go

@@ -0,0 +1,90 @@
+package fzf
+
+import "fmt"
+
+// Merger with no data
+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
+type Merger struct {
+	lists   [][]*Item
+	merged  []*Item
+	cursors []int
+	sorted  bool
+	tac     bool
+	final   bool
+	count   int
+}
+
+// NewMerger returns a new 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 {
+		mg.count += len(list)
+	}
+	return &mg
+}
+
+// Length returns the number of items
+func (mg *Merger) Length() int {
+	return mg.count
+}
+
+// Get returns the pointer to the Item object indexed by the given integer
+func (mg *Merger) Get(idx int) *Item {
+	if mg.sorted {
+		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 {
+	for i := len(mg.merged); i <= idx; i++ {
+		minRank := Rank{0, 0, 0}
+		minIdx := -1
+		for listIdx, list := range mg.lists {
+			cursor := mg.cursors[listIdx]
+			if cursor < 0 || cursor == len(list) {
+				mg.cursors[listIdx] = -1
+				continue
+			}
+			if cursor >= 0 {
+				rank := list[cursor].Rank(false)
+				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
+					minRank = rank
+					minIdx = listIdx
+				}
+			}
+			mg.cursors[listIdx] = cursor
+		}
+
+		if minIdx >= 0 {
+			chosen := mg.lists[minIdx]
+			mg.merged = append(mg.merged, chosen[mg.cursors[minIdx]])
+			mg.cursors[minIdx]++
+		} else {
+			panic(fmt.Sprintf("Index out of bounds (sorted, %d/%d)", i, mg.count))
+		}
+	}
+	return mg.merged[idx]
+}

src/merger_test.go

@@ -0,0 +1,93 @@
+package fzf
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+	"testing"
+)
+
+func assert(t *testing.T, cond bool, msg ...string) {
+	if !cond {
+		t.Error(msg)
+	}
+}
+
+func randItem() *Item {
+	str := fmt.Sprintf("%d", rand.Uint32())
+	offsets := make([]Offset, rand.Int()%3)
+	for idx := range offsets {
+		sidx := int32(rand.Uint32() % 20)
+		eidx := sidx + int32(rand.Uint32()%20)
+		offsets[idx] = Offset{sidx, eidx}
+	}
+	return &Item{
+		text:    &str,
+		index:   rand.Uint32(),
+		offsets: offsets}
+}
+
+func TestEmptyMerger(t *testing.T) {
+	assert(t, EmptyMerger.Length() == 0, "Not empty")
+	assert(t, EmptyMerger.count == 0, "Invalid count")
+	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
+}
+
+func buildLists(partiallySorted bool) ([][]*Item, []*Item) {
+	numLists := 4
+	lists := make([][]*Item, numLists)
+	cnt := 0
+	for i := 0; i < numLists; i++ {
+		numItems := rand.Int() % 20
+		cnt += numItems
+		lists[i] = make([]*Item, numItems)
+		for j := 0; j < numItems; j++ {
+			item := randItem()
+			lists[i][j] = item
+		}
+		if partiallySorted {
+			sort.Sort(ByRelevance(lists[i]))
+		}
+	}
+	items := []*Item{}
+	for _, list := range lists {
+		items = append(items, list...)
+	}
+	return lists, items
+}
+
+func TestMergerUnsorted(t *testing.T) {
+	lists, items := buildLists(false)
+	cnt := len(items)
+
+	// Not sorted: same order
+	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")
+	}
+}
+
+func TestMergerSorted(t *testing.T) {
+	lists, items := buildLists(true)
+	cnt := len(items)
+
+	// Sorted sorted order
+	mg := NewMerger(lists, true, false)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	sort.Sort(ByRelevance(items))
+	for i := 0; i < cnt; i++ {
+		if items[i] != mg.Get(i) {
+			t.Error("Not sorted", items[i], mg.Get(i))
+		}
+	}
+
+	// Inverse order
+	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

@@ -0,0 +1,310 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/junegunn/go-shellwords"
+)
+
+const usage = `usage: fzf [options]
+
+  Search mode
+    -x, --extended        Extended-search mode
+    -e, --extended-exact  Extended-search mode (exact match)
+    -i                    Case-insensitive match (default: smart-case match)
+    +i                    Case-sensitive match
+    -n, --nth=N[,..]      Comma-separated list of field index expressions
+                          for limiting search scope. Each can be a non-zero
+                          integer or a range expression ([BEGIN]..[END])
+        --with-nth=N[,..] Transform the item using index expressions for search
+    -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
+
+  Search result
+    +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
+        --no-mouse        Disable mouse
+    +c, --no-color        Disable colors
+    +2, --no-256          Disable 256-color
+        --black           Use black background
+        --reverse         Reverse orientation
+        --prompt=STR      Input prompt (default: '> ')
+
+  Scripting
+    -q, --query=STR       Start the finder with the given query
+    -1, --select-1        Automatically select the only match
+    -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')
+
+`
+
+// 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
+
+// Case-sensitivities
+const (
+	CaseSmart Case = iota
+	CaseIgnore
+	CaseRespect
+)
+
+// Options stores the values of command-line options
+type Options struct {
+	Mode       Mode
+	Case       Case
+	Nth        []Range
+	WithNth    []Range
+	Delimiter  *regexp.Regexp
+	Sort       int
+	Tac        bool
+	Multi      bool
+	Mouse      bool
+	Color      bool
+	Color256   bool
+	Black      bool
+	Reverse    bool
+	Prompt     string
+	Query      string
+	Select1    bool
+	Exit0      bool
+	Filter     *string
+	PrintQuery bool
+	Sync       bool
+	Version    bool
+}
+
+func defaultOptions() *Options {
+	return &Options{
+		Mode:       ModeFuzzy,
+		Case:       CaseSmart,
+		Nth:        make([]Range, 0),
+		WithNth:    make([]Range, 0),
+		Delimiter:  nil,
+		Sort:       1000,
+		Tac:        false,
+		Multi:      false,
+		Mouse:      true,
+		Color:      true,
+		Color256:   strings.Contains(os.Getenv("TERM"), "256"),
+		Black:      false,
+		Reverse:    false,
+		Prompt:     "> ",
+		Query:      "",
+		Select1:    false,
+		Exit0:      false,
+		Filter:     nil,
+		PrintQuery: false,
+		Sync:       false,
+		Version:    false}
+}
+
+func help(ok int) {
+	os.Stderr.WriteString(usage)
+	os.Exit(ok)
+}
+
+func errorExit(msg string) {
+	os.Stderr.WriteString(msg + "\n")
+	help(1)
+}
+
+func optString(arg string, prefix string) (bool, string) {
+	rx, _ := regexp.Compile(fmt.Sprintf("^(?:%s)(.*)$", prefix))
+	matches := rx.FindStringSubmatch(arg)
+	if len(matches) > 1 {
+		return true, matches[1]
+	}
+	return false, ""
+}
+
+func nextString(args []string, i *int, message string) string {
+	if len(args) > *i+1 {
+		*i++
+	} else {
+		errorExit(message)
+	}
+	return args[*i]
+}
+
+func optionalNumeric(args []string, i *int) int {
+	if len(args) > *i+1 {
+		if strings.IndexAny(args[*i+1], "0123456789") == 0 {
+			*i++
+		}
+	}
+	return 1 // Don't care
+}
+
+func splitNth(str string) []Range {
+	if match, _ := regexp.MatchString("^[0-9,-.]+$", str); !match {
+		errorExit("invalid format: " + str)
+	}
+
+	tokens := strings.Split(str, ",")
+	ranges := make([]Range, len(tokens))
+	for idx, s := range tokens {
+		r, ok := ParseRange(&s)
+		if !ok {
+			errorExit("invalid format: " + str)
+		}
+		ranges[idx] = r
+	}
+	return ranges
+}
+
+func delimiterRegexp(str string) *regexp.Regexp {
+	rx, e := regexp.Compile(str)
+	if e != nil {
+		str = regexp.QuoteMeta(str)
+	}
+
+	rx, e = regexp.Compile(fmt.Sprintf("(?:.*?%s)|(?:.+?$)", str))
+	if e != nil {
+		errorExit("invalid regular expression: " + e.Error())
+	}
+	return rx
+}
+
+func parseOptions(opts *Options, allArgs []string) {
+	for i := 0; i < len(allArgs); i++ {
+		arg := allArgs[i]
+		switch arg {
+		case "-h", "--help":
+			help(0)
+		case "-x", "--extended":
+			opts.Mode = ModeExtended
+		case "-e", "--extended-exact":
+			opts.Mode = ModeExtendedExact
+		case "+x", "--no-extended", "+e", "--no-extended-exact":
+			opts.Mode = ModeFuzzy
+		case "-q", "--query":
+			opts.Query = nextString(allArgs, &i, "query string required")
+		case "-f", "--filter":
+			filter := nextString(allArgs, &i, "query string required")
+			opts.Filter = &filter
+		case "-d", "--delimiter":
+			opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
+		case "-n", "--nth":
+			opts.Nth = splitNth(nextString(allArgs, &i, "nth expression required"))
+		case "--with-nth":
+			opts.WithNth = splitNth(nextString(allArgs, &i, "nth expression required"))
+		case "-s", "--sort":
+			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":
+			opts.Case = CaseRespect
+		case "-m", "--multi":
+			opts.Multi = true
+		case "+m", "--no-multi":
+			opts.Multi = false
+		case "--no-mouse":
+			opts.Mouse = false
+		case "+c", "--no-color":
+			opts.Color = false
+		case "+2", "--no-256":
+			opts.Color256 = false
+		case "--black":
+			opts.Black = true
+		case "--no-black":
+			opts.Black = false
+		case "--reverse":
+			opts.Reverse = true
+		case "--no-reverse":
+			opts.Reverse = false
+		case "-1", "--select-1":
+			opts.Select1 = true
+		case "+1", "--no-select-1":
+			opts.Select1 = false
+		case "-0", "--exit-0":
+			opts.Exit0 = true
+		case "+0", "--no-exit-0":
+			opts.Exit0 = false
+		case "--print-query":
+			opts.PrintQuery = true
+		case "--no-print-query":
+			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:
+			if match, value := optString(arg, "-q|--query="); match {
+				opts.Query = value
+			} else if match, value := optString(arg, "-f|--filter="); match {
+				opts.Filter = &value
+			} else if match, value := optString(arg, "-d|--delimiter="); match {
+				opts.Delimiter = delimiterRegexp(value)
+			} else if match, value := optString(arg, "--prompt="); match {
+				opts.Prompt = value
+			} else if match, value := optString(arg, "-n|--nth="); match {
+				opts.Nth = splitNth(value)
+			} else if match, value := optString(arg, "--with-nth="); match {
+				opts.WithNth = splitNth(value)
+			} else if match, _ := optString(arg, "-s|--sort="); match {
+				opts.Sort = 1 // Don't care
+			} else {
+				errorExit("unknown option: " + arg)
+			}
+		}
+	}
+
+	// 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 {
+		for _, r := range opts.Nth {
+			if r.begin == rangeEllipsis && r.end == rangeEllipsis {
+				opts.Nth = make([]Range, 0)
+				return
+			}
+		}
+	}
+}
+
+// ParseOptions parses command-line options
+func ParseOptions() *Options {
+	opts := defaultOptions()
+
+	// Options from Env var
+	words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
+	parseOptions(opts, words)
+
+	// Options from command-line arguments
+	parseOptions(opts, os.Args[1:])
+	return opts
+}

src/options_test.go

@@ -0,0 +1,67 @@
+package fzf
+
+import "testing"
+
+func TestDelimiterRegex(t *testing.T) {
+	rx := delimiterRegexp("*")
+	tokens := rx.FindAllString("-*--*---**---", -1)
+	if tokens[0] != "-*" || tokens[1] != "--*" || tokens[2] != "---*" ||
+		tokens[3] != "*" || tokens[4] != "---" {
+		t.Errorf("%s %s %d", rx, tokens, len(tokens))
+	}
+}
+
+func TestSplitNth(t *testing.T) {
+	{
+		ranges := splitNth("..")
+		if len(ranges) != 1 ||
+			ranges[0].begin != rangeEllipsis ||
+			ranges[0].end != rangeEllipsis {
+			t.Errorf("%s", ranges)
+		}
+	}
+	{
+		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
+		if len(ranges) != 10 ||
+			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
+			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
+			ranges[2].begin != 2 || ranges[2].end != 3 ||
+			ranges[3].begin != 4 || ranges[3].end != rangeEllipsis ||
+			ranges[4].begin != -3 || ranges[4].end != -2 ||
+			ranges[5].begin != rangeEllipsis || ranges[5].end != rangeEllipsis ||
+			ranges[6].begin != 2 || ranges[6].end != 2 ||
+			ranges[7].begin != -2 || ranges[7].end != -2 ||
+			ranges[8].begin != 2 || ranges[8].end != -2 ||
+			ranges[9].begin != rangeEllipsis || ranges[9].end != rangeEllipsis {
+			t.Errorf("%s", ranges)
+		}
+	}
+}
+
+func TestIrrelevantNth(t *testing.T) {
+	{
+		opts := defaultOptions()
+		words := []string{"--nth", "..", "-x"}
+		parseOptions(opts, words)
+		if len(opts.Nth) != 0 {
+			t.Errorf("nth should be empty: %s", opts.Nth)
+		}
+	}
+	for _, words := range [][]string{[]string{"--nth", "..,3"}, []string{"--nth", "3,1.."}, []string{"--nth", "..-1,1"}} {
+		{
+			opts := defaultOptions()
+			parseOptions(opts, words)
+			if len(opts.Nth) != 0 {
+				t.Errorf("nth should be empty: %s", opts.Nth)
+			}
+		}
+		{
+			opts := defaultOptions()
+			words = append(words, "-x")
+			parseOptions(opts, words)
+			if len(opts.Nth) != 2 {
+				t.Errorf("nth should not be empty: %s", opts.Nth)
+			}
+		}
+	}
+}

src/pattern.go

@@ -0,0 +1,320 @@
+package fzf
+
+import (
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/junegunn/fzf/src/algo"
+)
+
+const uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+// fuzzy
+// 'exact
+// ^exact-prefix
+// exact-suffix$
+// !not-fuzzy
+// !'not-exact
+// !^not-exact-prefix
+// !not-exact-suffix$
+
+type termType int
+
+const (
+	termFuzzy termType = iota
+	termExact
+	termPrefix
+	termSuffix
+)
+
+type term struct {
+	typ      termType
+	inv      bool
+	text     []rune
+	origText []rune
+}
+
+// Pattern represents search pattern
+type Pattern struct {
+	mode          Mode
+	caseSensitive bool
+	text          []rune
+	terms         []term
+	hasInvTerm    bool
+	delimiter     *regexp.Regexp
+	nth           []Range
+	procFun       map[termType]func(bool, *string, []rune) (int, int)
+}
+
+var (
+	_patternCache map[string]*Pattern
+	_splitRegex   *regexp.Regexp
+	_cache        ChunkCache
+)
+
+func init() {
+	// We can uniquely identify the pattern for a given string since
+	// mode and caseMode do not change while the program is running
+	_patternCache = make(map[string]*Pattern)
+	_splitRegex = regexp.MustCompile("\\s+")
+	_cache = NewChunkCache()
+}
+
+func clearPatternCache() {
+	_patternCache = make(map[string]*Pattern)
+}
+
+// BuildPattern builds Pattern object from the given arguments
+func BuildPattern(mode Mode, caseMode Case,
+	nth []Range, delimiter *regexp.Regexp, runes []rune) *Pattern {
+
+	var asString string
+	switch mode {
+	case ModeExtended, ModeExtendedExact:
+		asString = strings.Trim(string(runes), " ")
+	default:
+		asString = string(runes)
+	}
+
+	cached, found := _patternCache[asString]
+	if found {
+		return cached
+	}
+
+	caseSensitive, hasInvTerm := true, false
+	terms := []term{}
+
+	switch caseMode {
+	case CaseSmart:
+		if !strings.ContainsAny(asString, uppercaseLetters) {
+			runes, caseSensitive = []rune(strings.ToLower(asString)), false
+		}
+	case CaseIgnore:
+		runes, caseSensitive = []rune(strings.ToLower(asString)), false
+	}
+
+	switch mode {
+	case ModeExtended, ModeExtendedExact:
+		terms = parseTerms(mode, string(runes))
+		for _, term := range terms {
+			if term.inv {
+				hasInvTerm = true
+			}
+		}
+	}
+
+	ptr := &Pattern{
+		mode:          mode,
+		caseSensitive: caseSensitive,
+		text:          runes,
+		terms:         terms,
+		hasInvTerm:    hasInvTerm,
+		nth:           nth,
+		delimiter:     delimiter,
+		procFun:       make(map[termType]func(bool, *string, []rune) (int, int))}
+
+	ptr.procFun[termFuzzy] = algo.FuzzyMatch
+	ptr.procFun[termExact] = algo.ExactMatchNaive
+	ptr.procFun[termPrefix] = algo.PrefixMatch
+	ptr.procFun[termSuffix] = algo.SuffixMatch
+
+	_patternCache[asString] = ptr
+	return ptr
+}
+
+func parseTerms(mode Mode, str string) []term {
+	tokens := _splitRegex.Split(str, -1)
+	terms := []term{}
+	for _, token := range tokens {
+		typ, inv, text := termFuzzy, false, token
+		origText := []rune(text)
+		if mode == ModeExtendedExact {
+			typ = termExact
+		}
+
+		if strings.HasPrefix(text, "!") {
+			inv = true
+			text = text[1:]
+		}
+
+		if strings.HasPrefix(text, "'") {
+			if mode == ModeExtended {
+				typ = termExact
+				text = text[1:]
+			}
+		} else if strings.HasPrefix(text, "^") {
+			typ = termPrefix
+			text = text[1:]
+		} else if strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
+		if len(text) > 0 {
+			terms = append(terms, term{
+				typ:      typ,
+				inv:      inv,
+				text:     []rune(text),
+				origText: origText})
+		}
+	}
+	return terms
+}
+
+// IsEmpty returns true if the pattern is effectively empty
+func (p *Pattern) IsEmpty() bool {
+	if p.mode == ModeFuzzy {
+		return len(p.text) == 0
+	}
+	return len(p.terms) == 0
+}
+
+// AsString returns the search query in string type
+func (p *Pattern) AsString() string {
+	return string(p.text)
+}
+
+// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) CacheKey() string {
+	if p.mode == ModeFuzzy {
+		return p.AsString()
+	}
+	cacheableTerms := []string{}
+	for _, term := range p.terms {
+		if term.inv {
+			continue
+		}
+		cacheableTerms = append(cacheableTerms, string(term.origText))
+	}
+	return strings.Join(cacheableTerms, " ")
+}
+
+// Match returns the list of matches Items in the given Chunk
+func (p *Pattern) Match(chunk *Chunk) []*Item {
+	space := chunk
+
+	// ChunkCache: Exact match
+	cacheKey := p.CacheKey()
+	if !p.hasInvTerm { // Because we're excluding Inv-term from cache key
+		if cached, found := _cache.Find(chunk, cacheKey); found {
+			return cached
+		}
+	}
+
+	// ChunkCache: Prefix/suffix match
+Loop:
+	for idx := 1; idx < len(cacheKey); idx++ {
+		// [---------| ] | [ |---------]
+		// [--------|  ] | [  |--------]
+		// [-------|   ] | [   |-------]
+		prefix := cacheKey[:len(cacheKey)-idx]
+		suffix := cacheKey[idx:]
+		for _, substr := range [2]*string{&prefix, &suffix} {
+			if cached, found := _cache.Find(chunk, *substr); found {
+				cachedChunk := Chunk(cached)
+				space = &cachedChunk
+				break Loop
+			}
+		}
+	}
+
+	matches := p.matchChunk(space)
+
+	if !p.hasInvTerm {
+		_cache.Add(chunk, cacheKey, matches)
+	}
+	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{
+		text:        item.text,
+		origText:    item.origText,
+		transformed: item.transformed,
+		index:       item.index,
+		offsets:     offsets,
+		rank:        Rank{0, 0, item.index}}
+}
+
+func (p *Pattern) fuzzyMatch(item *Item) (int, int) {
+	input := p.prepareInput(item)
+	return p.iter(algo.FuzzyMatch, input, p.text)
+}
+
+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
+			}
+			offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
+		} else if term.inv {
+			offsets = append(offsets, Offset{0, 0})
+		}
+	}
+	return offsets
+}
+
+func (p *Pattern) prepareInput(item *Item) *Transformed {
+	if item.transformed != nil {
+		return item.transformed
+	}
+
+	var ret *Transformed
+	if len(p.nth) > 0 {
+		tokens := Tokenize(item.text, p.delimiter)
+		ret = Transform(tokens, p.nth)
+	} else {
+		trans := Transformed{
+			whole: item.text,
+			parts: []Token{Token{text: item.text, prefixLength: 0}}}
+		ret = &trans
+	}
+	item.transformed = ret
+	return ret
+}
+
+func (p *Pattern) iter(pfun func(bool, *string, []rune) (int, int),
+	inputs *Transformed, pattern []rune) (int, int) {
+	for _, part := range inputs.parts {
+		prefixLength := part.prefixLength
+		if sidx, eidx := pfun(p.caseSensitive, part.text, pattern); sidx >= 0 {
+			return sidx + prefixLength, eidx + prefixLength
+		}
+	}
+	return -1, -1
+}

src/pattern_test.go

@@ -0,0 +1,116 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/algo"
+)
+
+func TestParseTermsExtended(t *testing.T) {
+	terms := parseTerms(ModeExtended,
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
+	if len(terms) != 8 ||
+		terms[0].typ != termFuzzy || terms[0].inv ||
+		terms[1].typ != termExact || terms[1].inv ||
+		terms[2].typ != termPrefix || terms[2].inv ||
+		terms[3].typ != termSuffix || terms[3].inv ||
+		terms[4].typ != termFuzzy || !terms[4].inv ||
+		terms[5].typ != termExact || !terms[5].inv ||
+		terms[6].typ != termPrefix || !terms[6].inv ||
+		terms[7].typ != termSuffix || !terms[7].inv {
+		t.Errorf("%s", terms)
+	}
+	for idx, term := range terms {
+		if len(term.text) != 3 {
+			t.Errorf("%s", term)
+		}
+		if idx > 0 && len(term.origText) != 4+idx/5 {
+			t.Errorf("%s", term)
+		}
+	}
+}
+
+func TestParseTermsExtendedExact(t *testing.T) {
+	terms := parseTerms(ModeExtendedExact,
+		"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[1].typ != termExact || terms[1].inv || len(terms[1].text) != 4 ||
+		terms[2].typ != termPrefix || terms[2].inv || len(terms[2].text) != 3 ||
+		terms[3].typ != termSuffix || terms[3].inv || len(terms[3].text) != 3 ||
+		terms[4].typ != termExact || !terms[4].inv || len(terms[4].text) != 3 ||
+		terms[5].typ != termExact || !terms[5].inv || len(terms[5].text) != 4 ||
+		terms[6].typ != termPrefix || !terms[6].inv || len(terms[6].text) != 3 ||
+		terms[7].typ != termSuffix || !terms[7].inv || len(terms[7].text) != 3 {
+		t.Errorf("%s", terms)
+	}
+}
+
+func TestParseTermsEmpty(t *testing.T) {
+	terms := parseTerms(ModeExtended, "' $ ^ !' !^ !$")
+	if len(terms) != 0 {
+		t.Errorf("%s", terms)
+	}
+}
+
+func TestExact(t *testing.T) {
+	defer clearPatternCache()
+	clearPatternCache()
+	pattern := BuildPattern(ModeExtended, CaseSmart,
+		[]Range{}, nil, []rune("'abc"))
+	str := "aabbcc abc"
+	sidx, eidx := algo.ExactMatchNaive(pattern.caseSensitive, &str, pattern.terms[0].text)
+	if sidx != 7 || eidx != 10 {
+		t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
+	}
+}
+
+func TestCaseSensitivity(t *testing.T) {
+	defer clearPatternCache()
+	clearPatternCache()
+	pat1 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat2 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("Abc"))
+	clearPatternCache()
+	pat3 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat4 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("Abc"))
+	clearPatternCache()
+	pat5 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("abc"))
+	clearPatternCache()
+	pat6 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("Abc"))
+
+	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
+		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
+		string(pat3.text) != "abc" || pat3.caseSensitive != false ||
+		string(pat4.text) != "abc" || pat4.caseSensitive != false ||
+		string(pat5.text) != "abc" || pat5.caseSensitive != true ||
+		string(pat6.text) != "Abc" || pat6.caseSensitive != true {
+		t.Error("Invalid case conversion")
+	}
+}
+
+func TestOrigTextAndTransformed(t *testing.T) {
+	strptr := func(str string) *string {
+		return &str
+	}
+	pattern := BuildPattern(ModeExtended, CaseSmart, []Range{}, nil, []rune("jg"))
+	tokens := Tokenize(strptr("junegunn"), nil)
+	trans := Transform(tokens, []Range{Range{1, 1}})
+
+	for _, mode := range []Mode{ModeFuzzy, ModeExtended} {
+		chunk := Chunk{
+			&Item{
+				text:        strptr("junegunn"),
+				origText:    strptr("junegunn.choi"),
+				transformed: trans},
+		}
+		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 {
+			t.Error("Invalid match result", matches)
+		}
+	}
+}

src/reader.go

@@ -0,0 +1,59 @@
+package fzf
+
+import (
+	"bufio"
+	"io"
+	"os"
+	"os/exec"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const defaultCommand = `find * -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null`
+
+// Reader reads from command or standard input
+type Reader struct {
+	pusher   func(string)
+	eventBox *util.EventBox
+}
+
+// ReadSource reads data from the default command or from standard input
+func (r *Reader) ReadSource() {
+	if util.IsTty() {
+		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
+		if len(cmd) == 0 {
+			cmd = defaultCommand
+		}
+		r.readFromCommand(cmd)
+	} else {
+		r.readFromStdin()
+	}
+	r.eventBox.Set(EvtReadFin, nil)
+}
+
+func (r *Reader) feed(src io.Reader) {
+	if scanner := bufio.NewScanner(src); scanner != nil {
+		for scanner.Scan() {
+			r.pusher(scanner.Text())
+			r.eventBox.Set(EvtReadNew, nil)
+		}
+	}
+}
+
+func (r *Reader) readFromStdin() {
+	r.feed(os.Stdin)
+}
+
+func (r *Reader) readFromCommand(cmd string) {
+	listCommand := exec.Command("sh", "-c", cmd)
+	out, err := listCommand.StdoutPipe()
+	if err != nil {
+		return
+	}
+	err = listCommand.Start()
+	if err != nil {
+		return
+	}
+	defer listCommand.Wait()
+	r.feed(out)
+}

src/reader_test.go

@@ -0,0 +1,56 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestReadFromCommand(t *testing.T) {
+	strs := []string{}
+	eb := util.NewEventBox()
+	reader := Reader{
+		pusher:   func(s string) { strs = append(strs, s) },
+		eventBox: eb}
+
+	// Check EventBox
+	if eb.Peek(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Normal command
+	reader.readFromCommand(`echo abc && echo def`)
+	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	if !eb.Peek(EvtReadNew) {
+		t.Error("EvtReadNew should be set yet")
+	}
+
+	// Wait should return immediately
+	eb.Wait(func(events *util.Events) {
+		if _, found := (*events)[EvtReadNew]; !found {
+			t.Errorf("%s", events)
+		}
+		events.Clear()
+	})
+
+	// EventBox is cleared
+	if eb.Peek(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Failing command
+	reader.readFromCommand(`no-such-command`)
+	strs = []string{}
+	if len(strs) > 0 {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	if eb.Peek(EvtReadNew) {
+		t.Error("Command failed. EvtReadNew should be set")
+	}
+}

src/terminal.go

@@ -0,0 +1,709 @@
+package fzf
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/signal"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	C "github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/util"
+
+	"github.com/junegunn/go-runewidth"
+)
+
+// Terminal represents terminal input/output
+type Terminal struct {
+	prompt     string
+	reverse    bool
+	cx         int
+	cy         int
+	offset     int
+	yanked     []rune
+	input      []rune
+	multi      bool
+	printQuery bool
+	count      int
+	progress   int
+	reading    bool
+	merger     *Merger
+	selected   map[*string]selectedItem
+	reqBox     *util.EventBox
+	eventBox   *util.EventBox
+	mutex      sync.Mutex
+	initFunc   func()
+	suppress   bool
+	startChan  chan bool
+}
+
+type selectedItem struct {
+	at   time.Time
+	text *string
+}
+
+type ByTimeOrder []selectedItem
+
+func (a ByTimeOrder) Len() int {
+	return len(a)
+}
+
+func (a ByTimeOrder) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByTimeOrder) Less(i, j int) bool {
+	return a[i].at.Before(a[j].at)
+}
+
+var _spinner = []string{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
+var _runeWidths = make(map[rune]int)
+
+const (
+	reqPrompt util.EventType = iota
+	reqInfo
+	reqList
+	reqRefresh
+	reqRedraw
+	reqClose
+	reqQuit
+)
+
+const (
+	initialDelay    = 100 * time.Millisecond
+	spinnerDuration = 200 * time.Millisecond
+)
+
+// NewTerminal returns new Terminal object
+func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
+	input := []rune(opts.Query)
+	return &Terminal{
+		prompt:     opts.Prompt,
+		reverse:    opts.Reverse,
+		cx:         len(input),
+		cy:         0,
+		offset:     0,
+		yanked:     []rune{},
+		input:      input,
+		multi:      opts.Multi,
+		printQuery: opts.PrintQuery,
+		merger:     EmptyMerger,
+		selected:   make(map[*string]selectedItem),
+		reqBox:     util.NewEventBox(),
+		eventBox:   eventBox,
+		mutex:      sync.Mutex{},
+		suppress:   true,
+		startChan:  make(chan bool, 1),
+		initFunc: func() {
+			C.Init(opts.Color, opts.Color256, opts.Black, opts.Mouse)
+		}}
+}
+
+// Input returns current query string
+func (t *Terminal) Input() []rune {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	return copySlice(t.input)
+}
+
+// UpdateCount updates the count information
+func (t *Terminal) UpdateCount(cnt int, final bool) {
+	t.mutex.Lock()
+	t.count = cnt
+	t.reading = !final
+	t.mutex.Unlock()
+	t.reqBox.Set(reqInfo, nil)
+	if final {
+		t.reqBox.Set(reqRefresh, nil)
+	}
+}
+
+// UpdateProgress updates the search progress
+func (t *Terminal) UpdateProgress(progress float32) {
+	t.mutex.Lock()
+	newProgress := int(progress * 100)
+	changed := t.progress != newProgress
+	t.progress = newProgress
+	t.mutex.Unlock()
+
+	if changed {
+		t.reqBox.Set(reqInfo, nil)
+	}
+}
+
+// UpdateList updates Merger to display the list
+func (t *Terminal) UpdateList(merger *Merger) {
+	t.mutex.Lock()
+	t.progress = 100
+	t.merger = merger
+	t.mutex.Unlock()
+	t.reqBox.Set(reqInfo, nil)
+	t.reqBox.Set(reqList, nil)
+}
+
+func (t *Terminal) output() {
+	if t.printQuery {
+		fmt.Println(string(t.input))
+	}
+	if len(t.selected) == 0 {
+		cnt := t.merger.Length()
+		if cnt > 0 && cnt > t.cy {
+			fmt.Println(t.merger.Get(t.cy).AsString())
+		}
+	} else {
+		sels := make([]selectedItem, 0, len(t.selected))
+		for _, sel := range t.selected {
+			sels = append(sels, sel)
+		}
+		sort.Sort(ByTimeOrder(sels))
+		for _, sel := range sels {
+			fmt.Println(*sel.text)
+		}
+	}
+}
+
+func runeWidth(r rune, prefixWidth int) int {
+	if r == '\t' {
+		return 8 - prefixWidth%8
+	} else if w, found := _runeWidths[r]; found {
+		return w
+	} else {
+		w := runewidth.RuneWidth(r)
+		_runeWidths[r] = w
+		return w
+	}
+}
+
+func displayWidth(runes []rune) int {
+	l := 0
+	for _, r := range runes {
+		l += runeWidth(r, l)
+	}
+	return l
+}
+
+func (t *Terminal) move(y int, x int, clear bool) {
+	maxy := C.MaxY()
+	if !t.reverse {
+		y = maxy - y - 1
+	}
+
+	if clear {
+		C.MoveAndClear(y, x)
+	} else {
+		C.Move(y, x)
+	}
+}
+
+func (t *Terminal) placeCursor() {
+	t.move(0, len(t.prompt)+displayWidth(t.input[:t.cx]), false)
+}
+
+func (t *Terminal) printPrompt() {
+	t.move(0, 0, true)
+	C.CPrint(C.ColPrompt, true, t.prompt)
+	C.CPrint(C.ColNormal, true, string(t.input))
+}
+
+func (t *Terminal) printInfo() {
+	t.move(1, 0, true)
+	if t.reading {
+		duration := int64(spinnerDuration)
+		idx := (time.Now().UnixNano() % (duration * int64(len(_spinner)))) / duration
+		C.CPrint(C.ColSpinner, true, _spinner[idx])
+	}
+
+	t.move(1, 2, false)
+	output := fmt.Sprintf("%d/%d", t.merger.Length(), t.count)
+	if t.multi && len(t.selected) > 0 {
+		output += fmt.Sprintf(" (%d)", len(t.selected))
+	}
+	if t.progress > 0 && t.progress < 100 {
+		output += fmt.Sprintf(" (%d%%)", t.progress)
+	}
+	C.CPrint(C.ColInfo, false, output)
+}
+
+func (t *Terminal) printList() {
+	t.constrain()
+
+	maxy := maxItems()
+	count := t.merger.Length() - t.offset
+	for i := 0; i < maxy; i++ {
+		t.move(i+2, 0, true)
+		if i < count {
+			t.printItem(t.merger.Get(i+t.offset), i == t.cy-t.offset)
+		}
+	}
+}
+
+func (t *Terminal) printItem(item *Item, current bool) {
+	_, selected := t.selected[item.text]
+	if current {
+		C.CPrint(C.ColCursor, true, ">")
+		if selected {
+			C.CPrint(C.ColCurrent, true, ">")
+		} else {
+			C.CPrint(C.ColCurrent, true, " ")
+		}
+		t.printHighlighted(item, true, C.ColCurrent, C.ColCurrentMatch)
+	} else {
+		C.CPrint(C.ColCursor, true, " ")
+		if selected {
+			C.CPrint(C.ColSelected, true, ">")
+		} else {
+			C.Print(" ")
+		}
+		t.printHighlighted(item, false, 0, C.ColMatch)
+	}
+}
+
+func trimRight(runes []rune, width int) ([]rune, int) {
+	// We start from the beginning to handle tab characters
+	l := 0
+	for idx, r := range runes {
+		l += runeWidth(r, l)
+		if idx > 0 && l > width {
+			return runes[:idx], len(runes) - idx
+		}
+	}
+	return runes, 0
+}
+
+func displayWidthWithLimit(runes []rune, prefixWidth int, limit int) int {
+	l := 0
+	for _, r := range runes {
+		l += runeWidth(r, l+prefixWidth)
+		if l > limit {
+			// Early exit
+			return l
+		}
+	}
+	return l
+}
+
+func trimLeft(runes []rune, width int) ([]rune, int32) {
+	currentWidth := displayWidth(runes)
+	var trimmed int32
+
+	for currentWidth > width && len(runes) > 0 {
+		runes = runes[1:]
+		trimmed++
+		currentWidth = displayWidthWithLimit(runes, 2, width)
+	}
+	return runes, trimmed
+}
+
+func (*Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int) {
+	var maxe int32
+	for _, offset := range item.offsets {
+		if offset[1] > maxe {
+			maxe = offset[1]
+		}
+	}
+
+	// Overflow
+	text := []rune(*item.text)
+	offsets := item.offsets
+	maxWidth := C.MaxX() - 3
+	fullWidth := displayWidth(text)
+	if fullWidth > maxWidth {
+		// Stri..
+		matchEndWidth := displayWidth(text[:maxe])
+		if matchEndWidth <= maxWidth-2 {
+			text, _ = trimRight(text, maxWidth-2)
+			text = append(text, []rune("..")...)
+		} else {
+			// Stri..
+			if matchEndWidth < fullWidth-2 {
+				text = append(text[:maxe], []rune("..")...)
+			}
+			// ..ri..
+			var diff int32
+			text, diff = trimLeft(text, maxWidth-2)
+
+			// Transform offsets
+			offsets = make([]Offset, len(item.offsets))
+			for idx, offset := range item.offsets {
+				b, e := offset[0], offset[1]
+				b += 2 - diff
+				e += 2 - diff
+				b = util.Max32(b, 2)
+				if b < e {
+					offsets[idx] = Offset{b, e}
+				}
+			}
+			text = append([]rune(".."), text...)
+		}
+	}
+
+	sort.Sort(ByOrder(offsets))
+	var index int32
+	var substr string
+	var prefixWidth int
+	for _, offset := range offsets {
+		b := util.Max32(index, offset[0])
+		e := util.Max32(index, offset[1])
+
+		substr, prefixWidth = processTabs(text[index:b], prefixWidth)
+		C.CPrint(col1, bold, substr)
+
+		substr, prefixWidth = processTabs(text[b:e], prefixWidth)
+		C.CPrint(col2, bold, substr)
+
+		index = e
+	}
+	if index < int32(len(text)) {
+		substr, _ = processTabs(text[index:], prefixWidth)
+		C.CPrint(col1, bold, substr)
+	}
+}
+
+func processTabs(runes []rune, prefixWidth int) (string, int) {
+	var strbuf bytes.Buffer
+	l := prefixWidth
+	for _, r := range runes {
+		w := runeWidth(r, l)
+		l += w
+		if r == '\t' {
+			strbuf.WriteString(strings.Repeat(" ", w))
+		} else {
+			strbuf.WriteRune(r)
+		}
+	}
+	return strbuf.String(), l
+}
+
+func (t *Terminal) printAll() {
+	t.printList()
+	t.printInfo()
+	t.printPrompt()
+}
+
+func (t *Terminal) refresh() {
+	if !t.suppress {
+		C.Refresh()
+	}
+}
+
+func (t *Terminal) delChar() bool {
+	if len(t.input) > 0 && t.cx < len(t.input) {
+		t.input = append(t.input[:t.cx], t.input[t.cx+1:]...)
+		return true
+	}
+	return false
+}
+
+func findLastMatch(pattern string, str string) int {
+	rx, err := regexp.Compile(pattern)
+	if err != nil {
+		return -1
+	}
+	locs := rx.FindAllStringIndex(str, -1)
+	if locs == nil {
+		return -1
+	}
+	return locs[len(locs)-1][0]
+}
+
+func findFirstMatch(pattern string, str string) int {
+	rx, err := regexp.Compile(pattern)
+	if err != nil {
+		return -1
+	}
+	loc := rx.FindStringIndex(str)
+	if loc == nil {
+		return -1
+	}
+	return loc[0]
+}
+
+func copySlice(slice []rune) []rune {
+	ret := make([]rune, len(slice))
+	copy(ret, slice)
+	return ret
+}
+
+func (t *Terminal) rubout(pattern string) {
+	pcx := t.cx
+	after := t.input[t.cx:]
+	t.cx = findLastMatch(pattern, string(t.input[:t.cx])) + 1
+	t.yanked = copySlice(t.input[t.cx:pcx])
+	t.input = append(t.input[:t.cx], after...)
+}
+
+// Loop is called to start Terminal I/O
+func (t *Terminal) Loop() {
+	<-t.startChan
+	{ // Late initialization
+		t.mutex.Lock()
+		t.initFunc()
+		t.printPrompt()
+		t.placeCursor()
+		C.Refresh()
+		t.printInfo()
+		t.mutex.Unlock()
+		go func() {
+			timer := time.NewTimer(initialDelay)
+			<-timer.C
+			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)
+			}
+		}()
+	}
+
+	go func() {
+		for {
+			t.reqBox.Wait(func(events *util.Events) {
+				defer events.Clear()
+				t.mutex.Lock()
+				for req := range *events {
+					switch req {
+					case reqPrompt:
+						t.printPrompt()
+					case reqInfo:
+						t.printInfo()
+					case reqList:
+						t.printList()
+					case reqRefresh:
+						t.suppress = false
+					case reqRedraw:
+						C.Clear()
+						C.Endwin()
+						C.Refresh()
+						t.printAll()
+					case reqClose:
+						C.Close()
+						t.output()
+						os.Exit(0)
+					case reqQuit:
+						C.Close()
+						os.Exit(1)
+					}
+				}
+				t.placeCursor()
+				t.mutex.Unlock()
+			})
+			t.refresh()
+		}
+	}()
+
+	looping := true
+	for looping {
+		event := C.GetChar()
+
+		t.mutex.Lock()
+		previousInput := t.input
+		events := []util.EventType{reqPrompt}
+		req := func(evts ...util.EventType) {
+			for _, event := range evts {
+				events = append(events, event)
+				if event == reqClose || event == reqQuit {
+					looping = false
+				}
+			}
+		}
+		toggle := func() {
+			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 {
+						strptr = item.origText
+					} else {
+						strptr = item.text
+					}
+					t.selected[item.text] = selectedItem{time.Now(), strptr}
+				} else {
+					delete(t.selected, item.text)
+				}
+				req(reqInfo)
+			}
+		}
+		switch event.Type {
+		case C.Invalid:
+			t.mutex.Unlock()
+			continue
+		case C.CtrlA:
+			t.cx = 0
+		case C.CtrlB:
+			if t.cx > 0 {
+				t.cx--
+			}
+		case C.CtrlC, C.CtrlG, C.CtrlQ, C.ESC:
+			req(reqQuit)
+		case C.CtrlD:
+			if !t.delChar() && t.cx == 0 {
+				req(reqQuit)
+			}
+		case C.CtrlE:
+			t.cx = len(t.input)
+		case C.CtrlF:
+			if t.cx < len(t.input) {
+				t.cx++
+			}
+		case C.CtrlH:
+			if t.cx > 0 {
+				t.input = append(t.input[:t.cx-1], t.input[t.cx:]...)
+				t.cx--
+			}
+		case C.Tab:
+			if t.multi && t.merger.Length() > 0 {
+				toggle()
+				t.vmove(-1)
+				req(reqList)
+			}
+		case C.BTab:
+			if t.multi && t.merger.Length() > 0 {
+				toggle()
+				t.vmove(1)
+				req(reqList)
+			}
+		case C.CtrlJ, C.CtrlN:
+			t.vmove(-1)
+			req(reqList)
+		case C.CtrlK, C.CtrlP:
+			t.vmove(1)
+			req(reqList)
+		case C.CtrlM:
+			req(reqClose)
+		case C.CtrlL:
+			req(reqRedraw)
+		case C.CtrlU:
+			if t.cx > 0 {
+				t.yanked = copySlice(t.input[:t.cx])
+				t.input = t.input[t.cx:]
+				t.cx = 0
+			}
+		case C.CtrlW:
+			if t.cx > 0 {
+				t.rubout("\\s\\S")
+			}
+		case C.AltBS:
+			if t.cx > 0 {
+				t.rubout("[^[:alnum:]][[:alnum:]]")
+			}
+		case C.CtrlY:
+			suffix := copySlice(t.input[t.cx:])
+			t.input = append(append(t.input[:t.cx], t.yanked...), suffix...)
+			t.cx += len(t.yanked)
+		case C.Del:
+			t.delChar()
+		case C.PgUp:
+			t.vmove(maxItems() - 1)
+			req(reqList)
+		case C.PgDn:
+			t.vmove(-(maxItems() - 1))
+			req(reqList)
+		case C.AltB:
+			t.cx = findLastMatch("[^[:alnum:]][[:alnum:]]", string(t.input[:t.cx])) + 1
+		case C.AltF:
+			t.cx += findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
+		case C.AltD:
+			ncx := t.cx +
+				findFirstMatch("[[:alnum:]][^[:alnum:]]|(.$)", string(t.input[t.cx:])) + 1
+			if ncx > t.cx {
+				t.yanked = copySlice(t.input[t.cx:ncx])
+				t.input = append(t.input[:t.cx], t.input[ncx:]...)
+			}
+		case C.Rune:
+			prefix := copySlice(t.input[:t.cx])
+			t.input = append(append(prefix, event.Char), t.input[t.cx:]...)
+			t.cx++
+		case C.Mouse:
+			me := event.MouseEvent
+			mx, my := util.Constrain(me.X-len(t.prompt), 0, len(t.input)), me.Y
+			if !t.reverse {
+				my = C.MaxY() - my - 1
+			}
+			if me.S != 0 {
+				// Scroll
+				if t.merger.Length() > 0 {
+					if t.multi && me.Mod {
+						toggle()
+					}
+					t.vmove(me.S)
+					req(reqList)
+				}
+			} else if me.Double {
+				// Double-click
+				if my >= 2 {
+					if t.vset(my-2) && t.cy < t.merger.Length() {
+						req(reqClose)
+					}
+				}
+			} else if me.Down {
+				if my == 0 && mx >= 0 {
+					// Prompt
+					t.cx = mx
+				} else if my >= 2 {
+					// List
+					if t.vset(t.offset+my-2) && t.multi && me.Mod {
+						toggle()
+					}
+					req(reqList)
+				}
+			}
+		}
+		changed := string(previousInput) != string(t.input)
+		t.mutex.Unlock() // Must be unlocked before touching reqBox
+
+		if changed {
+			t.eventBox.Set(EvtSearchNew, nil)
+		}
+		for _, event := range events {
+			t.reqBox.Set(event, nil)
+		}
+	}
+}
+
+func (t *Terminal) constrain() {
+	count := t.merger.Length()
+	height := C.MaxY() - 2
+	diffpos := t.cy - t.offset
+
+	t.cy = util.Constrain(t.cy, 0, count-1)
+
+	if t.cy > t.offset+(height-1) {
+		// Ceil
+		t.offset = t.cy - (height - 1)
+	} else if t.offset > t.cy {
+		// Floor
+		t.offset = t.cy
+	}
+
+	// Adjustment
+	if count-t.offset < height {
+		t.offset = util.Max(0, count-height)
+		t.cy = util.Constrain(t.offset+diffpos, 0, count-1)
+	}
+}
+
+func (t *Terminal) vmove(o int) {
+	if t.reverse {
+		t.vset(t.cy - o)
+	} else {
+		t.vset(t.cy + o)
+	}
+}
+
+func (t *Terminal) vset(o int) bool {
+	t.cy = util.Constrain(o, 0, t.merger.Length()-1)
+	return t.cy == o
+}
+
+func maxItems() int {
+	return C.MaxY() - 2
+}

src/tokenizer.go

@@ -0,0 +1,214 @@
+package fzf
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const rangeEllipsis = 0
+
+// Range represents nth-expression
+type Range struct {
+	begin int
+	end   int
+}
+
+// Transformed holds the result of tokenization and transformation
+type Transformed struct {
+	whole *string
+	parts []Token
+}
+
+// Token contains the tokenized part of the strings and its prefix length
+type Token struct {
+	text         *string
+	prefixLength int
+}
+
+func newRange(begin int, end int) Range {
+	if begin == 1 {
+		begin = rangeEllipsis
+	}
+	if end == -1 {
+		end = rangeEllipsis
+	}
+	return Range{begin, end}
+}
+
+// ParseRange parses nth-expression and returns the corresponding Range object
+func ParseRange(str *string) (Range, bool) {
+	if (*str) == ".." {
+		return newRange(rangeEllipsis, rangeEllipsis), true
+	} else if strings.HasPrefix(*str, "..") {
+		end, err := strconv.Atoi((*str)[2:])
+		if err != nil || end == 0 {
+			return Range{}, false
+		}
+		return newRange(rangeEllipsis, end), true
+	} else if strings.HasSuffix(*str, "..") {
+		begin, err := strconv.Atoi((*str)[:len(*str)-2])
+		if err != nil || begin == 0 {
+			return Range{}, false
+		}
+		return newRange(begin, rangeEllipsis), true
+	} else if strings.Contains(*str, "..") {
+		ns := strings.Split(*str, "..")
+		if len(ns) != 2 {
+			return Range{}, false
+		}
+		begin, err1 := strconv.Atoi(ns[0])
+		end, err2 := strconv.Atoi(ns[1])
+		if err1 != nil || err2 != nil || begin == 0 || end == 0 {
+			return Range{}, false
+		}
+		return newRange(begin, end), true
+	}
+
+	n, err := strconv.Atoi(*str)
+	if err != nil || n == 0 {
+		return Range{}, false
+	}
+	return newRange(n, n), true
+}
+
+func withPrefixLengths(tokens []string, begin int) []Token {
+	ret := make([]Token, len(tokens))
+
+	prefixLength := begin
+	for idx, token := range tokens {
+		// Need to define a new local variable instead of the reused token to take
+		// the pointer to it
+		str := token
+		ret[idx] = Token{text: &str, prefixLength: prefixLength}
+		prefixLength += len([]rune(token))
+	}
+	return ret
+}
+
+const (
+	awkNil = iota
+	awkBlack
+	awkWhite
+)
+
+func awkTokenizer(input *string) ([]string, int) {
+	// 9, 32
+	ret := []string{}
+	str := []rune{}
+	prefixLength := 0
+	state := awkNil
+	for _, r := range []rune(*input) {
+		white := r == 9 || r == 32
+		switch state {
+		case awkNil:
+			if white {
+				prefixLength++
+			} else {
+				state = awkBlack
+				str = append(str, r)
+			}
+		case awkBlack:
+			str = append(str, r)
+			if white {
+				state = awkWhite
+			}
+		case awkWhite:
+			if white {
+				str = append(str, r)
+			} else {
+				ret = append(ret, string(str))
+				state = awkBlack
+				str = []rune{r}
+			}
+		}
+	}
+	if len(str) > 0 {
+		ret = append(ret, string(str))
+	}
+	return ret, prefixLength
+}
+
+// Tokenize tokenizes the given string with the delimiter
+func Tokenize(str *string, delimiter *regexp.Regexp) []Token {
+	if delimiter == nil {
+		// AWK-style (\S+\s*)
+		tokens, prefixLength := awkTokenizer(str)
+		return withPrefixLengths(tokens, prefixLength)
+	}
+	tokens := delimiter.FindAllString(*str, -1)
+	return withPrefixLengths(tokens, 0)
+}
+
+func joinTokens(tokens []Token) string {
+	ret := ""
+	for _, token := range tokens {
+		ret += *token.text
+	}
+	return ret
+}
+
+// Transform is used to transform the input when --with-nth option is given
+func Transform(tokens []Token, withNth []Range) *Transformed {
+	transTokens := make([]Token, len(withNth))
+	numTokens := len(tokens)
+	whole := ""
+	for idx, r := range withNth {
+		part := ""
+		minIdx := 0
+		if r.begin == r.end {
+			idx := r.begin
+			if idx == rangeEllipsis {
+				part += joinTokens(tokens)
+			} else {
+				if idx < 0 {
+					idx += numTokens + 1
+				}
+				if idx >= 1 && idx <= numTokens {
+					minIdx = idx - 1
+					part += *tokens[idx-1].text
+				}
+			}
+		} else {
+			var begin, end int
+			if r.begin == rangeEllipsis { // ..N
+				begin, end = 1, r.end
+				if end < 0 {
+					end += numTokens + 1
+				}
+			} else if r.end == rangeEllipsis { // N..
+				begin, end = r.begin, numTokens
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+			} else {
+				begin, end = r.begin, r.end
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+				if end < 0 {
+					end += numTokens + 1
+				}
+			}
+			minIdx = util.Max(0, begin-1)
+			for idx := begin; idx <= end; idx++ {
+				if idx >= 1 && idx <= numTokens {
+					part += *tokens[idx-1].text
+				}
+			}
+		}
+		whole += part
+		var prefixLength int
+		if minIdx < numTokens {
+			prefixLength = tokens[minIdx].prefixLength
+		} else {
+			prefixLength = 0
+		}
+		transTokens[idx] = Token{&part, prefixLength}
+	}
+	return &Transformed{
+		whole: &whole,
+		parts: transTokens}
+}

src/tokenizer_test.go

@@ -0,0 +1,101 @@
+package fzf
+
+import "testing"
+
+func TestParseRange(t *testing.T) {
+	{
+		i := ".."
+		r, _ := ParseRange(&i)
+		if r.begin != rangeEllipsis || r.end != rangeEllipsis {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3.."
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != rangeEllipsis {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3..5"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 5 {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "-3..-5"
+		r, _ := ParseRange(&i)
+		if r.begin != -3 || r.end != -5 {
+			t.Errorf("%s", r)
+		}
+	}
+	{
+		i := "3"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 3 {
+			t.Errorf("%s", r)
+		}
+	}
+}
+
+func TestTokenize(t *testing.T) {
+	// AWK-style
+	input := "  abc:  def:  ghi  "
+	tokens := Tokenize(&input, nil)
+	if *tokens[0].text != "abc:  " || tokens[0].prefixLength != 2 {
+		t.Errorf("%s", tokens)
+	}
+
+	// With delimiter
+	tokens = Tokenize(&input, delimiterRegexp(":"))
+	if *tokens[0].text != "  abc:" || tokens[0].prefixLength != 0 {
+		t.Errorf("%s", tokens)
+	}
+}
+
+func TestTransform(t *testing.T) {
+	input := "  abc:  def:  ghi:  jkl"
+	{
+		tokens := Tokenize(&input, nil)
+		{
+			ranges := splitNth("1,2,3")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "abc:  def:  ghi:  " {
+				t.Errorf("%s", *tx)
+			}
+		}
+		{
+			ranges := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
+				len(tx.parts) != 4 ||
+				*tx.parts[0].text != "abc:  def:  " || tx.parts[0].prefixLength != 2 ||
+				*tx.parts[1].text != "ghi:  " || tx.parts[1].prefixLength != 14 ||
+				*tx.parts[2].text != "def:  ghi:  jkl" || tx.parts[2].prefixLength != 8 ||
+				*tx.parts[3].text != "abc:  " || tx.parts[3].prefixLength != 2 {
+				t.Errorf("%s", *tx)
+			}
+		}
+	}
+	{
+		tokens := Tokenize(&input, delimiterRegexp(":"))
+		{
+			ranges := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			if *tx.whole != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+				len(tx.parts) != 4 ||
+				*tx.parts[0].text != "  abc:  def:" || tx.parts[0].prefixLength != 0 ||
+				*tx.parts[1].text != "  ghi:" || tx.parts[1].prefixLength != 12 ||
+				*tx.parts[2].text != "  def:  ghi:  jkl" || tx.parts[2].prefixLength != 6 ||
+				*tx.parts[3].text != "  abc:" || tx.parts[3].prefixLength != 0 {
+				t.Errorf("%s", *tx)
+			}
+		}
+	}
+}
+
+func TestTransformIndexOutOfBounds(t *testing.T) {
+	Transform([]Token{}, splitNth("1"))
+}

src/update_assets.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# http://www.rubydoc.info/github/rest-client/rest-client/RestClient
+require 'rest_client'
+
+if ARGV.length < 3
+  puts "usage: #$0 <token> <version> <files...>"
+  exit 1
+end
+
+token, version, *files = ARGV
+base = "https://api.github.com/repos/junegunn/fzf-bin/releases"
+
+# List releases
+rels = JSON.parse(RestClient.get(base, :authorization => "token #{token}"))
+rel = rels.find { |r| r['tag_name'] == version }
+unless rel
+  puts "#{version} not found"
+  exit 1
+end
+
+# List assets
+assets = Hash[rel['assets'].map { |a| a.values_at *%w[name id] }]
+
+files.select { |f| File.exists? f }.each do |file|
+  name = File.basename file
+
+  if asset_id = assets[name]
+    puts "#{name} found. Deleting asset id #{asset_id}."
+    RestClient.delete "#{base}/assets/#{asset_id}",
+      :authorization => "token #{token}"
+  else
+    puts "#{name} not found"
+  end
+
+  puts "Uploading #{name}"
+  RestClient.post(
+    "#{base.sub 'api', 'uploads'}/#{rel['id']}/assets?name=#{name}",
+    File.read(file),
+    :authorization => "token #{token}",
+    :content_type  => "application/octet-stream")
+end

src/util/atomicbool.go

@@ -0,0 +1,32 @@
+package util
+
+import "sync"
+
+// AtomicBool is a boxed-class that provides synchronized access to the
+// underlying boolean value
+type AtomicBool struct {
+	mutex sync.Mutex
+	state bool
+}
+
+// NewAtomicBool returns a new AtomicBool
+func NewAtomicBool(initialState bool) *AtomicBool {
+	return &AtomicBool{
+		mutex: sync.Mutex{},
+		state: initialState}
+}
+
+// Get returns the current boolean value synchronously
+func (a *AtomicBool) Get() bool {
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+	return a.state
+}
+
+// Set updates the boolean value synchronously
+func (a *AtomicBool) Set(newState bool) bool {
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+	a.state = newState
+	return a.state
+}

src/util/atomicbool_test.go

@@ -0,0 +1,17 @@
+package util
+
+import "testing"
+
+func TestAtomicBool(t *testing.T) {
+	if !NewAtomicBool(true).Get() || NewAtomicBool(false).Get() {
+		t.Error("Invalid initial value")
+	}
+
+	ab := NewAtomicBool(true)
+	if ab.Set(false) {
+		t.Error("Invalid return value")
+	}
+	if ab.Get() {
+		t.Error("Invalid state")
+	}
+}

src/util/eventbox.go

@@ -0,0 +1,95 @@
+package util
+
+import "sync"
+
+// EventType is the type for fzf events
+type EventType int
+
+// Events is a type that associates EventType to any data
+type Events map[EventType]interface{}
+
+// EventBox is used for coordinating events
+type EventBox struct {
+	events Events
+	cond   *sync.Cond
+	ignore map[EventType]bool
+}
+
+// NewEventBox returns a new EventBox
+func NewEventBox() *EventBox {
+	return &EventBox{
+		events: make(Events),
+		cond:   sync.NewCond(&sync.Mutex{}),
+		ignore: make(map[EventType]bool)}
+}
+
+// Wait blocks the goroutine until signaled
+func (b *EventBox) Wait(callback func(*Events)) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+
+	if len(b.events) == 0 {
+		b.cond.Wait()
+	}
+
+	callback(&b.events)
+}
+
+// Set turns on the event type on the box
+func (b *EventBox) Set(event EventType, value interface{}) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	b.events[event] = value
+	if _, found := b.ignore[event]; !found {
+		b.cond.Broadcast()
+	}
+}
+
+// Clear clears the events
+// Unsynchronized; should be called within Wait routine
+func (events *Events) Clear() {
+	for event := range *events {
+		delete(*events, event)
+	}
+}
+
+// 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]
+	return ok
+}
+
+// Watch deletes the events from the ignore list
+func (b *EventBox) Watch(events ...EventType) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	for _, event := range events {
+		delete(b.ignore, event)
+	}
+}
+
+// Unwatch adds the events to the ignore list
+func (b *EventBox) Unwatch(events ...EventType) {
+	b.cond.L.Lock()
+	defer b.cond.L.Unlock()
+	for _, event := range events {
+		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
+				}
+			}
+		})
+	}
+}

src/util/eventbox_test.go

@@ -0,0 +1,61 @@
+package util
+
+import "testing"
+
+// fzf events
+const (
+	EvtReadNew EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtClose
+)
+
+func TestEventBox(t *testing.T) {
+	eb := NewEventBox()
+
+	// Wait should return immediately
+	ch := make(chan bool)
+
+	go func() {
+		eb.Set(EvtReadNew, 10)
+		ch <- true
+		<-ch
+		eb.Set(EvtSearchNew, 10)
+		eb.Set(EvtSearchNew, 15)
+		eb.Set(EvtSearchNew, 20)
+		eb.Set(EvtSearchProgress, 30)
+		ch <- true
+		<-ch
+		eb.Set(EvtSearchFin, 40)
+		ch <- true
+		<-ch
+	}()
+
+	count := 0
+	sum := 0
+	looping := true
+	for looping {
+		<-ch
+		eb.Wait(func(events *Events) {
+			for _, value := range *events {
+				switch val := value.(type) {
+				case int:
+					sum += val
+					looping = sum < 100
+				}
+			}
+			events.Clear()
+		})
+		ch <- true
+		count++
+	}
+
+	if count != 3 {
+		t.Error("Invalid number of events", count)
+	}
+	if sum != 100 {
+		t.Error("Invalid sum", sum)
+	}
+}

src/util/util.go

@@ -0,0 +1,56 @@
+package util
+
+// #include <unistd.h>
+import "C"
+
+import (
+	"os"
+	"time"
+)
+
+// Max returns the largest integer
+func Max(first int, items ...int) int {
+	max := first
+	for _, item := range items {
+		if item > max {
+			max = item
+		}
+	}
+	return max
+}
+
+// Max32 returns the largest 32-bit integer
+func Max32(first int32, second int32) int32 {
+	if first > second {
+		return first
+	}
+	return second
+}
+
+// Constrain limits the given integer with the upper and lower bounds
+func Constrain(val int, min int, max int) int {
+	if val < min {
+		return min
+	}
+	if val > max {
+		return max
+	}
+	return val
+}
+
+// DurWithin limits the given time.Duration with the upper and lower bounds
+func DurWithin(
+	val time.Duration, min time.Duration, max time.Duration) time.Duration {
+	if val < min {
+		return min
+	}
+	if val > max {
+		return max
+	}
+	return val
+}
+
+// IsTty returns true is stdin is a terminal
+func IsTty() bool {
+	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
+}

src/util/util_test.go

@@ -0,0 +1,22 @@
+package util
+
+import "testing"
+
+func TestMax(t *testing.T) {
+	if Max(-2, 5, 1, 4, 3) != 5 {
+		t.Error("Invalid result")
+	}
+}
+
+func TestContrain(t *testing.T) {
+	if Constrain(-3, -1, 3) != -1 {
+		t.Error("Expected", -1)
+	}
+	if Constrain(2, -1, 3) != 2 {
+		t.Error("Expected", 2)
+	}
+
+	if Constrain(5, -1, 3) != 3 {
+		t.Error("Expected", 3)
+	}
+}

test/fzf.vader

@@ -0,0 +1,37 @@
+Execute (Setup):
+  let g:dir = fnamemodify(g:vader_file, ':p:h')
+  Log 'Test directory: ' . g:dir
+
+Execute (fzf#run with dir option):
+  let result = fzf#run({ 'options': '--filter=vdr', 'dir': g:dir })
+  AssertEqual ['fzf.vader'], result
+
+  let result = sort(fzf#run({ 'options': '--filter e', 'dir': g:dir }))
+  AssertEqual ['fzf.vader', 'test_go.rb', 'test_ruby.rb'], result
+
+Execute (fzf#run with Funcref command):
+  let g:ret = []
+  function! g:FzfTest(e)
+    call add(g:ret, a:e)
+  endfunction
+  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' }))
+  AssertEqual ['hi'], result
+
+Execute (fzf#run with list source):
+  let result = sort(fzf#run({ 'source': ['hello', 'world'], 'options': '-f e' }))
+  AssertEqual ['hello'], result
+  let result = sort(fzf#run({ 'source': ['hello', 'world'], 'options': '-f o' }))
+  AssertEqual ['hello', 'world'], result
+
+Execute (fzf#run with string source):
+  let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))
+  AssertEqual ['hi'], result
+
+Execute (Cleanup):
+  unlet g:dir
+  Restore

test/test_fzf.rb

@@ -1,394 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'minitest/autorun'
-$LOAD_PATH.unshift File.expand_path('../..', __FILE__)
-ENV['FZF_EXECUTABLE'] = '0'
-load 'fzf'
-
-class TestFZF < MiniTest::Unit::TestCase
-  def test_default_options
-    fzf = FZF.new []
-    assert_equal 1000,  fzf.sort
-    assert_equal false, fzf.multi
-    assert_equal true,  fzf.color
-    assert_equal nil,   fzf.rxflag
-
-    begin
-      ENV['FZF_DEFAULT_SORT'] = '1500'
-      fzf = FZF.new []
-      assert_equal 1500, fzf.sort
-    ensure
-      ENV.delete 'FZF_DEFAULT_SORT'
-    end
-  end
-
-  def test_option_parser
-    # Long opts
-    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello]
-    assert_equal 2000,    fzf.sort
-    assert_equal true,    fzf.multi
-    assert_equal false,   fzf.color
-    assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query.get
-
-    # Short opts
-    fzf = FZF.new %w[-s 2000 +c -m +i -qhello]
-    assert_equal 2000,    fzf.sort
-    assert_equal true,    fzf.multi
-    assert_equal false,   fzf.color
-    assert_equal 0,       fzf.rxflag
-    assert_equal 'hello', fzf.query.get
-
-    # Left-to-right
-    fzf = FZF.new %w[-qhello -s 2000 --no-sort -q world]
-    assert_equal nil,     fzf.sort
-    assert_equal 'world', fzf.query.get
-
-    fzf = FZF.new %w[--query hello +s -s 2000 --query=world]
-    assert_equal 2000,    fzf.sort
-    assert_equal 'world', fzf.query.get
-  rescue SystemExit => e
-    assert false, "Exited"
-  end
-
-  def test_invalid_option
-    [%w[--unknown], %w[yo dawg]].each do |argv|
-      assert_raises(SystemExit) do
-        fzf = FZF.new argv
-      end
-    end
-  end
-
-  # FIXME Only on 1.9 or above
-  def test_width
-    fzf = FZF.new []
-    assert_equal 5, fzf.width('abcde')
-    assert_equal 4, fzf.width('한글')
-    assert_equal 5, fzf.width('한글.')
-  end
-
-  def test_trim
-    fzf = FZF.new []
-    assert_equal ['사.',     6], fzf.trim('가나다라마바사.', 4, true)
-    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 5, true)
-    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 6, true)
-    assert_equal ['마바사.', 4], fzf.trim('가나다라마바사.', 7, true)
-    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 4, false)
-    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 5, false)
-    assert_equal ['가나a',   6], fzf.trim('가나ab라마바사.', 5, false)
-    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 6, false)
-    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 7, false)
-  end
-
-  def test_format
-    fzf = FZF.new []
-    assert_equal [['01234..', false]], fzf.format('0123456789', 7, [])
-    assert_equal [['012', false], ['34', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 5]])
-    assert_equal [['..56', false], ['789', true]],
-      fzf.format('0123456789', 7, [[7, 10]])
-    assert_equal [['..56', false], ['78', true], ['9', false]],
-      fzf.format('0123456789', 7, [[7, 9]])
-
-    (3..5).each do |i|
-      assert_equal [['..', false], ['567', true], ['89', false]],
-        fzf.format('0123456789', 7, [[i, 8]])
-    end
-
-    assert_equal [['..', false], ['345', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 6]])
-    assert_equal [['012', false], ['34', true], ['..', false]],
-      fzf.format('0123456789', 7, [[3, 5]])
-
-    # Multi-region
-    assert_equal [["0", true], ["1", false], ["2", true], ["34..", false]],
-      fzf.format('0123456789', 7, [[0, 1], [2, 3]])
-
-    assert_equal [["..", false], ["5", true], ["6", false], ["78", true], ["9", false]],
-      fzf.format('0123456789', 7, [[3, 6], [7, 9]])
-
-    assert_equal [["..", false], ["3", true], ["4", false], ["5", true], ["..", false]],
-      fzf.format('0123456789', 7, [[3, 4], [5, 6]])
-
-    # Multi-region Overlap
-    assert_equal [["..", false], ["345", true], ["..", false]],
-      fzf.format('0123456789', 7, [[4, 5], [3, 6]])
-  end
-
-  def test_fuzzy_matcher
-    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      juice
-      juiceful
-      juiceless
-      juicily
-      juiciness
-      juicy]
-    assert matcher.caches.empty?
-    assert_equal(
-      [["juice",     [[0, 1]]],
-       ["juiceful",  [[0, 1]]],
-       ["juiceless", [[0, 1]]],
-       ["juicily",   [[0, 1]]],
-       ["juiciness", [[0, 1]]],
-       ["juicy",     [[0, 1]]]], matcher.match(list, 'j', '', '').sort)
-    assert !matcher.caches.empty?
-    assert_equal [list.object_id], matcher.caches.keys
-    assert_equal 1, matcher.caches[list.object_id].length
-    assert_equal 6, matcher.caches[list.object_id]['j'].length
-
-    assert_equal(
-      [["juicily",   [[0, 5]]],
-       ["juiciness", [[0, 5]]]], matcher.match(list, 'jii', '', '').sort)
-
-    assert_equal(
-      [["juicily",   [[2, 5]]],
-       ["juiciness", [[2, 5]]]], matcher.match(list, 'ii', '', '').sort)
-
-    assert_equal 3, matcher.caches[list.object_id].length
-    assert_equal 2, matcher.caches[list.object_id]['ii'].length
-
-    # TODO : partial_cache
-  end
-
-  def test_fuzzy_matcher_rxflag
-    assert_equal nil, FZF::FuzzyMatcher.new(nil).rxflag
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag
-
-    assert_equal 1, FZF::FuzzyMatcher.new(nil).rxflag_for('abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(nil).rxflag_for('Abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('abc')
-    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('Abc')
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('abc')
-    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('Abc')
-  end
-
-  def test_fuzzy_matcher_case_sensitive
-    # Smart-case match (Uppercase found)
-    assert_equal [['Fruit', [[0, 5]]]],
-      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-
-    # Smart-case match (Uppercase not-found)
-    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'fruit', '', '').sort
-
-    # Case-sensitive match (-i)
-    assert_equal [['Fruit', [[0, 5]]]],
-      FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-
-    # Case-insensitive match (+i)
-    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-      FZF::FuzzyMatcher.new(Regexp::IGNORECASE).
-      match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-  end
-
-  def test_extended_fuzzy_matcher_case_sensitive
-    %w['Fruit Fruit$].each do |q|
-      # Smart-case match (Uppercase found)
-      assert_equal [['Fruit', [[0, 5]]]],
-        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q, '', '').sort
-
-      # Smart-case match (Uppercase not-found)
-      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q.downcase, '', '').sort
-
-      # Case-sensitive match (-i)
-      assert_equal [['Fruit', [[0, 5]]]],
-        FZF::ExtendedFuzzyMatcher.new(0).match(%w[Fruit Grapefruit], q, '', '').sort
-
-      # Case-insensitive match (+i)
-      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
-        FZF::ExtendedFuzzyMatcher.new(Regexp::IGNORECASE).
-        match(%w[Fruit Grapefruit], q, '', '').sort
-    end
-  end
-
-  def test_extended_fuzzy_matcher
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      juice
-      juiceful
-      juiceless
-      juicily
-      juiciness
-      juicy
-      _juice]
-    match = proc { |q, prefix|
-      matcher.match(list, q, prefix, '').sort.map { |p| [p.first, p.last.sort] }
-    }
-
-    assert matcher.caches.empty?
-    3.times do
-      ['y j', 'j y'].each do |pat|
-        (0..pat.length - 1).each do |prefix_length|
-          prefix = pat[0, prefix_length]
-          assert_equal(
-            [["juicily", [[0, 1], [6, 7]]],
-             ["juicy",   [[0, 1], [4, 5]]]],
-            match.call(pat, prefix))
-        end
-      end
-
-      # $
-      assert_equal [["juiceful",  [[7, 8]]]], match.call('l$', '')
-      assert_equal [["juiceful",  [[7, 8]]],
-                    ["juiceless", [[5, 6]]],
-                    ["juicily",   [[5, 6]]]], match.call('l', '')
-
-      # ^
-      assert_equal list.length,     match.call('j', '').length
-      assert_equal list.length - 1, match.call('^j', '').length
-
-      # ^ + $
-      assert_equal 0, match.call('^juici$', '').length
-      assert_equal 1, match.call('^juice$', '').length
-      assert_equal 0, match.call('^.*$', '').length
-
-      # !
-      assert_equal 0, match.call('!j', '').length
-
-      # ! + ^
-      assert_equal [["_juice", []]], match.call('!^j', '')
-
-      # ! + $
-      assert_equal list.length - 1, match.call('!l$', '').length
-
-      # ! + f
-      assert_equal [["juicy", [[4, 5]]]], match.call('y !l', '')
-
-      # '
-      assert_equal %w[juiceful juiceless juicily],
-        match.call('il', '').map { |e| e.first }
-      assert_equal %w[juicily],
-        match.call("'il", '').map { |e| e.first }
-      assert_equal (list - %w[juicily]).sort,
-        match.call("!'il", '').map { |e| e.first }.sort
-    end
-    assert !matcher.caches.empty?
-  end
-
-  def test_xfuzzy_matcher_prefix_cache
-    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      a.java
-      b.java
-      java.jive
-      c.java$
-      d.java
-    ]
-    2.times do
-      assert_equal 5, matcher.match(list, 'java',   'java',   '').length
-      assert_equal 3, matcher.match(list, 'java$',  'java$',  '').length
-      assert_equal 1, matcher.match(list, 'java$$', 'java$$', '').length
-
-      assert_equal 0, matcher.match(list, '!java',  '!java',  '').length
-      assert_equal 4, matcher.match(list, '!^jav',  '!^jav',  '').length
-      assert_equal 4, matcher.match(list, '!^java', '!^java', '').length
-      assert_equal 2, matcher.match(list, '!^java !b !c', '!^java', '').length
-    end
-  end
-
-  def test_sort_by_rank
-    matcher  = FZF::FuzzyMatcher.new Regexp::IGNORECASE
-    xmatcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
-    list = %w[
-      0____1
-      0_____1
-      01
-      ____0_1
-      01_
-      _01_
-      0______1
-      ___01___
-    ]
-    assert_equal(
-      [["01",       [[0, 2]]],
-       ["01_",      [[0, 2]]],
-       ["_01_",     [[1, 3]]],
-       ["___01___", [[3, 5]]],
-       ["____0_1",  [[4, 7]]],
-       ["0____1",   [[0, 6]]],
-       ["0_____1",  [[0, 7]]],
-       ["0______1", [[0, 8]]]],
-      FZF.new([]).sort_by_rank(matcher.match(list, '01', '', '')))
-
-    assert_equal(
-      [["01",       [[0, 1], [1, 2]]],
-       ["01_",      [[0, 1], [1, 2]]],
-       ["_01_",     [[1, 2], [2, 3]]],
-       ["0____1",   [[0, 1], [5, 6]]],
-       ["0_____1",  [[0, 1], [6, 7]]],
-       ["____0_1",  [[4, 5], [6, 7]]],
-       ["0______1", [[0, 1], [7, 8]]],
-       ["___01___", [[3, 4], [4, 5]]]],
-      FZF.new([]).sort_by_rank(xmatcher.match(list, '0 1', '', '')))
-
-    assert_equal(
-      [["_01_",     [[1, 3], [0, 4]]],
-       ["0____1",   [[0, 6], [1, 3]]],
-       ["0_____1",  [[0, 7], [1, 3]]],
-       ["0______1", [[0, 8], [1, 3]]],
-       ["___01___", [[3, 5], [0, 2]]],
-       ["____0_1",  [[4, 7], [0, 2]]]],
-      FZF.new([]).sort_by_rank(xmatcher.match(list, '01 __', '', '')))
-  end
-
-  if RUBY_PLATFORM =~ /darwin/
-    NFD = '한글'
-    def test_nfc
-      assert_equal 6, NFD.length
-      assert_equal ["한글", [[0, 1], [1, 2]]],
-        FZF::UConv.nfc(NFD, [[0, 3], [3, 6]])
-
-      nfd2 = 'before' + NFD + 'after'
-      assert_equal 6 + 6 + 5, nfd2.length
-
-      nfc, offsets = FZF::UConv.nfc(nfd2, [[4, 14], [9, 13]])
-      o1, o2 = offsets
-      assert_equal 'before한글after', nfc
-      assert_equal 're한글af',        nfc[(o1.first...o1.last)]
-      assert_equal '글a',             nfc[(o2.first...o2.last)]
-    end
-
-    def test_nfd
-      nfc = '한글'
-      nfd = FZF::UConv.nfd(nfc)
-      assert_equal 2, nfd.length
-      assert_equal 6, nfd.join.length
-      assert_equal NFD, nfd.join
-    end
-
-    def test_nfd_fuzzy_matcher
-      matcher = FZF::FuzzyMatcher.new 0
-      assert_equal [], matcher.match([NFD + NFD], '할', '', '')
-      match   = matcher.match([NFD + NFD], '글글', '', '')
-      assert_equal [[NFD + NFD, [[3, 12]]]], match
-      assert_equal ['한글한글', [[1, 4]]], FZF::UConv.nfc(*match.first)
-    end
-
-    def test_nfd_extended_fuzzy_matcher
-      matcher = FZF::ExtendedFuzzyMatcher.new 0
-      assert_equal [], matcher.match([NFD], "'글글", '', '')
-      match   = matcher.match([NFD], "'한글", '', '')
-      assert_equal [[NFD, [[0, 6]]]], match
-      assert_equal ['한글', [[0, 2]]], FZF::UConv.nfc(*match.first)
-    end
-  end
-
-  def test_split
-    assert_equal ["a", "b", "c", "\xFF", "d", "e", "f"],
-      FZF::UConv.split("abc\xFFdef")
-  end
-
-  # ^$ -> matches empty item
-  def test_format_empty_item
-    fzf = FZF.new []
-    item = ['', [[0, 0]]]
-    line, offsets = fzf.convert_item item
-    tokens        = fzf.format line, 80, offsets
-    assert_equal [], tokens
-  end
-end
-

test/test_go.rb

@@ -0,0 +1,577 @@
+#!/usr/bin/env ruby
+# 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
+  def readonce
+    name = self.class::TEMPNAME
+    waited = 0
+    while waited < 5
+      begin
+        data = `cat #{name}`
+        return data unless data.empty?
+      rescue
+        sleep 0.1
+        waited += 0.1
+      end
+    end
+    raise "failed to read tempfile"
+  ensure
+    while File.exists? name
+      File.unlink name rescue nil
+    end
+  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
+
+  TEMPNAME = '/tmp/fzf-test.txt'
+
+  attr_reader :win
+
+  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
+    send_keys 'C-c', 'C-u', 'exit', :Enter
+    wait { closed? }
+  end
+
+  def kill
+    go("kill-window -t #{win} 2> /dev/null")
+  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 #{target} #{args}")
+  end
+
+  def capture opts = {}
+    timeout, pane = defaults(opts).values_at(:timeout, :pane)
+    waited = 0
+    loop do
+      go("capture-pane -t #{win}.#{pane} \\; save-buffer #{TEMPNAME}")
+      break if $?.exitstatus == 0
+
+      if waited > timeout
+        raise "Window not found"
+      end
+      waited += 0.1
+      sleep 0.1
+    end
+    readonce.split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
+  end
+
+  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 defaults opts
+    { timeout: 10, pane: 0 }.merge(opts)
+  end
+
+  def wait opts = {}
+    timeout, pane = defaults(opts).values_at(:timeout, :pane)
+    waited = 0
+    until yield
+      if waited > timeout
+        hl = '=' * 10
+        puts hl
+        capture(opts).each_with_index do |line, idx|
+          puts [idx.to_s.rjust(2), line].join(': ')
+        end
+        puts hl
+        raise "timeout"
+      end
+      waited += 0.1
+      sleep 0.1
+    end
+  end
+
+  def go *args
+    %x[tmux #{args.join ' '}].split($/)
+  end
+end
+
+class TestBase < Minitest::Test
+  include Temp
+
+  FIN = 'FIN'
+  TEMPNAME = '/tmp/output'
+
+  attr_reader :tmux
+
+  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
+
+  def teardown
+    @tmux.kill
+  end
+
+  def test_vanilla
+    tmux.send_keys "seq 1 100000 | #{fzf}", :Enter
+    tmux.until(timeout: 20) { |lines|
+      lines.last =~ /^>/ && lines[-2] =~ /^  100000/ }
+    lines = tmux.capture
+    assert_equal '  2',             lines[-4]
+    assert_equal '> 1',             lines[-3]
+    assert_equal '  100000/100000', lines[-2]
+    assert_equal '>',               lines[-1]
+
+    # Testing basic key bindings
+    tmux.send_keys '99', 'C-a', '1', 'C-f', '3', 'C-b', 'C-h', 'C-u', 'C-e', 'C-y', 'C-k', 'Tab', 'BTab'
+    tmux.until { |lines| lines[-2] == '  856/100000' }
+    lines = tmux.capture
+    assert_equal '> 1391',       lines[-4]
+    assert_equal '  391',        lines[-3]
+    assert_equal '  856/100000', lines[-2]
+    assert_equal '> 391',        lines[-1]
+
+    tmux.send_keys :Enter
+    tmux.close
+    assert_equal '1391', readonce.chomp
+  end
+
+  def test_fzf_default_command
+    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' #{fzf}", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    tmux.send_keys :Enter
+    tmux.close
+    assert_equal 'hello', readonce.chomp
+  end
+
+  def test_key_bindings
+    tmux.send_keys "fzf -q 'foo bar foo-bar'", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    # CTRL-A
+    tmux.send_keys "C-A", "("
+    tmux.until { |lines| lines.last == '> (foo bar foo-bar' }
+
+    # META-F
+    tmux.send_keys :Escape, :f, ")"
+    tmux.until { |lines| lines.last == '> (foo) bar foo-bar' }
+
+    # CTRL-B
+    tmux.send_keys "C-B", "var"
+    tmux.until { |lines| lines.last == '> (foovar) bar foo-bar' }
+
+    # Left, CTRL-D
+    tmux.send_keys :Left, :Left, "C-D"
+    tmux.until { |lines| lines.last == '> (foovr) bar foo-bar' }
+
+    # META-BS
+    tmux.send_keys :Escape, :BSpace
+    tmux.until { |lines| lines.last == '> (r) bar foo-bar' }
+
+    # CTRL-Y
+    tmux.send_keys "C-Y", "C-Y"
+    tmux.until { |lines| lines.last == '> (foovfoovr) bar foo-bar' }
+
+    # META-B
+    tmux.send_keys :Escape, :b, :Space, :Space
+    tmux.until { |lines| lines.last == '> (  foovfoovr) bar foo-bar' }
+
+    # CTRL-F / Right
+    tmux.send_keys 'C-F', :Right, '/'
+    tmux.until { |lines| lines.last == '> (  fo/ovfoovr) bar foo-bar' }
+
+    # CTRL-H / BS
+    tmux.send_keys 'C-H', :BSpace
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-bar' }
+
+    # CTRL-E
+    tmux.send_keys "C-E", 'baz'
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-barbaz' }
+
+    # CTRL-U
+    tmux.send_keys "C-U"
+    tmux.until { |lines| lines.last == '>' }
+
+    # CTRL-Y
+    tmux.send_keys "C-Y"
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar foo-barbaz' }
+
+    # CTRL-W
+    tmux.send_keys "C-W", "bar-foo"
+    tmux.until { |lines| lines.last == '> (  fovfoovr) bar bar-foo' }
+
+    # META-D
+    tmux.send_keys :Escape, :b, :Escape, :b, :Escape, :d, "C-A", "C-Y"
+    tmux.until { |lines| lines.last == '> bar(  fovfoovr) bar -foo' }
+
+    # CTRL-M
+    tmux.send_keys "C-M"
+    tmux.until { |lines| lines.last !~ /^>/ }
+    tmux.close
+  end
+
+  def test_multi_order
+    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
+                   'C-K', 'C-K', 'C-K', 'C-K', :BTab, :BTab, # 5, 6
+                   :PgUp, 'C-J', :Down, :Tab, :Tab # 8, 7
+    tmux.until { |lines| lines[-2].include? '(6)' }
+    tmux.send_keys "C-M"
+    tmux.until { |lines| lines[-1].include?(FIN) }
+    assert_equal %w[3 2 5 6 8 7], readonce.split($/)
+    tmux.close
+  end
+
+  def test_with_nth
+    [true, false].each do |multi|
+      tmux.send_keys "(echo '  1st 2nd 3rd/';
+                       echo '  first second third/') |
+                       #{fzf multi && :multi, :x, :nth, 2, :with_nth, '2,-1,1'}",
+                      :Enter
+      tmux.until { |lines| lines[-2].include?('2/2') }
+
+      # Transformed list
+      lines = tmux.capture
+      assert_equal '  second third/first', lines[-4]
+      assert_equal '> 2nd 3rd/1st',        lines[-3]
+
+      # However, the output must not be transformed
+      if multi
+        tmux.send_keys :BTab, :BTab, :Enter
+        tmux.until { |lines| lines[-1].include?(FIN) }
+        assert_equal ['  1st 2nd 3rd/', '  first second third/'], readonce.split($/)
+      else
+        tmux.send_keys '^', '3'
+        tmux.until { |lines| lines[-2].include?('1/2') }
+        tmux.send_keys :Enter
+        tmux.until { |lines| lines[-1].include?(FIN) }
+        assert_equal ['  1st 2nd 3rd/'], readonce.split($/)
+      end
+    end
+  end
+
+  def test_scroll
+    [true, false].each do |rev|
+      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) }
+      assert_equal '100', readonce.chomp
+    end
+  end
+
+  def test_select_1
+    tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 5555, :'1'}", :Enter
+    tmux.until { |lines| lines[-1].include?(FIN) }
+    assert_equal ['5555', '55'], readonce.split($/)
+  end
+
+  def test_exit_0
+    tmux.send_keys "seq 1 100 | #{fzf :with_nth, '..,..', :print_query, :q, 555555, :'0'}", :Enter
+    tmux.until { |lines| lines[-1].include?(FIN) }
+    assert_equal ['555555'], readonce.split($/)
+  end
+
+  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, '가다'}", :Enter
+    tmux.until { |lines| lines.last.start_with? '>' }
+    tmux.send_keys :Enter
+    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

@@ -0,0 +1,850 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems'
+require 'curses'
+require 'timeout'
+require 'stringio'
+require 'minitest/autorun'
+require 'tempfile'
+$LOAD_PATH.unshift File.expand_path('../..', __FILE__)
+ENV['FZF_EXECUTABLE'] = '0'
+load 'fzf'
+
+class MockTTY
+  def initialize
+    @buffer = ''
+    @mutex = Mutex.new
+    @condv = ConditionVariable.new
+  end
+
+  def read_nonblock sz
+    @mutex.synchronize do
+      take sz
+    end
+  end
+
+  def take sz
+    if @buffer.length >= sz
+      ret = @buffer[0, sz]
+      @buffer = @buffer[sz..-1]
+      ret
+    end
+  end
+
+  def getc
+    sleep 0.1
+    while true
+      @mutex.synchronize do
+        if char = take(1)
+          return char
+        else
+          @condv.wait(@mutex)
+        end
+      end
+    end
+  end
+
+  def << str
+    @mutex.synchronize do
+      @buffer << str
+      @condv.broadcast
+    end
+    self
+  end
+end
+
+class TestRubyFZF < Minitest::Test
+  def setup
+    ENV.delete 'FZF_DEFAULT_SORT'
+    ENV.delete 'FZF_DEFAULT_OPTS'
+    ENV.delete 'FZF_DEFAULT_COMMAND'
+  end
+
+  def test_default_options
+    fzf = FZF.new []
+    assert_equal 1000,  fzf.sort
+    assert_equal false, fzf.multi
+    assert_equal true,  fzf.color
+    assert_equal nil,   fzf.rxflag
+    assert_equal true,  fzf.mouse
+    assert_equal nil,   fzf.nth
+    assert_equal nil,   fzf.with_nth
+    assert_equal true,  fzf.color
+    assert_equal false, fzf.black
+    assert_equal true,  fzf.ansi256
+    assert_equal '',    fzf.query
+    assert_equal false, fzf.select1
+    assert_equal false, fzf.exit0
+    assert_equal nil,   fzf.filter
+    assert_equal nil,   fzf.extended
+    assert_equal false, fzf.reverse
+    assert_equal '> ',  fzf.prompt
+    assert_equal false, fzf.print_query
+  end
+
+  def test_environment_variables
+    # Deprecated
+    ENV['FZF_DEFAULT_SORT'] = '20000'
+    fzf = FZF.new []
+    assert_equal 20000, fzf.sort
+    assert_equal nil,   fzf.nth
+
+    ENV['FZF_DEFAULT_OPTS'] =
+      '-x -m -s 10000 -q "  hello  world  " +c +2 --select-1 -0 ' <<
+      '--no-mouse -f "goodbye world" --black --with-nth=3,-3..,2 --nth=3,-1,2 --reverse --print-query'
+    fzf = FZF.new []
+    assert_equal 10000,   fzf.sort
+    assert_equal '  hello  world  ',
+                          fzf.query
+    assert_equal 'goodbye world',
+                          fzf.filter
+    assert_equal :fuzzy,  fzf.extended
+    assert_equal true,    fzf.multi
+    assert_equal false,   fzf.color
+    assert_equal false,   fzf.ansi256
+    assert_equal true,    fzf.black
+    assert_equal false,   fzf.mouse
+    assert_equal true,    fzf.select1
+    assert_equal true,    fzf.exit0
+    assert_equal true,    fzf.reverse
+    assert_equal true,    fzf.print_query
+    assert_equal [2..2, -1..-1, 1..1], fzf.nth
+    assert_equal [2..2, -3..-1, 1..1], fzf.with_nth
+  end
+
+  def test_option_parser
+    # Long opts
+    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello --select-1
+                     --exit-0 --filter=howdy --extended-exact
+                     --no-mouse --no-256 --nth=1 --with-nth=.. --reverse --prompt (hi)
+                     --print-query]
+    assert_equal 2000,    fzf.sort
+    assert_equal true,    fzf.multi
+    assert_equal false,   fzf.color
+    assert_equal false,   fzf.ansi256
+    assert_equal false,   fzf.black
+    assert_equal false,   fzf.mouse
+    assert_equal 0,       fzf.rxflag
+    assert_equal 'hello', fzf.query
+    assert_equal true,    fzf.select1
+    assert_equal true,    fzf.exit0
+    assert_equal 'howdy', fzf.filter
+    assert_equal :exact,  fzf.extended
+    assert_equal [0..0],  fzf.nth
+    assert_equal nil,     fzf.with_nth
+    assert_equal true,    fzf.reverse
+    assert_equal '(hi)',  fzf.prompt
+    assert_equal true,    fzf.print_query
+
+    # Long opts (left-to-right)
+    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query=hello
+                     --filter a --filter b --no-256 --black --nth -1 --nth -2
+                     --select-1 --exit-0 --no-select-1 --no-exit-0
+                     --no-sort -i --color --no-multi --256
+                     --reverse --no-reverse --prompt (hi) --prompt=(HI)
+                     --print-query --no-print-query]
+    assert_equal nil,     fzf.sort
+    assert_equal false,   fzf.multi
+    assert_equal true,    fzf.color
+    assert_equal true,    fzf.ansi256
+    assert_equal true,    fzf.black
+    assert_equal true,    fzf.mouse
+    assert_equal 1,       fzf.rxflag
+    assert_equal 'b',     fzf.filter
+    assert_equal 'hello', fzf.query
+    assert_equal false,   fzf.select1
+    assert_equal false,   fzf.exit0
+    assert_equal nil,     fzf.extended
+    assert_equal [-2..-2], fzf.nth
+    assert_equal false,   fzf.reverse
+    assert_equal '(HI)',  fzf.prompt
+    assert_equal false,    fzf.print_query
+
+    # Short opts
+    fzf = FZF.new %w[-s2000 +c -m +i -qhello -x -fhowdy +2 -n3 -1 -0]
+    assert_equal 2000,    fzf.sort
+    assert_equal true,    fzf.multi
+    assert_equal false,   fzf.color
+    assert_equal false,   fzf.ansi256
+    assert_equal 0,       fzf.rxflag
+    assert_equal 'hello', fzf.query
+    assert_equal 'howdy', fzf.filter
+    assert_equal :fuzzy,  fzf.extended
+    assert_equal [2..2],  fzf.nth
+    assert_equal true,    fzf.select1
+    assert_equal true,    fzf.exit0
+
+    # Left-to-right
+    fzf = FZF.new %w[-s 2000 +c -m +i -qhello -x -fgoodbye +2 -n3 -n4,5
+                     -s 3000 -c +m -i -q world +x -fworld -2 --black --no-black
+                     -1 -0 +1 +0
+                    ]
+    assert_equal 3000,    fzf.sort
+    assert_equal false,   fzf.multi
+    assert_equal true,    fzf.color
+    assert_equal true,    fzf.ansi256
+    assert_equal false,   fzf.black
+    assert_equal 1,       fzf.rxflag
+    assert_equal 'world', fzf.query
+    assert_equal false,   fzf.select1
+    assert_equal false,   fzf.exit0
+    assert_equal 'world', fzf.filter
+    assert_equal nil,     fzf.extended
+    assert_equal [3..3, 4..4], fzf.nth
+  rescue SystemExit => e
+    assert false, "Exited"
+  end
+
+  def test_invalid_option
+    [
+      %w[--unknown],
+      %w[yo dawg],
+      %w[--nth=0],
+      %w[-n 0],
+      %w[-n 1..2..3],
+      %w[-n 1....],
+      %w[-n ....3],
+      %w[-n 1....3],
+      %w[-n 1..0],
+      %w[--nth ..0],
+    ].each do |argv|
+      assert_raises(SystemExit) do
+        fzf = FZF.new argv
+      end
+    end
+  end
+
+  def test_width
+    fzf = FZF.new []
+    assert_equal 5, fzf.width('abcde')
+    assert_equal 4, fzf.width('한글')
+    assert_equal 5, fzf.width('한글.')
+  end if RUBY_VERSION >= '1.9'
+
+  def test_trim
+    fzf = FZF.new []
+    assert_equal ['사.',     6], fzf.trim('가나다라마바사.', 4, true)
+    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 5, true)
+    assert_equal ['바사.',   5], fzf.trim('가나다라마바사.', 6, true)
+    assert_equal ['마바사.', 4], fzf.trim('가나다라마바사.', 7, true)
+    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 4, false)
+    assert_equal ['가나',    6], fzf.trim('가나다라마바사.', 5, false)
+    assert_equal ['가나a',   6], fzf.trim('가나ab라마바사.', 5, false)
+    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 6, false)
+    assert_equal ['가나ab',  5], fzf.trim('가나ab라마바사.', 7, false)
+  end if RUBY_VERSION >= '1.9'
+
+  def test_format
+    fzf = FZF.new []
+    assert_equal [['01234..', false]], fzf.format('0123456789', 7, [])
+    assert_equal [['012', false], ['34', true], ['..', false]],
+      fzf.format('0123456789', 7, [[3, 5]])
+    assert_equal [['..56', false], ['789', true]],
+      fzf.format('0123456789', 7, [[7, 10]])
+    assert_equal [['..56', false], ['78', true], ['9', false]],
+      fzf.format('0123456789', 7, [[7, 9]])
+
+    (3..5).each do |i|
+      assert_equal [['..', false], ['567', true], ['89', false]],
+        fzf.format('0123456789', 7, [[i, 8]])
+    end
+
+    assert_equal [['..', false], ['345', true], ['..', false]],
+      fzf.format('0123456789', 7, [[3, 6]])
+    assert_equal [['012', false], ['34', true], ['..', false]],
+      fzf.format('0123456789', 7, [[3, 5]])
+
+    # Multi-region
+    assert_equal [["0", true], ["1", false], ["2", true], ["34..", false]],
+      fzf.format('0123456789', 7, [[0, 1], [2, 3]])
+
+    assert_equal [["..", false], ["5", true], ["6", false], ["78", true], ["9", false]],
+      fzf.format('0123456789', 7, [[3, 6], [7, 9]])
+
+    assert_equal [["..", false], ["3", true], ["4", false], ["5", true], ["..", false]],
+      fzf.format('0123456789', 7, [[3, 4], [5, 6]])
+
+    # Multi-region Overlap
+    assert_equal [["..", false], ["345", true], ["..", false]],
+      fzf.format('0123456789', 7, [[4, 5], [3, 6]])
+  end
+
+  def test_fuzzy_matcher
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
+    list = %w[
+      juice
+      juiceful
+      juiceless
+      juicily
+      juiciness
+      juicy]
+    assert matcher.caches.empty?
+    assert_equal(
+      [["juice",     [[0, 1]]],
+       ["juiceful",  [[0, 1]]],
+       ["juiceless", [[0, 1]]],
+       ["juicily",   [[0, 1]]],
+       ["juiciness", [[0, 1]]],
+       ["juicy",     [[0, 1]]]], matcher.match(list, 'j', '', '').sort)
+    assert !matcher.caches.empty?
+    assert_equal [list.object_id], matcher.caches.keys
+    assert_equal 1, matcher.caches[list.object_id].length
+    assert_equal 6, matcher.caches[list.object_id]['j'].length
+
+    assert_equal(
+      [["juicily",   [[0, 5]]],
+       ["juiciness", [[0, 5]]]], matcher.match(list, 'jii', '', '').sort)
+
+    assert_equal(
+      [["juicily",   [[2, 5]]],
+       ["juiciness", [[2, 5]]]], matcher.match(list, 'ii', '', '').sort)
+
+    assert_equal 3, matcher.caches[list.object_id].length
+    assert_equal 2, matcher.caches[list.object_id]['ii'].length
+
+    # TODO : partial_cache
+  end
+
+  def test_fuzzy_matcher_rxflag
+    assert_equal nil, FZF::FuzzyMatcher.new(nil).rxflag
+    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag
+    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag
+
+    assert_equal 1, FZF::FuzzyMatcher.new(nil).rxflag_for('abc')
+    assert_equal 0, FZF::FuzzyMatcher.new(nil).rxflag_for('Abc')
+    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('abc')
+    assert_equal 0, FZF::FuzzyMatcher.new(0).rxflag_for('Abc')
+    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('abc')
+    assert_equal 1, FZF::FuzzyMatcher.new(1).rxflag_for('Abc')
+  end
+
+  def test_fuzzy_matcher_case_sensitive
+    # Smart-case match (Uppercase found)
+    assert_equal [['Fruit', [[0, 5]]]],
+      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
+
+    # Smart-case match (Uppercase not-found)
+    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
+      FZF::FuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], 'fruit', '', '').sort
+
+    # Case-sensitive match (-i)
+    assert_equal [['Fruit', [[0, 5]]]],
+      FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
+
+    # Case-insensitive match (+i)
+    assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
+      FZF::FuzzyMatcher.new(Regexp::IGNORECASE).
+      match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
+  end
+
+  def test_extended_fuzzy_matcher_case_sensitive
+    %w['Fruit Fruit$].each do |q|
+      # Smart-case match (Uppercase found)
+      assert_equal [['Fruit', [[0, 5]]]],
+        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q, '', '').sort
+
+      # Smart-case match (Uppercase not-found)
+      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
+        FZF::ExtendedFuzzyMatcher.new(nil).match(%w[Fruit Grapefruit], q.downcase, '', '').sort
+
+      # Case-sensitive match (-i)
+      assert_equal [['Fruit', [[0, 5]]]],
+        FZF::ExtendedFuzzyMatcher.new(0).match(%w[Fruit Grapefruit], q, '', '').sort
+
+      # Case-insensitive match (+i)
+      assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
+        FZF::ExtendedFuzzyMatcher.new(Regexp::IGNORECASE).
+        match(%w[Fruit Grapefruit], q, '', '').sort
+    end
+  end
+
+  def test_extended_fuzzy_matcher
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
+    list = %w[
+      juice
+      juiceful
+      juiceless
+      juicily
+      juiciness
+      juicy
+      _juice]
+    match = proc { |q, prefix|
+      matcher.match(list, q, prefix, '').sort.map { |p| [p.first, p.last.sort] }
+    }
+
+    assert matcher.caches.empty?
+    3.times do
+      ['y j', 'j y'].each do |pat|
+        (0..pat.length - 1).each do |prefix_length|
+          prefix = pat[0, prefix_length]
+          assert_equal(
+            [["juicily", [[0, 1], [6, 7]]],
+             ["juicy",   [[0, 1], [4, 5]]]],
+            match.call(pat, prefix))
+        end
+      end
+
+      # $
+      assert_equal [["juiceful",  [[7, 8]]]], match.call('l$', '')
+      assert_equal [["juiceful",  [[7, 8]]],
+                    ["juiceless", [[5, 6]]],
+                    ["juicily",   [[5, 6]]]], match.call('l', '')
+
+      # ^
+      assert_equal list.length,     match.call('j', '').length
+      assert_equal list.length - 1, match.call('^j', '').length
+
+      # ^ + $
+      assert_equal 0, match.call('^juici$', '').length
+      assert_equal 1, match.call('^juice$', '').length
+      assert_equal 0, match.call('^.*$', '').length
+
+      # !
+      assert_equal 0, match.call('!j', '').length
+
+      # ! + ^
+      assert_equal [["_juice", []]], match.call('!^j', '')
+
+      # ! + $
+      assert_equal list.length - 1, match.call('!l$', '').length
+
+      # ! + f
+      assert_equal [["juicy", [[4, 5]]]], match.call('y !l', '')
+
+      # '
+      assert_equal %w[juiceful juiceless juicily],
+        match.call('il', '').map { |e| e.first }
+      assert_equal %w[juicily],
+        match.call("'il", '').map { |e| e.first }
+      assert_equal (list - %w[juicily]).sort,
+        match.call("!'il", '').map { |e| e.first }.sort
+    end
+    assert !matcher.caches.empty?
+  end
+
+  def test_xfuzzy_matcher_prefix_cache
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
+    list = %w[
+      a.java
+      b.java
+      java.jive
+      c.java$
+      d.java
+    ]
+    2.times do
+      assert_equal 5, matcher.match(list, 'java',   'java',   '').length
+      assert_equal 3, matcher.match(list, 'java$',  'java$',  '').length
+      assert_equal 1, matcher.match(list, 'java$$', 'java$$', '').length
+
+      assert_equal 0, matcher.match(list, '!java',  '!java',  '').length
+      assert_equal 4, matcher.match(list, '!^jav',  '!^jav',  '').length
+      assert_equal 4, matcher.match(list, '!^java', '!^java', '').length
+      assert_equal 2, matcher.match(list, '!^java !b !c', '!^java', '').length
+    end
+  end
+
+  def test_sort_by_rank
+    matcher  = FZF::FuzzyMatcher.new Regexp::IGNORECASE
+    xmatcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
+    list = %w[
+      0____1
+      0_____1
+      01
+      ____0_1
+      01_
+      _01_
+      0______1
+      ___01___
+    ]
+    assert_equal(
+      [["01",       [[0, 2]]],
+       ["01_",      [[0, 2]]],
+       ["_01_",     [[1, 3]]],
+       ["___01___", [[3, 5]]],
+       ["____0_1",  [[4, 7]]],
+       ["0____1",   [[0, 6]]],
+       ["0_____1",  [[0, 7]]],
+       ["0______1", [[0, 8]]]],
+      FZF.sort(matcher.match(list, '01', '', '')))
+
+    assert_equal(
+      [["01",       [[0, 1], [1, 2]]],
+       ["01_",      [[0, 1], [1, 2]]],
+       ["_01_",     [[1, 2], [2, 3]]],
+       ["0____1",   [[0, 1], [5, 6]]],
+       ["0_____1",  [[0, 1], [6, 7]]],
+       ["____0_1",  [[4, 5], [6, 7]]],
+       ["0______1", [[0, 1], [7, 8]]],
+       ["___01___", [[3, 4], [4, 5]]]],
+      FZF.sort(xmatcher.match(list, '0 1', '', '')))
+
+    assert_equal(
+      [["_01_",     [[1, 3], [0, 4]], [4, 4, "_01_"]],
+       ["___01___", [[3, 5], [0, 2]], [4, 8, "___01___"]],
+       ["____0_1",  [[4, 7], [0, 2]], [5, 7, "____0_1"]],
+       ["0____1",   [[0, 6], [1, 3]], [6, 6, "0____1"]],
+       ["0_____1",  [[0, 7], [1, 3]], [7, 7, "0_____1"]],
+       ["0______1", [[0, 8], [1, 3]], [8, 8, "0______1"]]],
+      FZF.sort(xmatcher.match(list, '01 __', '', '')).map { |tuple|
+        tuple << FZF.rank(tuple)
+      }
+    )
+  end
+
+  def test_extended_exact_mode
+    exact = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :exact
+    fuzzy = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy
+    list = %w[
+      extended-exact-mode-not-fuzzy
+      extended'-fuzzy-mode
+    ]
+    assert_equal 2, fuzzy.match(list, 'extended', '', '').length
+    assert_equal 2, fuzzy.match(list, 'mode extended', '', '').length
+    assert_equal 2, fuzzy.match(list, 'xtndd', '', '').length
+    assert_equal 2, fuzzy.match(list, "'-fuzzy", '', '').length
+
+    assert_equal 2, exact.match(list, 'extended', '', '').length
+    assert_equal 2, exact.match(list, 'mode extended', '', '').length
+    assert_equal 0, exact.match(list, 'xtndd', '', '').length
+    assert_equal 1, exact.match(list, "'-fuzzy", '', '').length
+    assert_equal 2, exact.match(list, "-fuzzy", '', '').length
+  end
+
+  # ^$ -> matches empty item
+  def test_format_empty_item
+    fzf = FZF.new []
+    item = ['', [[0, 0]]]
+    line, offsets = item
+    tokens        = fzf.format line, 80, offsets
+    assert_equal [], tokens
+  end
+
+  def test_mouse_event
+    interval = FZF::MouseEvent::DOUBLE_CLICK_INTERVAL
+    me = FZF::MouseEvent.new nil
+    me.v = 10
+    assert_equal false, me.double?(10)
+    assert_equal false, me.double?(20)
+    me.v = 20
+    assert_equal false, me.double?(10)
+    assert_equal false, me.double?(20)
+    me.v = 20
+    assert_equal false, me.double?(10)
+    assert_equal true,  me.double?(20)
+    sleep interval
+    assert_equal false,  me.double?(20)
+  end
+
+  def test_nth_match
+    list = [
+      ' first  second  third',
+      'fourth	 fifth   sixth',
+    ]
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
+    assert_equal list, matcher.match(list, 'f', '', '').map(&:first)
+    assert_equal [
+      [list[0], [[2,  5]]],
+      [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1]
+    assert_equal [[list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
+    assert_equal [[list[0], [[8, 9]]]], matcher.match(list, 's', '', '')
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2]
+    assert_equal [[list[0], [[19, 20]]]], matcher.match(list, 'r', '', '')
+
+    # Comma-separated
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [2..2, 0..0]
+    assert_equal [[list[0], [[19, 20]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
+
+    # Ordered
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0, 2..2]
+    assert_equal [[list[0], [[3, 4]]], [list[1], [[3, 4]]]], matcher.match(list, 'r', '', '')
+
+    regex = FZF.build_delim_regex "\t"
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
+    assert_equal [[list[0], [[3, 10]]]], matcher.match(list, 're', '', '')
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
+    assert_equal [], matcher.match(list, 'r', '', '')
+    assert_equal [[list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
+
+    # Negative indexing
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [-1..-1], regex
+    assert_equal [[list[0], [[3, 6]]]], matcher.match(list, 'rt', '', '')
+    assert_equal [[list[0], [[2, 5]]], [list[1], [[9, 17]]]], matcher.match(list, 'is', '', '')
+
+    # Regex delimiter
+    regex = FZF.build_delim_regex "[ \t]+"
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [0..0], regex
+    assert_equal [list[1]], matcher.match(list, 'f', '', '').map(&:first)
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..1], regex
+    assert_equal [[list[0], [[1, 2]]], [list[1], [[8, 9]]]], matcher.match(list, 'f', '', '')
+  end
+
+  def test_nth_match_range
+    list = [
+      ' first  second  third',
+      'fourth	 fifth   sixth',
+    ]
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..2]
+    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
+    assert_equal [], matcher.match(list, 'fo', '', '')
+
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE, [1..-1, 0..0]
+    assert_equal [[list[0], [[8, 20]]]], matcher.match(list, 'sr', '', '')
+    assert_equal [[list[1], [[0, 2]]]], matcher.match(list, 'fo', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..0, 1..2]
+    assert_equal [], matcher.match(list, '^t', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [0..1, 2..2]
+    assert_equal [[list[0], [[16, 17]]]], matcher.match(list, '^t', '', '')
+
+    matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE, :fuzzy, [1..-1]
+    assert_equal [[list[0], [[8, 9]]]], matcher.match(list, '^s', '', '')
+  end
+
+  def stream_for str, delay = 0
+    StringIO.new(str).tap do |sio|
+      sio.instance_eval do
+        alias org_gets gets
+
+        def gets
+          org_gets.tap { |e| sleep(@delay) unless e.nil? }
+        end
+
+        def reopen _
+        end
+      end
+      sio.instance_variable_set :@delay, delay
+    end
+  end
+
+  def assert_fzf_output opts, given, expected
+    stream = stream_for given
+    output = stream_for ''
+
+    def sorted_lines line
+      line.split($/).sort
+    end
+
+    begin
+      tty = MockTTY.new
+      $stdout = output
+      fzf = FZF.new(opts, stream)
+      fzf.instance_variable_set :@tty, tty
+      thr = block_given? && Thread.new { yield tty }
+      fzf.start
+      thr && thr.join
+    rescue SystemExit => e
+      assert_equal 0, e.status
+      assert_equal sorted_lines(expected), sorted_lines(output.string)
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  def test_filter
+    {
+      %w[--filter=ol] => 'World',
+      %w[--filter=ol --print-query] => "ol\nWorld",
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
+    end
+  end
+
+  def test_select_1
+    {
+      %w[--query=ol --select-1] => 'World',
+      %w[--query=ol --select-1 --print-query] => "ol\nWorld",
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
+    end
+  end
+
+  def test_select_1_without_query
+    assert_fzf_output %w[--select-1], 'Hello World', 'Hello World'
+  end
+
+  def test_select_1_ambiguity
+    begin
+      Timeout::timeout(0.5) do
+        assert_fzf_output %w[--query=o --select-1], "hello\nworld", "should not match"
+      end
+    rescue Timeout::Error
+      Curses.close_screen
+    end
+  end
+
+  def test_exit_0
+    {
+      %w[--query=zz --exit-0] => '',
+      %w[--query=zz --exit-0 --print-query] => 'zz',
+    }.each do |opts, expected|
+      assert_fzf_output opts, "Hello\nWorld", expected
+    end
+  end
+
+  def test_exit_0_without_query
+    assert_fzf_output %w[--exit-0], '', ''
+  end
+
+  def test_with_nth
+    source = "hello world\nbatman"
+    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q ^worl],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=2,1 -x -q llo$],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=.. -x -q llo$],
+      source, ''
+    assert_fzf_output %w[-0 -1 --with-nth=2,2,2,..,1 -x -q worlworlworlhellworlhell],
+      source, 'hello world'
+    assert_fzf_output %w[-0 -1 --with-nth=1,1,-1,1 -x -q batbatbatbat],
+      source, 'batman'
+  end
+
+  def test_with_nth_transform
+    fzf = FZF.new %w[--with-nth 2..,1]
+    assert_equal 'my world hello', fzf.transform('hello my world')
+    assert_equal 'my   world hello', fzf.transform('hello   my   world')
+    assert_equal 'my   world  hello', fzf.transform('hello   my   world  ')
+
+    fzf = FZF.new %w[--with-nth 2,-1,2]
+    assert_equal 'my world my', fzf.transform('hello my world')
+    assert_equal 'world world world', fzf.transform('hello world')
+    assert_equal 'world  world  world', fzf.transform('hello world  ')
+  end
+
+  def test_ranking_overlap_match_regions
+    list = [
+      '1           3   4      2',
+      '1           2   3    4'
+    ]
+    assert_equal [
+      ['1           2   3    4',   [[0, 13], [16, 22]]],
+      ['1           3   4      2', [[0, 24], [12, 17]]],
+    ], FZF.sort(FZF::ExtendedFuzzyMatcher.new(nil).match(list, '12 34', '', ''))
+  end
+
+  def test_constrain
+    fzf = FZF.new []
+
+    # [#****             ]
+    assert_equal [false, 0, 0], fzf.constrain(0, 0, 5, 100)
+
+    # *****[**#**  ...   ] => [**#*******  ... ]
+    assert_equal [true, 0, 2], fzf.constrain(5, 7, 10, 100)
+
+    # [**********]**#** => ***[*********#]**
+    assert_equal [true, 3, 12], fzf.constrain(0, 12, 15, 10)
+
+    # *****[**#**  ] => ***[**#****]
+    assert_equal [true, 3, 5], fzf.constrain(5, 7, 10, 7)
+
+    # *****[**#** ] => ****[**#***]
+    assert_equal [true, 4, 6], fzf.constrain(5, 7, 10, 6)
+
+    # *****  [#] => ****[#]
+    assert_equal [true, 4, 4], fzf.constrain(10, 10, 5, 1)
+
+    # [ ] #**** => [#]****
+    assert_equal [true, 0, 0], fzf.constrain(-5, 0, 5, 1)
+
+    # [ ] **#** => **[#]**
+    assert_equal [true, 2, 2], fzf.constrain(-5, 2, 5, 1)
+
+    # [*****  #] => [****#   ]
+    assert_equal [true, 0, 4], fzf.constrain(0, 7, 5, 10)
+
+    # **[*****  #] => [******# ]
+    assert_equal [true, 0, 6], fzf.constrain(2, 10, 7, 10)
+  end
+
+  def test_invalid_utf8
+    tmp = Tempfile.new('fzf')
+    tmp << 'hello ' << [0xff].pack('C*') << ' world' << $/ << [0xff].pack('C*')
+    tmp.close
+    begin
+      Timeout::timeout(0.5) do
+        FZF.new(%w[-n..,1,2.. -q^ -x], File.open(tmp.path)).start
+      end
+    rescue Timeout::Error
+      Curses.close_screen
+    end
+  ensure
+    tmp.unlink
+  end
+
+  def test_with_nth_mock_tty
+    # Manual selection with input
+    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
+      tty << "world"
+      tty << "hell"
+      tty << "\r"
+    end
+
+    # Manual selection without input
+    assert_fzf_output ["--with-nth=2,1"], "hello world", "hello world" do |tty|
+      tty << "\r"
+    end
+
+    # Manual selection with input and --multi
+    lines = "hello world\ngoodbye world"
+    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
+      tty << "o"
+      tty << "\e[Z\e[Z"
+      tty << "\r"
+    end
+
+    # Manual selection without input and --multi
+    assert_fzf_output %w[-m --with-nth=2,1], lines, lines do |tty|
+      tty << "\e[Z\e[Z"
+      tty << "\r"
+    end
+
+    # ALT-D
+    assert_fzf_output %w[--print-query], "", "hello  baby = world" do |tty|
+      tty << "hello world baby"
+      tty << alt(:b) << alt(:b) << alt(:d)
+      tty << ctrl(:e) << " = " << ctrl(:y)
+      tty << "\r"
+    end
+
+    # ALT-BACKSPACE
+    assert_fzf_output %w[--print-query], "", "hello baby = world " do |tty|
+      tty << "hello world baby"
+      tty << alt(:b) << alt(127.chr)
+      tty << ctrl(:e) << " = " << ctrl(:y)
+      tty << "\r"
+    end
+
+    # Word-movements
+    assert_fzf_output %w[--print-query], "", "ello!_orld!~ foo=?" do |tty|
+      tty << "hello_world==baby?"
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:b) << ctrl(:d)
+      tty << alt(:f) << '!'
+      tty << alt(:f) << '!'
+      tty << alt(:d) << '~'
+      tty << " foo=bar foo=bar"
+      tty << ctrl(:w)
+      tty << alt(127.chr)
+      tty << "\r"
+    end
+  end
+
+  def alt chr
+    "\e#{chr}"
+  end
+
+  def ctrl char
+    char.to_s.ord - 'a'.ord + 1
+  end
+end
+

uninstall

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+
+confirm() {
+  while [ 1 ]; do
+    read -p "$1" -n 1 -r
+    echo
+    if [[ "$REPLY" =~ ^[Yy] ]]; then
+      return 0
+    elif [[ "$REPLY" =~ ^[Nn] ]]; then
+      return 1
+    fi
+  done
+}
+
+remove() {
+  echo "Remove $1"
+  rm -f "$1"
+}
+
+remove_line() {
+  src=$(readlink "$1")
+  if [ $? -eq 0 ]; then
+    echo "Remove from $1 ($src):"
+  else
+    src=$1
+    echo "Remove from $1:"
+  fi
+
+  shift
+  line_no=1
+  match=0
+  while [ -n "$1" ]; do
+    line=$(sed -n "$line_no,\$p" "$src" | \grep -m1 -nF "$1")
+    if [ $? -ne 0 ]; then
+      shift
+      line_no=1
+      continue
+    fi
+    line_no=$(( $(sed 's/:.*//' <<< "$line") + line_no - 1 ))
+    content=$(sed 's/^[0-9]*://' <<< "$line")
+    match=1
+    echo    "  - Line #$line_no: $content"
+    [ "$content" = "$1" ] || confirm "    - Remove (y/n) ? "
+    if [ $? -eq 0 ]; then
+      awk -v n=$line_no 'NR == n {next} {print}' "$src" > "$src.bak" &&
+        mv "$src.bak" "$src" || break
+      echo  "      - Removed"
+    else
+      echo  "      - Skipped"
+      line_no=$(( line_no + 1 ))
+    fi
+  done
+  [ $match -eq 0 ] && echo "  - Nothing found"
+  echo
+}
+
+for shell in bash zsh; do
+  remove ~/.fzf.${shell}
+  remove_line ~/.${shell}rc \
+    "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" \
+    "source ~/.fzf.${shell}"
+done
+
+bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
+if [ -f "$bind_file" ]; then
+  remove_line "$bind_file" "fzf_key_bindings"
+fi
+
+if [ -d ~/.config/fish/functions ]; then
+  remove ~/.config/fish/functions/fzf.fish
+
+  if [ "$(ls -A ~/.config/fish/functions)" ]; then
+    echo "Can't delete non-empty directory: \"~/.config/fish/functions\""
+  else
+    rmdir ~/.config/fish/functions
+  fi
+fi
+