Update install script

😭

.gitignore

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

.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+
+install:
+- sudo apt-get install -y libncurses-dev lib32ncurses5-dev
+- sudo add-apt-repository -y ppa:pi-rho/dev
+- sudo apt-get update
+- sudo apt-get install -y tmux=1.9a-1~ppa1~p
+
+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 ]

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,62 +8,50 @@ 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
 ------------
 
-Download [fzf executable](https://raw.github.com/junegunn/fzf/master/fzf) and
-put it somewhere in your search $PATH.
-
-```sh
-mkdir -p ~/bin
-wget https://raw.github.com/junegunn/fzf/master/fzf -O ~/bin/fzf
-chmod +x ~/bin/fzf
-```
-
-Or you can just clone this repository and run
+Clone this repository and run
 [install](https://github.com/junegunn/fzf/blob/master/install) script.
 
 ```sh
-git clone https://github.com/junegunn/fzf.git
-fzf/install
+git clone https://github.com/junegunn/fzf.git ~/.fzf
+~/.fzf/install
 ```
 
-Make sure that ~/bin is included in $PATH.
+In case you don't have git installed:
 
 ```sh
-export PATH=$PATH:~/bin
+mkdir -p ~/.fzf
+curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
+    tar xz --strip-components 1 -C ~/.fzf
+~/.fzf/install
 ```
 
-### Install as Ruby gem
+The script will setup:
 
-fzf can be installed as a Ruby gem
+- `fzf` function (bash, zsh, fish)
+- Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
+- Fuzzy auto-completion (bash)
 
-```
-gem install fzf
-```
-
-It's a bit easier to install and update the script but the Ruby gem version
-takes slightly longer to start.
+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
 -----
@@ -71,12 +59,40 @@ Usage
 ```
 usage: fzf [options]
 
-  -m, --multi      Enable multi-select
-  -x, --extended   Extended-search mode
-  -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-sensitive match
-  +c, --no-color   Disable colors
+  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 will launch curses-based finder, read the list from STDIN, and write the
@@ -101,21 +117,26 @@ 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 will terminate the finder.
+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
+- 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. 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
 
 With `-x` or `--extended` option, fzf will start in "extended-search mode".
@@ -132,134 +153,390 @@ 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.
-
-```vim
-:FZF
-:FZF --no-sort
-```
-
-You can override the command which produces input to fzf.
-
-```vim
-let g:fzf_command = 'find . -type f'
-```
-
-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 bash examples
---------------------
+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
 fkill() {
   ps -ef | sed 1d | fzf -m | awk '{print $2}' | xargs kill -${1:-9}
 }
-
-# (Assuming you don't use the default CTRL-T and CTRL-R)
-
-# CTRL-T - Paste the selected file path into the command line
-bind '"\er": redraw-current-line'
-bind '"\C-t": " \C-u \C-a\C-k$(fzf)\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 widgets
------------
+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 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
+
+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
+---------------
+
+Disclaimer: *Auto-completion feature is currently experimental, it can change
+over time*
+
+### bash
+
+#### Files and directories
+
+Fuzzy completion for files and directories can be triggered if the word before
+the cursor ends with the trigger sequence which is by default `**`.
+
+- `COMMAND [DIRECTORY/][FUZZY_PATTERN]**<TAB>`
 
 ```sh
-# CTRL-T - Paste the selected file(s) path into the command line
-fzf-file-widget() {
-  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
+# Files under current directory
+# - You can select multiple items with TAB key
+vim **<TAB>
 
-# ALT-C - cd into the selected directory
-fzf-cd-widget() {
-  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
+# Files under parent directory
+vim ../**<TAB>
 
-# CTRL-R - Paste the selected command from history into the command line
-fzf-history-widget() {
-  LBUFFER=$(history | fzf +s | sed "s/ *[0-9]* *//")
-  zle redisplay
-}
-zle     -N   fzf-history-widget
-bindkey '^R' fzf-history-widget
+# Files under parent directory that match `fzf`
+vim ../fzf**<TAB>
+
+# Files under your home directory
+vim ~/**<TAB>
+
+
+# Directories under current directory (single-selection)
+cd **<TAB>
+
+# Directories under ~/github that match `fzf`
+cd ~/github/fzf**<TAB>
 ```
 
+#### Process IDs
+
+Fuzzy completion for PIDs is provided for kill command. In this case
+there is no trigger sequence, just press tab key after kill command.
+
+```sh
+# Can select multiple processes with <TAB> or <Shift-TAB> keys
+kill -9 <TAB>
+```
+
+#### Host names
+
+For ssh and telnet commands, fuzzy completion for host names is provided. The
+names are extracted from /etc/hosts and ~/.ssh/config.
+
+```sh
+ssh **<TAB>
+telnet **<TAB>
+```
+
+#### Environment variables / Aliases
+
+```sh
+unset **<TAB>
+export **<TAB>
+unalias **<TAB>
+```
+
+#### Settings
+
+```sh
+# Use ~~ as the trigger sequence instead of the default **
+export FZF_COMPLETION_TRIGGER='~~'
+
+# Options to fzf command
+export FZF_COMPLETION_OPTS='+c -x'
+```
+
+### zsh
+
+TODO :smiley:
+
+(Pull requests are appreciated.)
+
+Usage as Vim plugin
+-------------------
+
+(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
+: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                                                  |
+| `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 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',
+\   '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
+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`.
 
-Define fzf alias 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
-alias fzf='ruby --disable-gems ~/bin/fzf'
+# 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
 ```
 
-### Incorrect display on Ruby 1.8
+### `git ls-tree` for fast 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.
+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
+```
+
+### 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
 ------

Rakefile

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

@@ -0,0 +1,247 @@
+#!/bin/bash
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/-completion.bash
+#
+# - $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="
+    -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)
+    COMPREPLY=( $(compgen -W "$(seq 2000 1000 10000)" -- ${cur}) )
+    return 0
+    ;;
+  esac
+
+  if [[ ${cur} =~ ^-|\+ ]]; then
+    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    return 0
+  fi
+
+  return 0
+}
+
+_fzf_handle_dynamic_completion() {
+  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=()
+  trigger=${FZF_COMPLETION_TRIGGER:-**}
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  if [[ ${cur} == *"$trigger" ]]; then
+    base=${cur:0:${#cur}-${#trigger}}
+    eval base=$base
+
+    dir="$base"
+    while [ 1 ]; do
+      if [ -z "$dir" -o -d "$dir" ]; then
+        leftover=${base/#"$dir"}
+        leftover=${leftover/#\/}
+        [ "$dir" = './' ] && dir=''
+        tput sc
+        matches=$(find -L "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+          printf '%q ' "$item"
+        done)
+        matches=${matches% }
+        if [ -n "$matches" ]; then
+          COMPREPLY=( "$matches" )
+        else
+          COMPREPLY=( "$cur" )
+        fi
+        tput rc
+        return 0
+      fi
+      dir=$(dirname "$dir")
+      [[ "$dir" =~ /$ ]] || dir="$dir"/
+    done
+  else
+    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_path_completion \
+    "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
+    "-m" "$@"
+}
+
+_fzf_file_completion() {
+  _fzf_path_completion \
+    "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
+    "-m" "$@"
+}
+
+_fzf_dir_completion() {
+  _fzf_path_completion \
+    "-name .git -prune -o -name .svn -prune -o -type d -print" \
+    "" "$@"
+}
+
+_fzf_kill_completion() {
+  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
+
+  local selected
+  tput sc
+  selected=$(ps -ef | sed 1d | fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
+  tput rc
+
+  if [ -n "$selected" ]; then
+    COMPREPLY=( "$selected" )
+    return 0
+  fi
+}
+
+_fzf_telnet_completion() {
+  _fzf_list_completion '+m' "$@" << "EOF"
+  \grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{if (length($2) > 0) {print $2}}' | sort -u
+EOF
+}
+
+_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
+
+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 $d_cmds; do
+  complete -F _fzf_dir_completion -o default -o bashdefault $cmd
+done
+
+# File
+for cmd in $f_cmds; do
+  complete -F _fzf_file_completion -o default -o bashdefault $cmd
+done
+
+# Anything
+for cmd in $a_cmds; do
+  complete -F _fzf_all_completion -o default -o bashdefault $cmd
+done
+
+# Kill completion
+complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
+
+# Host completion
+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-completion.zsh

@@ -0,0 +1,9 @@
+#!/bin/zsh
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/-completion.zsh
+#
+
+# TODO

fzf.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = 'fzf'
-  spec.version       = '0.4.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,7 +1,497 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-cd `dirname $BASH_SOURCE`
-mkdir -p ~/bin
-ln -sf `pwd`/fzf ~/bin/fzf
-chmod +x ~/bin/fzf
+version=0.9.1
+
+cd $(dirname $BASH_SOURCE)
+fzf_base=$(pwd)
+
+ask() {
+  read -p "$1 ([y]/n) " -n 1 -r
+  echo
+  [[ ! $REPLY =~ ^[Nn]$ ]]
+}
+
+check_binary() {
+  echo -n "  - Checking fzf executable ... "
+  local output=$("$fzf_base"/bin/fzf --version 2>&1)
+  if [ "$version" = "$output" ]; then
+    echo "$output"
+    binary_error=""
+  else
+    echo "$output != $version"
+    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
+ask "Do you want to add auto-completion support?"
+auto_completion=$?
+
+# Key-bindings
+ask "Do you want to add key bindings?"
+key_bindings=$?
+
+echo
+for shell in bash zsh; do
+  echo -n "Generate ~/.fzf.$shell ... "
+  src=~/.fzf.${shell}
+
+  fzf_completion="[[ \$- =~ i ]] && source $fzf_base/fzf-completion.${shell}"
+  if [ $auto_completion -ne 0 ]; then
+    fzf_completion="# $fzf_completion"
+  fi
+
+  if [ -n "$binary_error" ]; then
+    cat > $src << EOF
+# Setup fzf function
+# ------------------
+unalias fzf 2> /dev/null
+fzf() {
+  $fzf_cmd "\$@"
+}
+export -f fzf > /dev/null
+
+# Auto-completion
+# ---------------
+$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 << "EOFZF"
+# Key bindings
+# ------------
+__fsel() {
+  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
+}
+
+if [[ $- =~ i ]]; then
+
+__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 << "EOFZF"
+# Key bindings
+# ------------
+# CTRL-T - Paste the selected file path(s) into the command line
+__fsel() {
+  set -o nonomatch
+  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
+}
+
+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 "${$(set -o nonomatch; command find -L * -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
+fzf-history-widget() {
+  LBUFFER=$(fc -l 1 | fzf +s +m -n2..,.. | sed "s/ *[0-9*]* *//")
+  zle redisplay
+}
+zle     -N   fzf-history-widget
+bindkey '^R' fzf-history-widget
+
+fi
+EOFZF
+    fi
+  fi
+
+  echo "OK"
+done
+
+# 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
+  if [ -n "$binary_error" ]; then
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
+function fzf
+  $fzf_cmd \$argv
+end
+EOFZF
+  else
+    cat > ~/.config/fish/functions/fzf.fish << EOFZF
+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 * -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_reverse
+    if which tac > /dev/null
+      tac $argv
+    else
+      tail -r $argv
+    end
+  end
+
+  function __fzf_ctrl_r
+    history | __fzf_reverse | 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
+    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. 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,25 +21,231 @@
 " 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_go = expand('<sfile>:h:h').'/bin/fzf'
+let s:fzf_rb = expand('<sfile>:h:h').'/fzf'
 
-function! s:fzf(args)
-  try
-    let tf = tempname()
-    let prefix = exists('g:fzf_command') ? g:fzf_command.'|' : ''
-    let fzf = executable(s:exec) ? s:exec : 'fzf'
-    execute "silent !".prefix.fzf." ".a:args." > ".tf
-    if !v:shell_error
-      let file = join(readfile(tf), '')
-      if !empty(file)
-        execute 'silent e '.file
-      endif
+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_go) ?
+            \ s:fzf_go : (executable(s:fzf_rb) ? s:fzf_rb : '')
+    else
+      let s:exec = 'fzf'
     endif
-  finally
-    silent! call delete(tf)
-    redraw!
-  endtry
+    return s:fzf_exec()
+  elseif empty(s:exec)
+    unlet s:exec
+    throw 'fzf executable not found'
+  else
+    return s:exec
+  endif
 endfunction
 
-command! -nargs=* FZF call s:fzf(<q-args>)
+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(...) abort
+  let dict   = exists('a:1') ? a:1 : {}
+  let temps  = { 'result': tempname() }
+  let optstr = get(dict, 'options', '')
+  try
+    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
+  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
+  endif
+
+  for tf in values(a:temps)
+    silent! call delete(tf)
+  endfor
+
+  call s:popd(a:dict)
+
+  return lines
+endfunction
+
+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
 

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.1.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.1.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.1.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,117 @@
+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
+```
+
+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)
+
+[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.1"
+
+// fzf events
+const (
+	EvtReadNew util.EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtClose
+)

src/core.go

@@ -0,0 +1,196 @@
+/*
+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
+	reader := Reader{func(str string) { chunkList.Push(str) }, eventBox}
+	go reader.ReadSource()
+
+	// Matcher
+	patternBuilder := func(runes []rune) *Pattern {
+		return BuildPattern(
+			opts.Mode, opts.Case, opts.Nth, opts.Delimiter, runes)
+	}
+	matcher := NewMatcher(patternBuilder, opts.Sort > 0, eventBox)
+
+	// Defered-interactive / Non-interactive
+	//   --select-1 | --exit-0 | --filter
+	if filtering := opts.Filter != nil; filtering || opts.Select1 || opts.Exit0 {
+		limit := 0
+		var patternString string
+		if filtering {
+			patternString = *opts.Filter
+		} else {
+			if opts.Select1 || opts.Exit0 {
+				limit = 1
+			}
+			patternString = opts.Query
+		}
+		pattern := patternBuilder([]rune(patternString))
+
+		looping := true
+		eventBox.Unwatch(EvtReadNew)
+		for looping {
+			eventBox.Wait(func(events *util.Events) {
+				for evt := range *events {
+					switch evt {
+					case EvtReadFin:
+						looping = false
+						return
+					}
+				}
+			})
+		}
+
+		snapshot, _ := chunkList.Snapshot()
+		merger, cancelled := matcher.scan(MatchRequest{
+			chunks:  snapshot,
+			pattern: pattern}, limit)
+
+		if !cancelled && (filtering ||
+			opts.Exit0 && merger.Length() == 0 ||
+			opts.Select1 && merger.Length() == 1) {
+			if opts.PrintQuery {
+				fmt.Println(patternString)
+			}
+			for i := 0; i < merger.Length(); i++ {
+				fmt.Println(merger.Get(i).AsString())
+			}
+			os.Exit(0)
+		}
+	}
+
+	// Go interactive
+	go matcher.Loop()
+
+	// Terminal I/O
+	terminal := NewTerminal(opts, eventBox)
+	go terminal.Loop()
+
+	// 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)
+
+				case EvtSearchNew:
+					snapshot, _ := chunkList.Snapshot()
+					matcher.Reset(snapshot, terminal.Input(), true)
+					delay = false
+
+				case EvtSearchProgress:
+					switch val := value.(type) {
+					case float32:
+						terminal.UpdateProgress(val)
+					}
+
+				case EvtSearchFin:
+					switch val := value.(type) {
+					case *Merger:
+						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,426 @@
+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 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,110 @@
+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)
+}
+
+func compareRanks(irank Rank, jrank Rank) 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
+	}
+
+	if irank.index <= jrank.index {
+		return true
+	}
+	return false
+}

src/item_test.go

@@ -0,0 +1,67 @@
+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}) ||
+		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}) ||
+		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}) ||
+		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}) {
+		t.Error("Invalid order")
+	}
+}
+
+// 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,214 @@
+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
+}
+
+// Matcher is responsible for performing search
+type Matcher struct {
+	patternBuilder func([]rune) *Pattern
+	sort           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, eventBox *util.EventBox) *Matcher {
+	return &Matcher{
+		patternBuilder: patternBuilder,
+		sort:           sort,
+		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, 0)
+		}
+
+		if !cancelled {
+			m.mergerCache[patternString] = merger
+			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, limit int) (*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 {
+				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 limit > 0 && matchCount > limit {
+			return nil, wait() // For --select-1 and --exit-0
+		}
+
+		if count == numChunks {
+			break
+		}
+
+		if !empty && m.reqBox.Peak(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), false
+}
+
+// Reset is called to interrupt/signal the ongoing search
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool) {
+	pattern := m.patternBuilder(patternRunes)
+
+	var event util.EventType
+	if cancel {
+		event = reqReset
+	} else {
+		event = reqRetry
+	}
+	m.reqBox.Set(event, MatchRequest{chunks, pattern})
+}

src/merger.go

@@ -0,0 +1,84 @@
+package fzf
+
+import "fmt"
+
+// Merger with no data
+var EmptyMerger = NewMerger([][]*Item{}, 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
+	count   int
+}
+
+// NewMerger returns a new Merger
+func NewMerger(lists [][]*Item, sorted bool) *Merger {
+	mg := Merger{
+		lists:   lists,
+		merged:  []*Item{},
+		cursors: make([]int, len(lists)),
+		sorted:  sorted,
+		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 len(mg.lists) == 1 {
+		return mg.lists[0][idx]
+	} else if !mg.sorted {
+		for _, list := range mg.lists {
+			numItems := len(list)
+			if idx < numItems {
+				return list[idx]
+			}
+			idx -= numItems
+		}
+		panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+	}
+	return mg.mergedGet(idx)
+}
+
+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) {
+					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)
+	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)
+	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)
+	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,282 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/junegunn/go-shellwords"
+)
+
+const usage = `usage: fzf [options]
+
+  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            Sort the result
+    +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")
+
+`
+
+// 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
+	Multi      bool
+	Mouse      bool
+	Color      bool
+	Color256   bool
+	Black      bool
+	Reverse    bool
+	Prompt     string
+	Query      string
+	Select1    bool
+	Exit0      bool
+	Filter     *string
+	PrintQuery bool
+	Version    bool
+}
+
+func defaultOptions() *Options {
+	return &Options{
+		Mode:       ModeFuzzy,
+		Case:       CaseSmart,
+		Nth:        make([]Range, 0),
+		WithNth:    make([]Range, 0),
+		Delimiter:  nil,
+		Sort:       1000,
+		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,
+		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 "-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 "--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)
+			}
+		}
+	}
+}
+
+// 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,37 @@
+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")
+		if len(ranges) != 8 ||
+			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
+			ranges[1].begin != 1 || ranges[1].end != rangeEllipsis ||
+			ranges[2].begin != 2 || ranges[2].end != 3 ||
+			ranges[3].begin != 4 || ranges[3].end != -1 ||
+			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 {
+			t.Errorf("%s", ranges)
+		}
+	}
+}

src/pattern.go

@@ -0,0 +1,309 @@
+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
+			}
+		}
+	}
+
+	var matches []*Item
+	if p.mode == ModeFuzzy {
+		matches = p.fuzzyMatch(space)
+	} else {
+		matches = p.extendedMatch(space)
+	}
+
+	if !p.hasInvTerm {
+		_cache.Add(chunk, cacheKey, matches)
+	}
+	return matches
+}
+
+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(chunk *Chunk) []*Item {
+	matches := []*Item{}
+	for _, item := range *chunk {
+		input := p.prepareInput(item)
+		if sidx, eidx := p.iter(algo.FuzzyMatch, input, p.text); sidx >= 0 {
+			matches = append(matches,
+				dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
+		}
+	}
+	return matches
+}
+
+func (p *Pattern) extendedMatch(chunk *Chunk) []*Item {
+	matches := []*Item{}
+	for _, item := range *chunk {
+		input := p.prepareInput(item)
+		offsets := []Offset{}
+		for _, term := range p.terms {
+			pfun := p.procFun[term.typ]
+			if sidx, eidx := p.iter(pfun, input, term.text); sidx >= 0 {
+				if term.inv {
+					break
+				}
+				offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
+			} else if term.inv {
+				offsets = append(offsets, Offset{0, 0})
+			}
+		}
+		if len(offsets) == len(p.terms) {
+			matches = append(matches, dupItem(item, offsets))
+		}
+	}
+	return matches
+}
+
+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,115 @@
+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 _, fun := range []func(*Chunk) []*Item{pattern.fuzzyMatch, pattern.extendedMatch} {
+		chunk := Chunk{
+			&Item{
+				text:        strptr("junegunn"),
+				origText:    strptr("junegunn.choi"),
+				transformed: trans},
+		}
+		matches := fun(&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.Peak(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.Peak(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.Peak(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.Peak(EvtReadNew) {
+		t.Error("Command failed. EvtReadNew should be set")
+	}
+}

src/terminal.go

@@ -0,0 +1,654 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"sync"
+	"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
+	tac        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
+}
+
+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{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
+
+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,
+		tac:        opts.Sort == 0,
+		reverse:    opts.Reverse,
+		cx:         displayWidth(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,
+		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) listIndex(y int) int {
+	if t.tac {
+		return t.merger.Length() - y - 1
+	}
+	return y
+}
+
+func (t *Terminal) output() {
+	if t.printQuery {
+		fmt.Println(string(t.input))
+	}
+	if len(t.selected) == 0 {
+		cnt := t.merger.Length()
+		if cnt > 0 && cnt > t.cy {
+			fmt.Println(t.merger.Get(t.listIndex(t.cy)).AsString())
+		}
+	} 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 displayWidth(runes []rune) int {
+	l := 0
+	for _, r := range runes {
+		l += runewidth.RuneWidth(r)
+	}
+	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(t.listIndex(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) {
+	currentWidth := displayWidth(runes)
+	trimmed := 0
+
+	for currentWidth > width && len(runes) > 0 {
+		sz := len(runes)
+		currentWidth -= runewidth.RuneWidth(runes[sz-1])
+		runes = runes[:sz-1]
+		trimmed++
+	}
+	return runes, trimmed
+}
+
+func trimLeft(runes []rune, width int) ([]rune, int32) {
+	currentWidth := displayWidth(runes)
+	var trimmed int32
+
+	for currentWidth > width && len(runes) > 0 {
+		currentWidth -= runewidth.RuneWidth(runes[0])
+		runes = runes[1:]
+		trimmed++
+	}
+	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
+	for _, offset := range offsets {
+		b := util.Max32(index, offset[0])
+		e := util.Max32(index, offset[1])
+		C.CPrint(col1, bold, string(text[index:b]))
+		C.CPrint(col2, bold, string(text[b:e]))
+		index = e
+	}
+	if index < int32(len(text)) {
+		C.CPrint(col1, bold, string(text[index:]))
+	}
+}
+
+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() {
+	{ // 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)
+		}()
+	}
+
+	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()
+						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() {
+			idx := t.listIndex(t.cy)
+			if idx < t.merger.Length() {
+				item := t.merger.Get(idx)
+				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.listIndex(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,204 @@
+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
+}
+
+// ParseRange parses nth-expression and returns the corresponding Range object
+func ParseRange(str *string) (Range, bool) {
+	if (*str) == ".." {
+		return Range{rangeEllipsis, rangeEllipsis}, true
+	} else if strings.HasPrefix(*str, "..") {
+		end, err := strconv.Atoi((*str)[2:])
+		if err != nil || end == 0 {
+			return Range{}, false
+		}
+		return Range{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 Range{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 {
+			return Range{}, false
+		}
+		return Range{begin, end}, true
+	}
+
+	n, err := strconv.Atoi(*str)
+	if err != nil || n == 0 {
+		return Range{}, false
+	}
+	return Range{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,41 @@
+#!/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...>"
+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,80 @@
+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)
+	}
+}
+
+// Peak peaks at the event box if the given event is set
+func (b *EventBox) Peak(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
+	}
+}

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_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,306 +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 Regexp::IGNORECASE, 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]
-    assert_equal 2000, fzf.sort
-    assert_equal true, fzf.multi
-    assert_equal false, fzf.color
-    assert_equal 0, fzf.rxflag
-
-    # Short opts
-    fzf = FZF.new %w[-s 2000 +c -m +i]
-    assert_equal 2000, fzf.sort
-    assert_equal true, fzf.multi
-    assert_equal false, fzf.color
-    assert_equal 0, fzf.rxflag
-  end
-
-  def test_invalid_option
-    [%w[-s 2000 +s], %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_case_sensitive
-    assert_equal [['Fruit', [[0, 5]]]],
-      FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
-
-    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
-    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('!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 6, nfd.length
-      assert_equal NFD, nfd
-    end
-  end
-
-  def test_split
-    assert_equal ["a", "b", "c", "\xFF", "d", "e", "f"],
-      FZF::UConv.split("abc\xFFdef")
-  end
-end
-

test/test_go.rb

@@ -0,0 +1,278 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'minitest/autorun'
+
+class NilClass
+  def include? str
+    false
+  end
+end
+
+class Tmux
+  TEMPNAME = '/tmp/fzf-test.txt'
+
+  attr_reader :win
+
+  def initialize shell = 'bash'
+    @win = go("new-window -d -P -F '#I' 'PS1= bash --rcfile ~/.fzf.#{shell}'").first
+    @lines = `tput lines`.chomp.to_i
+  end
+
+  def closed?
+    !go("list-window -F '#I'").include?(win)
+  end
+
+  def close timeout = 1
+    send_keys 'C-c', 'C-u', 'exit', :Enter
+    wait(timeout) { closed? }
+  end
+
+  def kill
+    go("kill-window -t #{win} 2> /dev/null")
+  end
+
+  def send_keys *args
+    args = args.map { |a| %{"#{a}"} }.join ' '
+    go("send-keys -t #{win} #{args}")
+  end
+
+  def capture
+    go("capture-pane -t #{win} \\; save-buffer #{TEMPNAME}")
+    raise "Window not found" if $?.exitstatus != 0
+    File.read(TEMPNAME).split($/)[0, @lines].reverse.drop_while(&:empty?).reverse
+  end
+
+  def until timeout = 1
+    wait(timeout) { yield capture }
+  end
+
+private
+  def wait timeout = 1
+    waited = 0
+    until yield
+      waited += 0.1
+      sleep 0.1
+      if waited > timeout
+        hl = '=' * 10
+        puts hl
+        capture.each_with_index do |line, idx|
+          puts [idx.to_s.rjust(2), line].join(': ')
+        end
+        puts hl
+        raise "timeout"
+      end
+    end
+  end
+
+  def go *args
+    %x[tmux #{args.join ' '}].split($/)
+  end
+end
+
+class TestGoFZF < MiniTest::Unit::TestCase
+  attr_reader :tmux
+
+  def tempname
+    '/tmp/output'
+  end
+
+  def rmtemp
+    while File.exists? tempname
+      File.unlink tempname rescue nil
+    end
+  end
+
+  def readtemp
+    waited = 0
+    while waited < 5
+      begin
+        return File.read(tempname)
+      rescue
+        sleep 0.1
+        waited += 0.1
+      end
+    end
+    raise "failed to read tempfile"
+  end
+
+  def setup
+    ENV.delete 'FZF_DEFAULT_OPTS'
+    ENV.delete 'FZF_DEFAULT_COMMAND'
+    @tmux = Tmux.new
+    rmtemp
+  end
+
+  def teardown
+    @tmux.kill
+  end
+
+  def test_vanilla
+    tmux.send_keys "seq 1 100000 | fzf > #{tempname}", :Enter
+    tmux.until(10) { |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', readtemp.chomp
+  end
+
+  def test_fzf_default_command
+    tmux.send_keys "FZF_DEFAULT_COMMAND='echo hello' fzf > #{tempname}", :Enter
+    tmux.until { |lines| lines.last =~ /^>/ }
+
+    tmux.send_keys :Enter
+    tmux.close
+    assert_equal 'hello', readtemp.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 > #{tempname} && echo -n done", :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?('done') }
+    assert_equal %w[3 2 5 6 8 7], readtemp.split($/)
+    tmux.close
+  end
+
+  def test_with_nth
+    [true, false].each do |multi|
+      rmtemp
+
+      tmux.send_keys "(echo '  1st 2nd 3rd/';
+                       echo '  first second third/') |
+                      fzf #{"--multi" if multi} -x --nth 2 --with-nth 2,-1,1 > #{tempname} && echo -n done",
+                      :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?('done') }
+        assert_equal ['  1st 2nd 3rd/', '  first second third/'], readtemp.split($/)
+      else
+        tmux.send_keys '^', '3'
+        tmux.until { |lines| lines[-2].include?('1/2') }
+        tmux.send_keys :Enter
+        tmux.until { |lines| lines[-1].include?('done') }
+        assert_equal ['  1st 2nd 3rd/'], readtemp.split($/)
+      end
+    end
+  end
+
+  def test_scroll
+    [true, false].each do |rev|
+      rmtemp
+
+      tmux.send_keys "seq 1 100 | fzf #{'--reverse' if rev} > #{tempname} && echo -n done", :Enter
+      tmux.until { |lines| rev ? lines.first == '>' : lines.last == '>' }
+      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?('done') }
+      assert_equal '100', readtemp.chomp
+    end
+  end
+
+  def test_select_1
+    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 5555 -1 > #{tempname} && echo -n done", :Enter
+    tmux.until { |lines| lines[-1].include?('done') }
+    assert_equal ['5555', '55'], readtemp.split($/)
+  end
+
+  def test_exit_0
+    tmux.send_keys "seq 1 100 | fzf --with-nth ..,.. --print-query -q 555555 -0 > #{tempname} && echo -n done", :Enter
+    tmux.until { |lines| lines[-1].include?('done') }
+    assert_equal ['555555'], readtemp.split($/)
+  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::Unit::TestCase
+  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
+