Merge pull request #104 from junegunn/add-with-nth

Add --with-nth option

.gitignore

@@ -1,2 +1,3 @@
 pkg
 Gemfile.lock
+.DS_Store

.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.1"
+
+install: gem install curses minitest
+

README.md

@@ -24,26 +24,39 @@ git clone https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
+In case you don't have git installed:
+
+```sh
+mkdir -p ~/.fzf
+curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
+    tar xz --strip-components 1 -C ~/.fzf
+~/.fzf/install
+```
+
 The script will setup:
 
-- `fzf` executable
-- Key bindings (`CTRL-T`, `CTRL-R`, etc.)
-- Fuzzy auto-completion for bash
+- `fzf` function (bash, zsh, fish)
+- Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
+- Fuzzy auto-completion (bash)
+
+If you don't use any of the aforementioned shells, you have to manually place
+fzf executable in a directory included in `$PATH`. Key bindings and
+auto-completion will not be available in that case.
 
 ### Install as Vim plugin
 
-You can use any Vim plugin manager to install fzf for Vim. If you don't use one,
-I recommend you try [vim-plug](https://github.com/junegunn/vim-plug).
+Once you have cloned the repository, add the following line to your .vimrc.
 
-1. [Install vim-plug](https://github.com/junegunn/vim-plug#usage)
-2. Edit your .vimrc
+```vim
+set rtp+=~/.fzf
+```
 
-        call plug#begin()
-        Plug 'junegunn/fzf'
-        " ...
-        call plug#end()
+Or you may use [vim-plug](https://github.com/junegunn/vim-plug) to manage fzf
+inside Vim:
 
-3. Run `:PlugInstall`
+```vim
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
+```
 
 Usage
 -----
@@ -51,20 +64,40 @@ Usage
 ```
 usage: fzf [options]
 
-  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
-        --no-mouse       Disable mouse
+  Search
+    -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, --sort=MAX        Maximum number of matched items to sort (default: 1000)
+    +s, --no-sort         Do not sort the result. Keep the sequence unchanged.
+
+  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
 
   Environment variables
-    FZF_DEFAULT_COMMAND  Default command to use when input is tty
-    FZF_DEFAULT_OPTS     Defaults options. (e.g. "-x -m --sort 10000")
+    FZF_DEFAULT_COMMAND   Default command to use when input is tty
+    FZF_DEFAULT_OPTS      Defaults options. (e.g. "-x -m --sort 10000")
 ```
 
 fzf will launch curses-based finder, read the list from STDIN, and write the
@@ -89,7 +122,7 @@ If you want to preserve the exact sequence of the input, provide `--no-sort` (or
 history | fzf +s
 ```
 
-### Key binding
+### Keys
 
 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.
@@ -98,14 +131,16 @@ The following readline key bindings should also work as expected.
 
 - CTRL-A / CTRL-E
 - CTRL-B / CTRL-F
-- CTRL-W / CTRL-U
+- CTRL-H / CTRL-D
+- CTRL-W / CTRL-U / CTRL-Y
 - ALT-B / ALT-F
 
 If you enable multi-select mode with `-m` option, you can select multiple items
 with TAB or Shift-TAB key.
 
-You can also use mouse. Click on an item to select it or shift-click to select
-multiple items. Use mouse wheel to move the cursor up and down.
+You can also use mouse. Double-click on an item to select it or shift-click (or
+ctrl-click) to select multiple items. Use mouse wheel to move the cursor up and
+down.
 
 ### Extended-search mode
 
@@ -123,28 +158,33 @@ such as: `^music .mp3$ sbtrkt !rmx`
 | `'wild`  | Items that include `wild`        | exact-match (quoted) |
 | `!'fire` | Items that do not include `fire` | inverse-exact-match  |
 
+If you don't need fuzzy matching and do not wish to "quote" every word, start
+fzf with `-e` or `--extended-exact` option.
+
 Useful examples
 ---------------
 
 ```sh
-# vimf - Open selected file in Vim
-vimf() {
-  FILE=$(fzf) && vim "$FILE"
+# fe [FUZZY PATTERN] - Open the selected file with the default editor
+#   - Bypass fuzzy finder if there's only one match (--select-1)
+#   - Exit if there's no match (--exit-0)
+fe() {
+  local file
+  file=$(fzf --query="$1" --select-1 --exit-0)
+  [ -n "$file" ] && ${EDITOR:-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"
+  local dir
+  dir=$(find ${1:-*} -path '*/\.*' -prune \
+                  -o -type d -print 2> /dev/null | fzf +m) &&
+  cd "$dir"
 }
 
 # fh - repeat history
 fh() {
-  eval $(history | fzf +s | sed 's/ *[0-9]* *//')
+  eval $(([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s | sed 's/ *[0-9]* *//')
 }
 
 # fkill - kill process
@@ -153,25 +193,30 @@ fkill() {
 }
 ```
 
+For more examples, see [the wiki
+page](https://github.com/junegunn/fzf/wiki/examples).
+
 Key bindings for command line
 -----------------------------
 
-The install script will setup the following key bindings.
-
-### 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
-
-The source code can be found in `~/.fzf.bash`.
-
-### zsh
+The install script will setup the following key bindings for bash, zsh, and
+fish.
 
 - `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
 
-The source code can be found in `~/.fzf.zsh`.
+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`.
 
 Auto-completion
 ---------------
@@ -230,6 +275,14 @@ ssh **<TAB>
 telnet **<TAB>
 ```
 
+#### Environment variables / Aliases
+
+```sh
+unset **<TAB>
+export **<TAB>
+unalias **<TAB>
+```
+
 #### Settings
 
 ```sh
@@ -249,7 +302,11 @@ TODO :smiley:
 Usage as Vim plugin
 -------------------
 
-If you install fzf as a Vim plugin, `:FZF` command will be added.
+(Note: To use fzf in GVim, an external terminal emulator is required.)
+
+### `:FZF[!]`
+
+If you have set up fzf for Vim, `:FZF` command will be added.
 
 ```vim
 " Look for files under current directory
@@ -262,59 +319,124 @@ If you install fzf as a Vim plugin, `:FZF` command will be added.
 :FZF --no-sort -m /tmp
 ```
 
-You can override the source command which produces input to fzf.
+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
-let g:fzf_source = 'find . -type f'
+" 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'
 ```
 
-And you can predefine default options to fzf command.
+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                                                  |
+| `tmux_width`    | number/string | Use tmux vertical split with the given height (e.g. `20`, `50%`)   |
+| `tmux_height`   | number/string | Use tmux horizontal split with the given height (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 g:fzf_options = '--no-color --extended'
+let items = fzf#run({ 'options': '-m +c', 'dir': '~', 'source': 'ls' })
 ```
 
-For more advanced uses, you can call `fzf#run` function as follows.
+But if `sink` is given as a string, the command will be executed for each
+selected item.
 
 ```vim
-:call fzf#run('tabedit', '-m +c')
+" Each selected item will be opened in a new tab
+let items = fzf#run({ 'sink': 'tabe', 'options': '-m +c', 'dir': '~', 'source': 'ls' })
 ```
 
-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.
+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',
+\   'tmux_width': 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',
+\   'tmux_height': '40%'
+\ })<CR>
+```
+
+### 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
-`--disable-gems` option to Ruby.
+If you have any rendering issues, check the followings:
 
-- `time ruby ~/bin/fzf -h`
-    - 0.077 sec
-- `time ruby --disable-gems ~/bin/fzf -h`
-    - 0.025 sec
-
-You can define fzf function with the option as follows:
-
-```sh
-fzf() {
-  ruby --disable-gems ~/bin/fzf "$@"
-}
-export -f fzf
-```
-
-However, this is automatically set up in your .bashrc and .zshrc if you use the
-bundled [install](https://github.com/junegunn/fzf/blob/master/install) script.
-
-### Incorrect display on Ruby 1.8
-
-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.
+1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
+  contains `256` (e.g. `xterm-256color`)
+2. If you're on screen or tmux, `$TERM` should be either `screen` or
+  `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`.
+5. Ruby 1.9 or above is required for correctly displaying unicode characters.
 
 ### Ranking algorithm
 
@@ -330,6 +452,113 @@ This limit can be adjusted with `-s` option, or with the environment variable
 export FZF_DEFAULT_OPTS="--sort 20000"
 ```
 
+### 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
+# Feed the output of ag into fzf
+ag -l -g "" | 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
+```
+
+### `git ls-tree` for fast traversal
+
+If you're running fzf in a large git repository, `git ls-tree` can boost up the
+speed of the traversal.
+
+```sh
+# 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 splits
+
+It isn't too hard to write your own fzf-tmux combo like the default
+CTRL-T key binding. (Or is it?)
+
+```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
+```
+
+### Windows
+
+fzf works on [Cygwin](http://www.cygwin.com/) and
+[MSYS2](http://sourceforge.net/projects/msys2/). You may need to use `--black`
+option on MSYS2 to avoid rendering issues.
+
+### 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
 -------
 

Rakefile

@@ -6,3 +6,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
+task :default => :test

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,12 +8,35 @@
 # - $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
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
   prev="${COMP_WORDS[COMP_CWORD-1]}"
-  opts="-m --multi -x --extended -s --sort +s +i +c --no-color"
+  opts="
+    -x --extended
+    -e --extended-exact
+    -i +i
+    -n --nth
+    -d --delimiter
+    -s --sort +s
+    -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"
 
   case "${prev}" in
   --sort|-s)
@@ -30,8 +53,9 @@ _fzf_opts_completion() {
   return 0
 }
 
-_fzf_generic_completion() {
-  local cur base dir leftover matches trigger
+_fzf_path_completion() {
+  local cur base dir leftover matches trigger cmd orig
+  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER:-**}
   cur="${COMP_WORDS[COMP_CWORD]}"
@@ -46,7 +70,7 @@ _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"
         done)
         matches=${matches% }
@@ -61,25 +85,63 @@ _fzf_generic_completion() {
       dir=$(dirname "$dir")
       [[ "$dir" =~ /$ ]] || dir="$dir"/
     done
+  else
+    shift
+    shift
+    orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+    [ -n "$orig" ] && type "$orig" > /dev/null 2>&1 && $orig "$@"
+  fi
+}
+
+_fzf_list_completion() {
+  local cur selected trigger cmd src ret
+  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
+    orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+    if [ -n "$orig" ] && type "$orig" > /dev/null; 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
   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() {
@@ -97,64 +159,69 @@ _fzf_kill_completion() {
 }
 
 _fzf_telnet_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  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_list_completion '+m' "$@" << "EOF"
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{if (length($2) > 0) {print $2}}' | sort -u
+EOF
 }
 
 _fzf_ssh_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  tput sc
-  selected=$(cat \
-    <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | grep -i ^host) \
-    <(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_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
 
+d_cmds="cd pushd rmdir"
+f_cmds="
+  awk cat diff diff3
+  emacs ex file ftp g++ gcc gvim head hg java
+  javac ld less more mvim patch perl python ruby
+  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 "cd pushd rmdir"; do
+for cmd in $d_cmds; do
   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
+for cmd in $f_cmds; do
   complete -F _fzf_file_completion -o default -o bashdefault $cmd
 done
 
 # Anything
-for cmd in "
-  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
+for cmd in $a_cmds; do
   complete -F _fzf_all_completion -o default -o bashdefault $cmd
 done
 
@@ -165,3 +232,9 @@ complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
 complete -F _fzf_ssh_completion -o default -o bashdefault ssh
 complete -F _fzf_telnet_completion -o default -o bashdefault telnet
 
+# 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.7.0'
+  spec.version       = '0.8.4'
   spec.authors       = ['Junegunn Choi']
   spec.email         = ['junegunn.c@gmail.com']
   spec.description   = %q{Fuzzy finder for your shell}
@@ -13,5 +13,5 @@ Gem::Specification.new do |spec|
   spec.files         = %w[fzf.gemspec]
   spec.executables   = 'fzf'
 
-  spec.add_runtime_dependency 'curses', '~> 1.0.0'
+  spec.extensions   += ['ext/mkrf_conf.rb']
 end

install

@@ -12,10 +12,9 @@ if [ $? -ne 0 ]; then
 fi
 
 # System ruby is preferred
-curses_check="begin; require 'curses'; rescue Exception; exit 1; end"
 system_ruby=/usr/bin/ruby
 if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
-  $system_ruby --disable-gems -e "$curses_check" 2> /dev/null
+  $system_ruby --disable-gems -rcurses -e0 2> /dev/null
   [ $? -eq 0 ] && ruby=$system_ruby
 fi
 
@@ -23,16 +22,23 @@ echo "OK ($ruby)"
 
 # Curses-support
 echo -n "Checking Curses support ... "
-"$ruby" -e "$curses_check"
+"$ruby" -rcurses -e0 2> /dev/null
 if [ $? -eq 0 ]; then
   echo "OK"
 else
   echo "Not found"
   echo "Installing 'curses' gem ... "
-  /usr/bin/env gem install curses
+  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."
-    echo "Try installing it as root: sudo gem install curses"
+    if [[ $(uname -r) =~ 'ARCH' ]]; then
+      echo "Make sure that base-devel package group is installed."
+    fi
     exit 1
   fi
 fi
@@ -42,7 +48,7 @@ echo -n "Checking Ruby version ... "
 "$ruby" -e 'exit RUBY_VERSION >= "1.9"'
 if [ $? -eq 0 ]; then
   echo ">= 1.9"
-  "$ruby" --disable-gems -e "$curses_check"
+  "$ruby" --disable-gems -rcurses -e0 2> /dev/null
   if [ $? -eq 0 ]; then
     fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
   else
@@ -70,7 +76,7 @@ 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
@@ -92,51 +98,123 @@ EOF
 
   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
-bind '"\er": redraw-current-line'
-
-# CTRL-T - Paste the selected file path into the command line
 __fsel() {
-  find * -path '*/\.*' -prune \
+  command find * -path '*/\.*' -prune \
     -o -type f -print \
+    -o -type d -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"'
+if [[ $- =~ i ]]; then
 
-EOF
+__fsel_tmux() {
+  local height
+  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 '*/\.*' -prune -o -type d -print 2> /dev/null | 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 +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 +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
-      cat >> $src << "EOF"
+      cat >> $src << "EOFZF"
 # Key bindings
 # ------------
 # CTRL-T - Paste the selected file path(s) into the command line
-fzf-file-widget() {
-  local FILES
-  local IFS="
-"
-  FILES=($(
-    find * -path '*/\.*' -prune \
+__fsel() {
+  set -o nonomatch
+  command 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
+    -o -type d -print \
+    -o -type l -print 2> /dev/null | fzf -m | while read item; do
+    printf '%q ' "$item"
+  done
+  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 "${$(set -o nonomatch; command find -L * -path '*/\.*' -prune \
           -o -type d -print 2> /dev/null | fzf):-.}"
   zle reset-prompt
 }
@@ -145,40 +223,159 @@ 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 +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
-for shell in bash zsh; do
-  rc=~/.${shell}rc
-  src="source ~/.fzf.${shell}"
+# fish
+has_fish=0
+if [ -n "$(which fish)" ]; then
+  has_fish=1
+  echo -n "Generate ~/.config/fish/functions/fzf.fish ... "
+  mkdir -p ~/.config/fish/functions
+  cat > ~/.config/fish/functions/fzf.fish << EOFZF
+function fzf
+  $fzf_cmd \$argv
+end
+EOFZF
+  echo "OK"
 
-  echo "Update $rc:"
-  echo "  - $src"
-  if [ $(grep -F "$src" $rc | wc -l) -gt 0 ]; then
-    echo "    - Not added (already being sourced)"
+  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 * -path '*/\.*' -prune \
+      -o -type f -print \
+      -o -type d -print \
+      -o -type l -print 2> /dev/null
+  end
+
+  function __fzf_list_dir
+    command find -L * -path '*/\.*' -prune -o -type d -print 2> /dev/null
+  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_ctrl_r
+    history | fzf +s +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
-    echo $src >> $rc
-    echo "    - Added"
+    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
 
+if [ $key_bindings -eq 0 -a $has_fish -eq 1 ]; then
+  bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
+  append_line "fzf_key_bindings" "$bind_file"
+
+  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. Reload your .bashrc or .zshrc.
+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
 
-To uninstall fzf, simply remove the added line.
+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) 2014 Junegunn Choi
 "
 " MIT License
 "
@@ -21,39 +21,229 @@
 " 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:min_tmux_width  = 10
+let s:min_tmux_height = 3
+let s:default_tmux_height = '40%'
+let s:launcher = 'xterm -e bash -ic %s'
+let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! s:fzf_exec()
+  if !exists('s:exec')
+    call system('type fzf')
+    if v:shell_error
+      let s:exec = executable(s:fzf_rb) ? s:fzf_rb : ''
+    else
+      let s:exec = 'fzf'
+    endif
+    return s:fzf_exec()
+  elseif empty(s:exec)
+    unlet s:exec
+    throw 'fzf executable not found'
+  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')
+    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, ...)
-  let cwd = getcwd()
+function! fzf#run(...) abort
+  let dict   = exists('a:1') ? a:1 : {}
+  let temps  = { 'result': tempname() }
+  let optstr = get(dict, 'options', '')
   try
-    let args = copy(a:000)
-    if len(args) > 0 && isdirectory(expand(args[-1]))
-      let dir = remove(args, -1)
-      execute 'chdir '.s:escape(dir)
+    let fzf_exec = s:fzf_exec()
+  catch
+    throw v:exception
+  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)
-    let tf      = tempname()
-    let prefix  = exists('g:fzf_source') ? g:fzf_source.'|' : ''
-    let fzf     = executable(s:exec)     ? s:exec : 'fzf'
-    let options = empty(argstr)          ? get(g:, 'fzf_options', '') : argstr
-    execute "silent !".prefix.fzf.' '.options." > ".tf
-    if !v:shell_error
-      for line in readfile(tf)
-        if !empty(line)
-          execute a:command.' '.s:escape(line)
+  else
+    let prefix = ''
+  endif
+  let command = prefix.fzf_exec.' '.optstr.' > '.temps.result
+
+  if s:tmux_enabled() && s:tmux_splittable(dict)
+    return s:execute_tmux(dict, command, temps)
+  else
+    return s:execute(dict, command, temps)
+  endif
+endfunction
+
+function! s:tmux_splittable(dict)
+  return
+  \ min([&columns, get(a:dict, 'tmux_width', 0)]) >= s:min_tmux_width ||
+  \ min([&lines, get(a:dict, 'tmux_height', get(a:dict, 'tmux', 0))]) >= s:min_tmux_height
+endfunction
+
+function! s:pushd(dict)
+  if !empty(get(a:dict, 'dir', ''))
+    let a:dict.prev_dir = getcwd()
+    execute 'chdir '.s:escape(a:dict.dir)
+  endif
+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, 0)
+  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 = s:env_var('FZF_DEFAULT_OPTS').s:env_var('FZF_DEFAULT_COMMAND').a:command
+  if !empty(get(a:dict, 'dir', ''))
+    let command = 'cd '.s:escape(a:dict.dir).' && '.command
+  endif
+
+  let splitopt = '-v'
+  if has_key(a:dict, 'tmux_width')
+    let splitopt = '-h'
+    let size = a:dict.tmux_width
+  else
+    let size = get(a:dict, 'tmux_height', get(a:dict, 'tmux'))
+  endif
+
+  if type(size) == 1 && size =~ '%$'
+    let sizeopt = '-p '.size[0:-2]
+  else
+    let sizeopt = '-l '.size
+  endif
+
+  let s:pane = substitute(
+    \ system(
+      \ printf(
+        \ 'tmux split-window %s %s -P -F "#{pane_id}" %s',
+        \ splitopt, sizeopt, s:shellesc(command))), '\n', '', 'g')
+  let s:dict = a:dict
+  let s:temps = a:temps
+
+  augroup fzf_tmux
+    autocmd!
+    autocmd VimResized * nested call s:tmux_check()
+  augroup END
+endfunction
+
+function! s:tmux_check()
+  let panes = split(system('tmux list-panes -a -F "#{pane_id}"'), '\n')
+
+  if index(panes, s:pane) < 0
+    augroup fzf_tmux
+      autocmd!
+    augroup END
+
+    call s:callback(s:dict, s:temps, 1)
+    redraw
+  endif
+endfunction
+
+function! s:callback(dict, temps, cd)
+  if !filereadable(a:temps.result)
+    let lines = []
+  else
+    if a:cd | call s:pushd(a:dict) | endif
+
+    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
-    execute 'chdir '.s:escape(cwd)
-    redraw!
+  endif
+
+  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.tmux = 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
 

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_fzf.rb'], result
+
+Execute (fzf#run with Funcref command):
+  let g:ret = []
+  function! g:proc(e)
+    call add(g:ret, a:e)
+  endfunction
+  let result = sort(fzf#run({ 'sink': function('g:proc'), 'options': '--filter e', 'dir': g:dir }))
+  AssertEqual ['fzf.vader', 'test_fzf.rb'], result
+  AssertEqual ['fzf.vader', 'test_fzf.rb'], sort(g:ret)
+
+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,13 +1,59 @@
 #!/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 TestFZF < MiniTest::Unit::TestCase
+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
+  end
+end
+
+class TestFZF < MiniTest::Unit::TestCase
   def setup
     ENV.delete 'FZF_DEFAULT_SORT'
     ENV.delete 'FZF_DEFAULT_OPTS'
@@ -21,6 +67,19 @@ class TestFZF < MiniTest::Unit::TestCase
     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
@@ -28,80 +87,139 @@ class TestFZF < MiniTest::Unit::TestCase
     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 --no-mouse'
+    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.get
-    assert_equal true,    fzf.extended
+                          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 --extended --no-mouse]
+    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.get
-    assert_equal true,    fzf.extended
+    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
 
-    fzf = FZF.new %w[--sort=2000 --no-color --multi +i --query hello
-                     --no-sort -i --color --no-multi]
+    # 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 'hello', fzf.query.get
-    assert_equal false,   fzf.extended
+    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[-s 2000 +c -m +i -qhello -x]
+    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.get
-    assert_equal true,    fzf.extended
+    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
-                     -s 3000 -c +m -i -q world +x]
+    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.get
-    assert_equal false,   fzf.extended
-
-    fzf = FZF.new %w[--query hello +s -s 2000 --query=world]
-    assert_equal 2000,    fzf.sort
-    assert_equal 'world', fzf.query.get
+    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]].each do |argv|
+    [
+      %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
 
-  # 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
+  end if RUBY_VERSION >= '1.9'
 
   def test_trim
     fzf = FZF.new []
@@ -114,7 +232,7 @@ class TestFZF < MiniTest::Unit::TestCase
     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
+  end if RUBY_VERSION >= '1.9'
 
   def test_format
     fzf = FZF.new []
@@ -347,7 +465,7 @@ class TestFZF < MiniTest::Unit::TestCase
        ["0____1",   [[0, 6]]],
        ["0_____1",  [[0, 7]]],
        ["0______1", [[0, 8]]]],
-      FZF.new([]).sort_by_rank(matcher.match(list, '01', '', '')))
+      FZF.sort(matcher.match(list, '01', '', '')))
 
     assert_equal(
       [["01",       [[0, 1], [1, 2]]],
@@ -358,72 +476,335 @@ class TestFZF < MiniTest::Unit::TestCase
        ["____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', '', '')))
+      FZF.sort(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 __', '', '')))
+      [["_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
 
-  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]])
+  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
 
-      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")
+    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 = fzf.convert_item item
+    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
+  end
 end
 

uninstall

@@ -0,0 +1,78 @@
+#!/bin/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
+